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     PyObject * obj0 = 0 ;
17170     char *kwnames[] = {
17171         (char *) "self", NULL
17172     };
17173
17174     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_Tile",kwnames,&obj0)) goto fail;
17175     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17176     if (SWIG_arg_fail(1)) SWIG_fail;
17177     {
17178         PyThreadState* __tstate = wxPyBeginAllowThreads();
17179         (arg1)->Tile();
17180
17181         wxPyEndAllowThreads(__tstate);
17182         if (PyErr_Occurred()) SWIG_fail;
17183     }
17184     Py_INCREF(Py_None); resultobj = Py_None;
17185     return resultobj;
17186     fail:
17187     return NULL;
17188 }
17189
17190
17191 static PyObject * MDIParentFrame_swigregister(PyObject *, PyObject *args) {
17192     PyObject *obj;
17193     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17194     SWIG_TypeClientData(SWIGTYPE_p_wxMDIParentFrame, obj);
17195     Py_INCREF(obj);
17196     return Py_BuildValue((char *)"");
17197 }
17198 static PyObject *_wrap_new_MDIChildFrame(PyObject *, PyObject *args, PyObject *kwargs) {
17199     PyObject *resultobj;
17200     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17201     int arg2 = (int) (int)-1 ;
17202     wxString const &arg3_defvalue = wxPyEmptyString ;
17203     wxString *arg3 = (wxString *) &arg3_defvalue ;
17204     wxPoint const &arg4_defvalue = wxDefaultPosition ;
17205     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
17206     wxSize const &arg5_defvalue = wxDefaultSize ;
17207     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
17208     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
17209     wxString const &arg7_defvalue = wxPyFrameNameStr ;
17210     wxString *arg7 = (wxString *) &arg7_defvalue ;
17211     wxMDIChildFrame *result;
17212     bool temp3 = false ;
17213     wxPoint temp4 ;
17214     wxSize temp5 ;
17215     bool temp7 = false ;
17216     PyObject * obj0 = 0 ;
17217     PyObject * obj1 = 0 ;
17218     PyObject * obj2 = 0 ;
17219     PyObject * obj3 = 0 ;
17220     PyObject * obj4 = 0 ;
17221     PyObject * obj5 = 0 ;
17222     PyObject * obj6 = 0 ;
17223     char *kwnames[] = {
17224         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17225     };
17226
17227     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MDIChildFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
17228     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17229     if (SWIG_arg_fail(1)) SWIG_fail;
17230     if (obj1) {
17231         {
17232             arg2 = (int const)(SWIG_As_int(obj1));
17233             if (SWIG_arg_fail(2)) SWIG_fail;
17234         }
17235     }
17236     if (obj2) {
17237         {
17238             arg3 = wxString_in_helper(obj2);
17239             if (arg3 == NULL) SWIG_fail;
17240             temp3 = true;
17241         }
17242     }
17243     if (obj3) {
17244         {
17245             arg4 = &temp4;
17246             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17247         }
17248     }
17249     if (obj4) {
17250         {
17251             arg5 = &temp5;
17252             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
17253         }
17254     }
17255     if (obj5) {
17256         {
17257             arg6 = (long)(SWIG_As_long(obj5));
17258             if (SWIG_arg_fail(6)) SWIG_fail;
17259         }
17260     }
17261     if (obj6) {
17262         {
17263             arg7 = wxString_in_helper(obj6);
17264             if (arg7 == NULL) SWIG_fail;
17265             temp7 = true;
17266         }
17267     }
17268     {
17269         if (!wxPyCheckForApp()) SWIG_fail;
17270         PyThreadState* __tstate = wxPyBeginAllowThreads();
17271         result = (wxMDIChildFrame *)new wxMDIChildFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
17272
17273         wxPyEndAllowThreads(__tstate);
17274         if (PyErr_Occurred()) SWIG_fail;
17275     }
17276     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIChildFrame, 1);
17277     {
17278         if (temp3)
17279         delete arg3;
17280     }
17281     {
17282         if (temp7)
17283         delete arg7;
17284     }
17285     return resultobj;
17286     fail:
17287     {
17288         if (temp3)
17289         delete arg3;
17290     }
17291     {
17292         if (temp7)
17293         delete arg7;
17294     }
17295     return NULL;
17296 }
17297
17298
17299 static PyObject *_wrap_new_PreMDIChildFrame(PyObject *, PyObject *args, PyObject *kwargs) {
17300     PyObject *resultobj;
17301     wxMDIChildFrame *result;
17302     char *kwnames[] = {
17303         NULL
17304     };
17305
17306     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIChildFrame",kwnames)) goto fail;
17307     {
17308         if (!wxPyCheckForApp()) SWIG_fail;
17309         PyThreadState* __tstate = wxPyBeginAllowThreads();
17310         result = (wxMDIChildFrame *)new wxMDIChildFrame();
17311
17312         wxPyEndAllowThreads(__tstate);
17313         if (PyErr_Occurred()) SWIG_fail;
17314     }
17315     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIChildFrame, 1);
17316     return resultobj;
17317     fail:
17318     return NULL;
17319 }
17320
17321
17322 static PyObject *_wrap_MDIChildFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17323     PyObject *resultobj;
17324     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17325     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
17326     int arg3 = (int) (int)-1 ;
17327     wxString const &arg4_defvalue = wxPyEmptyString ;
17328     wxString *arg4 = (wxString *) &arg4_defvalue ;
17329     wxPoint const &arg5_defvalue = wxDefaultPosition ;
17330     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
17331     wxSize const &arg6_defvalue = wxDefaultSize ;
17332     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
17333     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
17334     wxString const &arg8_defvalue = wxPyFrameNameStr ;
17335     wxString *arg8 = (wxString *) &arg8_defvalue ;
17336     bool result;
17337     bool temp4 = false ;
17338     wxPoint temp5 ;
17339     wxSize temp6 ;
17340     bool temp8 = false ;
17341     PyObject * obj0 = 0 ;
17342     PyObject * obj1 = 0 ;
17343     PyObject * obj2 = 0 ;
17344     PyObject * obj3 = 0 ;
17345     PyObject * obj4 = 0 ;
17346     PyObject * obj5 = 0 ;
17347     PyObject * obj6 = 0 ;
17348     PyObject * obj7 = 0 ;
17349     char *kwnames[] = {
17350         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17351     };
17352
17353     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MDIChildFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
17354     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17355     if (SWIG_arg_fail(1)) SWIG_fail;
17356     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17357     if (SWIG_arg_fail(2)) SWIG_fail;
17358     if (obj2) {
17359         {
17360             arg3 = (int const)(SWIG_As_int(obj2));
17361             if (SWIG_arg_fail(3)) SWIG_fail;
17362         }
17363     }
17364     if (obj3) {
17365         {
17366             arg4 = wxString_in_helper(obj3);
17367             if (arg4 == NULL) SWIG_fail;
17368             temp4 = true;
17369         }
17370     }
17371     if (obj4) {
17372         {
17373             arg5 = &temp5;
17374             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
17375         }
17376     }
17377     if (obj5) {
17378         {
17379             arg6 = &temp6;
17380             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
17381         }
17382     }
17383     if (obj6) {
17384         {
17385             arg7 = (long)(SWIG_As_long(obj6));
17386             if (SWIG_arg_fail(7)) SWIG_fail;
17387         }
17388     }
17389     if (obj7) {
17390         {
17391             arg8 = wxString_in_helper(obj7);
17392             if (arg8 == NULL) SWIG_fail;
17393             temp8 = true;
17394         }
17395     }
17396     {
17397         PyThreadState* __tstate = wxPyBeginAllowThreads();
17398         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
17399
17400         wxPyEndAllowThreads(__tstate);
17401         if (PyErr_Occurred()) SWIG_fail;
17402     }
17403     {
17404         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17405     }
17406     {
17407         if (temp4)
17408         delete arg4;
17409     }
17410     {
17411         if (temp8)
17412         delete arg8;
17413     }
17414     return resultobj;
17415     fail:
17416     {
17417         if (temp4)
17418         delete arg4;
17419     }
17420     {
17421         if (temp8)
17422         delete arg8;
17423     }
17424     return NULL;
17425 }
17426
17427
17428 static PyObject *_wrap_MDIChildFrame_Activate(PyObject *, PyObject *args, PyObject *kwargs) {
17429     PyObject *resultobj;
17430     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17431     PyObject * obj0 = 0 ;
17432     char *kwnames[] = {
17433         (char *) "self", NULL
17434     };
17435
17436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIChildFrame_Activate",kwnames,&obj0)) goto fail;
17437     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17438     if (SWIG_arg_fail(1)) SWIG_fail;
17439     {
17440         PyThreadState* __tstate = wxPyBeginAllowThreads();
17441         (arg1)->Activate();
17442
17443         wxPyEndAllowThreads(__tstate);
17444         if (PyErr_Occurred()) SWIG_fail;
17445     }
17446     Py_INCREF(Py_None); resultobj = Py_None;
17447     return resultobj;
17448     fail:
17449     return NULL;
17450 }
17451
17452
17453 static PyObject *_wrap_MDIChildFrame_Maximize(PyObject *, PyObject *args, PyObject *kwargs) {
17454     PyObject *resultobj;
17455     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17456     bool arg2 = (bool) true ;
17457     PyObject * obj0 = 0 ;
17458     PyObject * obj1 = 0 ;
17459     char *kwnames[] = {
17460         (char *) "self",(char *) "maximize", NULL
17461     };
17462
17463     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MDIChildFrame_Maximize",kwnames,&obj0,&obj1)) goto fail;
17464     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17465     if (SWIG_arg_fail(1)) SWIG_fail;
17466     if (obj1) {
17467         {
17468             arg2 = (bool)(SWIG_As_bool(obj1));
17469             if (SWIG_arg_fail(2)) SWIG_fail;
17470         }
17471     }
17472     {
17473         PyThreadState* __tstate = wxPyBeginAllowThreads();
17474         (arg1)->Maximize(arg2);
17475
17476         wxPyEndAllowThreads(__tstate);
17477         if (PyErr_Occurred()) SWIG_fail;
17478     }
17479     Py_INCREF(Py_None); resultobj = Py_None;
17480     return resultobj;
17481     fail:
17482     return NULL;
17483 }
17484
17485
17486 static PyObject *_wrap_MDIChildFrame_Restore(PyObject *, PyObject *args, PyObject *kwargs) {
17487     PyObject *resultobj;
17488     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17489     PyObject * obj0 = 0 ;
17490     char *kwnames[] = {
17491         (char *) "self", NULL
17492     };
17493
17494     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIChildFrame_Restore",kwnames,&obj0)) goto fail;
17495     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17496     if (SWIG_arg_fail(1)) SWIG_fail;
17497     {
17498         PyThreadState* __tstate = wxPyBeginAllowThreads();
17499         (arg1)->Restore();
17500
17501         wxPyEndAllowThreads(__tstate);
17502         if (PyErr_Occurred()) SWIG_fail;
17503     }
17504     Py_INCREF(Py_None); resultobj = Py_None;
17505     return resultobj;
17506     fail:
17507     return NULL;
17508 }
17509
17510
17511 static PyObject * MDIChildFrame_swigregister(PyObject *, PyObject *args) {
17512     PyObject *obj;
17513     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17514     SWIG_TypeClientData(SWIGTYPE_p_wxMDIChildFrame, obj);
17515     Py_INCREF(obj);
17516     return Py_BuildValue((char *)"");
17517 }
17518 static PyObject *_wrap_new_MDIClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17519     PyObject *resultobj;
17520     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17521     long arg2 = (long) 0 ;
17522     wxMDIClientWindow *result;
17523     PyObject * obj0 = 0 ;
17524     PyObject * obj1 = 0 ;
17525     char *kwnames[] = {
17526         (char *) "parent",(char *) "style", NULL
17527     };
17528
17529     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_MDIClientWindow",kwnames,&obj0,&obj1)) goto fail;
17530     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17531     if (SWIG_arg_fail(1)) SWIG_fail;
17532     if (obj1) {
17533         {
17534             arg2 = (long)(SWIG_As_long(obj1));
17535             if (SWIG_arg_fail(2)) SWIG_fail;
17536         }
17537     }
17538     {
17539         if (!wxPyCheckForApp()) SWIG_fail;
17540         PyThreadState* __tstate = wxPyBeginAllowThreads();
17541         result = (wxMDIClientWindow *)new wxMDIClientWindow(arg1,arg2);
17542
17543         wxPyEndAllowThreads(__tstate);
17544         if (PyErr_Occurred()) SWIG_fail;
17545     }
17546     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIClientWindow, 1);
17547     return resultobj;
17548     fail:
17549     return NULL;
17550 }
17551
17552
17553 static PyObject *_wrap_new_PreMDIClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17554     PyObject *resultobj;
17555     wxMDIClientWindow *result;
17556     char *kwnames[] = {
17557         NULL
17558     };
17559
17560     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIClientWindow",kwnames)) goto fail;
17561     {
17562         if (!wxPyCheckForApp()) SWIG_fail;
17563         PyThreadState* __tstate = wxPyBeginAllowThreads();
17564         result = (wxMDIClientWindow *)new wxMDIClientWindow();
17565
17566         wxPyEndAllowThreads(__tstate);
17567         if (PyErr_Occurred()) SWIG_fail;
17568     }
17569     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIClientWindow, 1);
17570     return resultobj;
17571     fail:
17572     return NULL;
17573 }
17574
17575
17576 static PyObject *_wrap_MDIClientWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17577     PyObject *resultobj;
17578     wxMDIClientWindow *arg1 = (wxMDIClientWindow *) 0 ;
17579     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
17580     long arg3 = (long) 0 ;
17581     bool result;
17582     PyObject * obj0 = 0 ;
17583     PyObject * obj1 = 0 ;
17584     PyObject * obj2 = 0 ;
17585     char *kwnames[] = {
17586         (char *) "self",(char *) "parent",(char *) "style", NULL
17587     };
17588
17589     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MDIClientWindow_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
17590     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIClientWindow, SWIG_POINTER_EXCEPTION | 0);
17591     if (SWIG_arg_fail(1)) SWIG_fail;
17592     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17593     if (SWIG_arg_fail(2)) SWIG_fail;
17594     if (obj2) {
17595         {
17596             arg3 = (long)(SWIG_As_long(obj2));
17597             if (SWIG_arg_fail(3)) SWIG_fail;
17598         }
17599     }
17600     {
17601         PyThreadState* __tstate = wxPyBeginAllowThreads();
17602         result = (bool)(arg1)->Create(arg2,arg3);
17603
17604         wxPyEndAllowThreads(__tstate);
17605         if (PyErr_Occurred()) SWIG_fail;
17606     }
17607     {
17608         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17609     }
17610     return resultobj;
17611     fail:
17612     return NULL;
17613 }
17614
17615
17616 static PyObject * MDIClientWindow_swigregister(PyObject *, PyObject *args) {
17617     PyObject *obj;
17618     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17619     SWIG_TypeClientData(SWIGTYPE_p_wxMDIClientWindow, obj);
17620     Py_INCREF(obj);
17621     return Py_BuildValue((char *)"");
17622 }
17623 static PyObject *_wrap_new_PyWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17624     PyObject *resultobj;
17625     wxWindow *arg1 = (wxWindow *) 0 ;
17626     int arg2 = (int) (int)-1 ;
17627     wxPoint const &arg3_defvalue = wxDefaultPosition ;
17628     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
17629     wxSize const &arg4_defvalue = wxDefaultSize ;
17630     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
17631     long arg5 = (long) 0 ;
17632     wxString const &arg6_defvalue = wxPyPanelNameStr ;
17633     wxString *arg6 = (wxString *) &arg6_defvalue ;
17634     wxPyWindow *result;
17635     wxPoint temp3 ;
17636     wxSize temp4 ;
17637     bool temp6 = false ;
17638     PyObject * obj0 = 0 ;
17639     PyObject * obj1 = 0 ;
17640     PyObject * obj2 = 0 ;
17641     PyObject * obj3 = 0 ;
17642     PyObject * obj4 = 0 ;
17643     PyObject * obj5 = 0 ;
17644     char *kwnames[] = {
17645         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17646     };
17647
17648     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17649     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17650     if (SWIG_arg_fail(1)) SWIG_fail;
17651     if (obj1) {
17652         {
17653             arg2 = (int const)(SWIG_As_int(obj1));
17654             if (SWIG_arg_fail(2)) SWIG_fail;
17655         }
17656     }
17657     if (obj2) {
17658         {
17659             arg3 = &temp3;
17660             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17661         }
17662     }
17663     if (obj3) {
17664         {
17665             arg4 = &temp4;
17666             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
17667         }
17668     }
17669     if (obj4) {
17670         {
17671             arg5 = (long)(SWIG_As_long(obj4));
17672             if (SWIG_arg_fail(5)) SWIG_fail;
17673         }
17674     }
17675     if (obj5) {
17676         {
17677             arg6 = wxString_in_helper(obj5);
17678             if (arg6 == NULL) SWIG_fail;
17679             temp6 = true;
17680         }
17681     }
17682     {
17683         if (!wxPyCheckForApp()) SWIG_fail;
17684         PyThreadState* __tstate = wxPyBeginAllowThreads();
17685         result = (wxPyWindow *)new wxPyWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
17686
17687         wxPyEndAllowThreads(__tstate);
17688         if (PyErr_Occurred()) SWIG_fail;
17689     }
17690     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyWindow, 1);
17691     {
17692         if (temp6)
17693         delete arg6;
17694     }
17695     return resultobj;
17696     fail:
17697     {
17698         if (temp6)
17699         delete arg6;
17700     }
17701     return NULL;
17702 }
17703
17704
17705 static PyObject *_wrap_new_PrePyWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17706     PyObject *resultobj;
17707     wxPyWindow *result;
17708     char *kwnames[] = {
17709         NULL
17710     };
17711
17712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyWindow",kwnames)) goto fail;
17713     {
17714         if (!wxPyCheckForApp()) SWIG_fail;
17715         PyThreadState* __tstate = wxPyBeginAllowThreads();
17716         result = (wxPyWindow *)new wxPyWindow();
17717
17718         wxPyEndAllowThreads(__tstate);
17719         if (PyErr_Occurred()) SWIG_fail;
17720     }
17721     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyWindow, 1);
17722     return resultobj;
17723     fail:
17724     return NULL;
17725 }
17726
17727
17728 static PyObject *_wrap_PyWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
17729     PyObject *resultobj;
17730     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17731     PyObject *arg2 = (PyObject *) 0 ;
17732     PyObject *arg3 = (PyObject *) 0 ;
17733     PyObject * obj0 = 0 ;
17734     PyObject * obj1 = 0 ;
17735     PyObject * obj2 = 0 ;
17736     char *kwnames[] = {
17737         (char *) "self",(char *) "self",(char *) "_class", NULL
17738     };
17739
17740     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
17741     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17742     if (SWIG_arg_fail(1)) SWIG_fail;
17743     arg2 = obj1;
17744     arg3 = obj2;
17745     {
17746         PyThreadState* __tstate = wxPyBeginAllowThreads();
17747         (arg1)->_setCallbackInfo(arg2,arg3);
17748
17749         wxPyEndAllowThreads(__tstate);
17750         if (PyErr_Occurred()) SWIG_fail;
17751     }
17752     Py_INCREF(Py_None); resultobj = Py_None;
17753     return resultobj;
17754     fail:
17755     return NULL;
17756 }
17757
17758
17759 static PyObject *_wrap_PyWindow_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
17760     PyObject *resultobj;
17761     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17762     wxSize *arg2 = 0 ;
17763     wxSize temp2 ;
17764     PyObject * obj0 = 0 ;
17765     PyObject * obj1 = 0 ;
17766     char *kwnames[] = {
17767         (char *) "self",(char *) "size", NULL
17768     };
17769
17770     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
17771     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17772     if (SWIG_arg_fail(1)) SWIG_fail;
17773     {
17774         arg2 = &temp2;
17775         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17776     }
17777     {
17778         PyThreadState* __tstate = wxPyBeginAllowThreads();
17779         (arg1)->SetBestSize((wxSize const &)*arg2);
17780
17781         wxPyEndAllowThreads(__tstate);
17782         if (PyErr_Occurred()) SWIG_fail;
17783     }
17784     Py_INCREF(Py_None); resultobj = Py_None;
17785     return resultobj;
17786     fail:
17787     return NULL;
17788 }
17789
17790
17791 static PyObject *_wrap_PyWindow_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17792     PyObject *resultobj;
17793     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17794     int arg2 ;
17795     int arg3 ;
17796     int arg4 ;
17797     int arg5 ;
17798     PyObject * obj0 = 0 ;
17799     PyObject * obj1 = 0 ;
17800     PyObject * obj2 = 0 ;
17801     PyObject * obj3 = 0 ;
17802     PyObject * obj4 = 0 ;
17803     char *kwnames[] = {
17804         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
17805     };
17806
17807     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyWindow_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17808     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17809     if (SWIG_arg_fail(1)) SWIG_fail;
17810     {
17811         arg2 = (int)(SWIG_As_int(obj1));
17812         if (SWIG_arg_fail(2)) SWIG_fail;
17813     }
17814     {
17815         arg3 = (int)(SWIG_As_int(obj2));
17816         if (SWIG_arg_fail(3)) SWIG_fail;
17817     }
17818     {
17819         arg4 = (int)(SWIG_As_int(obj3));
17820         if (SWIG_arg_fail(4)) SWIG_fail;
17821     }
17822     {
17823         arg5 = (int)(SWIG_As_int(obj4));
17824         if (SWIG_arg_fail(5)) SWIG_fail;
17825     }
17826     {
17827         PyThreadState* __tstate = wxPyBeginAllowThreads();
17828         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
17829
17830         wxPyEndAllowThreads(__tstate);
17831         if (PyErr_Occurred()) SWIG_fail;
17832     }
17833     Py_INCREF(Py_None); resultobj = Py_None;
17834     return resultobj;
17835     fail:
17836     return NULL;
17837 }
17838
17839
17840 static PyObject *_wrap_PyWindow_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
17841     PyObject *resultobj;
17842     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17843     int arg2 ;
17844     int arg3 ;
17845     int arg4 ;
17846     int arg5 ;
17847     int arg6 = (int) wxSIZE_AUTO ;
17848     PyObject * obj0 = 0 ;
17849     PyObject * obj1 = 0 ;
17850     PyObject * obj2 = 0 ;
17851     PyObject * obj3 = 0 ;
17852     PyObject * obj4 = 0 ;
17853     PyObject * obj5 = 0 ;
17854     char *kwnames[] = {
17855         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
17856     };
17857
17858     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyWindow_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17859     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17860     if (SWIG_arg_fail(1)) SWIG_fail;
17861     {
17862         arg2 = (int)(SWIG_As_int(obj1));
17863         if (SWIG_arg_fail(2)) SWIG_fail;
17864     }
17865     {
17866         arg3 = (int)(SWIG_As_int(obj2));
17867         if (SWIG_arg_fail(3)) SWIG_fail;
17868     }
17869     {
17870         arg4 = (int)(SWIG_As_int(obj3));
17871         if (SWIG_arg_fail(4)) SWIG_fail;
17872     }
17873     {
17874         arg5 = (int)(SWIG_As_int(obj4));
17875         if (SWIG_arg_fail(5)) SWIG_fail;
17876     }
17877     if (obj5) {
17878         {
17879             arg6 = (int)(SWIG_As_int(obj5));
17880             if (SWIG_arg_fail(6)) SWIG_fail;
17881         }
17882     }
17883     {
17884         PyThreadState* __tstate = wxPyBeginAllowThreads();
17885         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
17886
17887         wxPyEndAllowThreads(__tstate);
17888         if (PyErr_Occurred()) SWIG_fail;
17889     }
17890     Py_INCREF(Py_None); resultobj = Py_None;
17891     return resultobj;
17892     fail:
17893     return NULL;
17894 }
17895
17896
17897 static PyObject *_wrap_PyWindow_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
17898     PyObject *resultobj;
17899     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17900     int arg2 ;
17901     int arg3 ;
17902     PyObject * obj0 = 0 ;
17903     PyObject * obj1 = 0 ;
17904     PyObject * obj2 = 0 ;
17905     char *kwnames[] = {
17906         (char *) "self",(char *) "width",(char *) "height", NULL
17907     };
17908
17909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
17910     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17911     if (SWIG_arg_fail(1)) SWIG_fail;
17912     {
17913         arg2 = (int)(SWIG_As_int(obj1));
17914         if (SWIG_arg_fail(2)) SWIG_fail;
17915     }
17916     {
17917         arg3 = (int)(SWIG_As_int(obj2));
17918         if (SWIG_arg_fail(3)) SWIG_fail;
17919     }
17920     {
17921         PyThreadState* __tstate = wxPyBeginAllowThreads();
17922         (arg1)->base_DoSetClientSize(arg2,arg3);
17923
17924         wxPyEndAllowThreads(__tstate);
17925         if (PyErr_Occurred()) SWIG_fail;
17926     }
17927     Py_INCREF(Py_None); resultobj = Py_None;
17928     return resultobj;
17929     fail:
17930     return NULL;
17931 }
17932
17933
17934 static PyObject *_wrap_PyWindow_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
17935     PyObject *resultobj;
17936     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17937     int arg2 ;
17938     int arg3 ;
17939     PyObject * obj0 = 0 ;
17940     PyObject * obj1 = 0 ;
17941     PyObject * obj2 = 0 ;
17942     char *kwnames[] = {
17943         (char *) "self",(char *) "x",(char *) "y", NULL
17944     };
17945
17946     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
17947     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17948     if (SWIG_arg_fail(1)) SWIG_fail;
17949     {
17950         arg2 = (int)(SWIG_As_int(obj1));
17951         if (SWIG_arg_fail(2)) SWIG_fail;
17952     }
17953     {
17954         arg3 = (int)(SWIG_As_int(obj2));
17955         if (SWIG_arg_fail(3)) SWIG_fail;
17956     }
17957     {
17958         PyThreadState* __tstate = wxPyBeginAllowThreads();
17959         (arg1)->base_DoSetVirtualSize(arg2,arg3);
17960
17961         wxPyEndAllowThreads(__tstate);
17962         if (PyErr_Occurred()) SWIG_fail;
17963     }
17964     Py_INCREF(Py_None); resultobj = Py_None;
17965     return resultobj;
17966     fail:
17967     return NULL;
17968 }
17969
17970
17971 static PyObject *_wrap_PyWindow_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
17972     PyObject *resultobj;
17973     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17974     int *arg2 = (int *) 0 ;
17975     int *arg3 = (int *) 0 ;
17976     int temp2 ;
17977     int res2 = 0 ;
17978     int temp3 ;
17979     int res3 = 0 ;
17980     PyObject * obj0 = 0 ;
17981     char *kwnames[] = {
17982         (char *) "self", NULL
17983     };
17984
17985     arg2 = &temp2; res2 = SWIG_NEWOBJ;
17986     arg3 = &temp3; res3 = SWIG_NEWOBJ;
17987     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetSize",kwnames,&obj0)) goto fail;
17988     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17989     if (SWIG_arg_fail(1)) SWIG_fail;
17990     {
17991         PyThreadState* __tstate = wxPyBeginAllowThreads();
17992         ((wxPyWindow const *)arg1)->base_DoGetSize(arg2,arg3);
17993
17994         wxPyEndAllowThreads(__tstate);
17995         if (PyErr_Occurred()) SWIG_fail;
17996     }
17997     Py_INCREF(Py_None); resultobj = Py_None;
17998     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17999     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18000     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18001     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18002     return resultobj;
18003     fail:
18004     return NULL;
18005 }
18006
18007
18008 static PyObject *_wrap_PyWindow_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18009     PyObject *resultobj;
18010     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18011     int *arg2 = (int *) 0 ;
18012     int *arg3 = (int *) 0 ;
18013     int temp2 ;
18014     int res2 = 0 ;
18015     int temp3 ;
18016     int res3 = 0 ;
18017     PyObject * obj0 = 0 ;
18018     char *kwnames[] = {
18019         (char *) "self", NULL
18020     };
18021
18022     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18023     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetClientSize",kwnames,&obj0)) goto fail;
18025     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18026     if (SWIG_arg_fail(1)) SWIG_fail;
18027     {
18028         PyThreadState* __tstate = wxPyBeginAllowThreads();
18029         ((wxPyWindow const *)arg1)->base_DoGetClientSize(arg2,arg3);
18030
18031         wxPyEndAllowThreads(__tstate);
18032         if (PyErr_Occurred()) SWIG_fail;
18033     }
18034     Py_INCREF(Py_None); resultobj = Py_None;
18035     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18036     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18037     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18038     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18039     return resultobj;
18040     fail:
18041     return NULL;
18042 }
18043
18044
18045 static PyObject *_wrap_PyWindow_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18046     PyObject *resultobj;
18047     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18048     int *arg2 = (int *) 0 ;
18049     int *arg3 = (int *) 0 ;
18050     int temp2 ;
18051     int res2 = 0 ;
18052     int temp3 ;
18053     int res3 = 0 ;
18054     PyObject * obj0 = 0 ;
18055     char *kwnames[] = {
18056         (char *) "self", NULL
18057     };
18058
18059     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18060     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18061     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetPosition",kwnames,&obj0)) goto fail;
18062     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18063     if (SWIG_arg_fail(1)) SWIG_fail;
18064     {
18065         PyThreadState* __tstate = wxPyBeginAllowThreads();
18066         ((wxPyWindow const *)arg1)->base_DoGetPosition(arg2,arg3);
18067
18068         wxPyEndAllowThreads(__tstate);
18069         if (PyErr_Occurred()) SWIG_fail;
18070     }
18071     Py_INCREF(Py_None); resultobj = Py_None;
18072     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18073     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18074     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18075     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18076     return resultobj;
18077     fail:
18078     return NULL;
18079 }
18080
18081
18082 static PyObject *_wrap_PyWindow_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18083     PyObject *resultobj;
18084     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18085     wxSize result;
18086     PyObject * obj0 = 0 ;
18087     char *kwnames[] = {
18088         (char *) "self", NULL
18089     };
18090
18091     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
18092     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18093     if (SWIG_arg_fail(1)) SWIG_fail;
18094     {
18095         PyThreadState* __tstate = wxPyBeginAllowThreads();
18096         result = ((wxPyWindow const *)arg1)->base_DoGetVirtualSize();
18097
18098         wxPyEndAllowThreads(__tstate);
18099         if (PyErr_Occurred()) SWIG_fail;
18100     }
18101     {
18102         wxSize * resultptr;
18103         resultptr = new wxSize((wxSize &)(result));
18104         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18105     }
18106     return resultobj;
18107     fail:
18108     return NULL;
18109 }
18110
18111
18112 static PyObject *_wrap_PyWindow_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18113     PyObject *resultobj;
18114     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18115     wxSize result;
18116     PyObject * obj0 = 0 ;
18117     char *kwnames[] = {
18118         (char *) "self", NULL
18119     };
18120
18121     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetBestSize",kwnames,&obj0)) goto fail;
18122     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18123     if (SWIG_arg_fail(1)) SWIG_fail;
18124     {
18125         PyThreadState* __tstate = wxPyBeginAllowThreads();
18126         result = ((wxPyWindow const *)arg1)->base_DoGetBestSize();
18127
18128         wxPyEndAllowThreads(__tstate);
18129         if (PyErr_Occurred()) SWIG_fail;
18130     }
18131     {
18132         wxSize * resultptr;
18133         resultptr = new wxSize((wxSize &)(result));
18134         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18135     }
18136     return resultobj;
18137     fail:
18138     return NULL;
18139 }
18140
18141
18142 static PyObject *_wrap_PyWindow_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
18143     PyObject *resultobj;
18144     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18145     PyObject * obj0 = 0 ;
18146     char *kwnames[] = {
18147         (char *) "self", NULL
18148     };
18149
18150     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_InitDialog",kwnames,&obj0)) goto fail;
18151     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18152     if (SWIG_arg_fail(1)) SWIG_fail;
18153     {
18154         PyThreadState* __tstate = wxPyBeginAllowThreads();
18155         (arg1)->base_InitDialog();
18156
18157         wxPyEndAllowThreads(__tstate);
18158         if (PyErr_Occurred()) SWIG_fail;
18159     }
18160     Py_INCREF(Py_None); resultobj = Py_None;
18161     return resultobj;
18162     fail:
18163     return NULL;
18164 }
18165
18166
18167 static PyObject *_wrap_PyWindow_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18168     PyObject *resultobj;
18169     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18170     bool result;
18171     PyObject * obj0 = 0 ;
18172     char *kwnames[] = {
18173         (char *) "self", NULL
18174     };
18175
18176     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
18177     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18178     if (SWIG_arg_fail(1)) SWIG_fail;
18179     {
18180         PyThreadState* __tstate = wxPyBeginAllowThreads();
18181         result = (bool)(arg1)->base_TransferDataToWindow();
18182
18183         wxPyEndAllowThreads(__tstate);
18184         if (PyErr_Occurred()) SWIG_fail;
18185     }
18186     {
18187         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18188     }
18189     return resultobj;
18190     fail:
18191     return NULL;
18192 }
18193
18194
18195 static PyObject *_wrap_PyWindow_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18196     PyObject *resultobj;
18197     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18198     bool result;
18199     PyObject * obj0 = 0 ;
18200     char *kwnames[] = {
18201         (char *) "self", NULL
18202     };
18203
18204     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
18205     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18206     if (SWIG_arg_fail(1)) SWIG_fail;
18207     {
18208         PyThreadState* __tstate = wxPyBeginAllowThreads();
18209         result = (bool)(arg1)->base_TransferDataFromWindow();
18210
18211         wxPyEndAllowThreads(__tstate);
18212         if (PyErr_Occurred()) SWIG_fail;
18213     }
18214     {
18215         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18216     }
18217     return resultobj;
18218     fail:
18219     return NULL;
18220 }
18221
18222
18223 static PyObject *_wrap_PyWindow_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
18224     PyObject *resultobj;
18225     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18226     bool result;
18227     PyObject * obj0 = 0 ;
18228     char *kwnames[] = {
18229         (char *) "self", NULL
18230     };
18231
18232     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_Validate",kwnames,&obj0)) goto fail;
18233     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18234     if (SWIG_arg_fail(1)) SWIG_fail;
18235     {
18236         PyThreadState* __tstate = wxPyBeginAllowThreads();
18237         result = (bool)(arg1)->base_Validate();
18238
18239         wxPyEndAllowThreads(__tstate);
18240         if (PyErr_Occurred()) SWIG_fail;
18241     }
18242     {
18243         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18244     }
18245     return resultobj;
18246     fail:
18247     return NULL;
18248 }
18249
18250
18251 static PyObject *_wrap_PyWindow_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
18252     PyObject *resultobj;
18253     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18254     bool result;
18255     PyObject * obj0 = 0 ;
18256     char *kwnames[] = {
18257         (char *) "self", NULL
18258     };
18259
18260     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_AcceptsFocus",kwnames,&obj0)) goto fail;
18261     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18262     if (SWIG_arg_fail(1)) SWIG_fail;
18263     {
18264         PyThreadState* __tstate = wxPyBeginAllowThreads();
18265         result = (bool)((wxPyWindow const *)arg1)->base_AcceptsFocus();
18266
18267         wxPyEndAllowThreads(__tstate);
18268         if (PyErr_Occurred()) SWIG_fail;
18269     }
18270     {
18271         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18272     }
18273     return resultobj;
18274     fail:
18275     return NULL;
18276 }
18277
18278
18279 static PyObject *_wrap_PyWindow_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
18280     PyObject *resultobj;
18281     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18282     bool result;
18283     PyObject * obj0 = 0 ;
18284     char *kwnames[] = {
18285         (char *) "self", NULL
18286     };
18287
18288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
18289     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18290     if (SWIG_arg_fail(1)) SWIG_fail;
18291     {
18292         PyThreadState* __tstate = wxPyBeginAllowThreads();
18293         result = (bool)((wxPyWindow const *)arg1)->base_AcceptsFocusFromKeyboard();
18294
18295         wxPyEndAllowThreads(__tstate);
18296         if (PyErr_Occurred()) SWIG_fail;
18297     }
18298     {
18299         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18300     }
18301     return resultobj;
18302     fail:
18303     return NULL;
18304 }
18305
18306
18307 static PyObject *_wrap_PyWindow_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
18308     PyObject *resultobj;
18309     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18310     wxSize result;
18311     PyObject * obj0 = 0 ;
18312     char *kwnames[] = {
18313         (char *) "self", NULL
18314     };
18315
18316     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_GetMaxSize",kwnames,&obj0)) goto fail;
18317     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18318     if (SWIG_arg_fail(1)) SWIG_fail;
18319     {
18320         PyThreadState* __tstate = wxPyBeginAllowThreads();
18321         result = ((wxPyWindow const *)arg1)->base_GetMaxSize();
18322
18323         wxPyEndAllowThreads(__tstate);
18324         if (PyErr_Occurred()) SWIG_fail;
18325     }
18326     {
18327         wxSize * resultptr;
18328         resultptr = new wxSize((wxSize &)(result));
18329         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18330     }
18331     return resultobj;
18332     fail:
18333     return NULL;
18334 }
18335
18336
18337 static PyObject *_wrap_PyWindow_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
18338     PyObject *resultobj;
18339     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18340     wxWindow *arg2 = (wxWindow *) 0 ;
18341     PyObject * obj0 = 0 ;
18342     PyObject * obj1 = 0 ;
18343     char *kwnames[] = {
18344         (char *) "self",(char *) "child", NULL
18345     };
18346
18347     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
18348     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18349     if (SWIG_arg_fail(1)) SWIG_fail;
18350     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18351     if (SWIG_arg_fail(2)) SWIG_fail;
18352     {
18353         PyThreadState* __tstate = wxPyBeginAllowThreads();
18354         (arg1)->base_AddChild(arg2);
18355
18356         wxPyEndAllowThreads(__tstate);
18357         if (PyErr_Occurred()) SWIG_fail;
18358     }
18359     Py_INCREF(Py_None); resultobj = Py_None;
18360     return resultobj;
18361     fail:
18362     return NULL;
18363 }
18364
18365
18366 static PyObject *_wrap_PyWindow_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
18367     PyObject *resultobj;
18368     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18369     wxWindow *arg2 = (wxWindow *) 0 ;
18370     PyObject * obj0 = 0 ;
18371     PyObject * obj1 = 0 ;
18372     char *kwnames[] = {
18373         (char *) "self",(char *) "child", NULL
18374     };
18375
18376     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
18377     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18378     if (SWIG_arg_fail(1)) SWIG_fail;
18379     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18380     if (SWIG_arg_fail(2)) SWIG_fail;
18381     {
18382         PyThreadState* __tstate = wxPyBeginAllowThreads();
18383         (arg1)->base_RemoveChild(arg2);
18384
18385         wxPyEndAllowThreads(__tstate);
18386         if (PyErr_Occurred()) SWIG_fail;
18387     }
18388     Py_INCREF(Py_None); resultobj = Py_None;
18389     return resultobj;
18390     fail:
18391     return NULL;
18392 }
18393
18394
18395 static PyObject *_wrap_PyWindow_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
18396     PyObject *resultobj;
18397     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18398     bool result;
18399     PyObject * obj0 = 0 ;
18400     char *kwnames[] = {
18401         (char *) "self", NULL
18402     };
18403
18404     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
18405     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18406     if (SWIG_arg_fail(1)) SWIG_fail;
18407     {
18408         PyThreadState* __tstate = wxPyBeginAllowThreads();
18409         result = (bool)((wxPyWindow const *)arg1)->base_ShouldInheritColours();
18410
18411         wxPyEndAllowThreads(__tstate);
18412         if (PyErr_Occurred()) SWIG_fail;
18413     }
18414     {
18415         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18416     }
18417     return resultobj;
18418     fail:
18419     return NULL;
18420 }
18421
18422
18423 static PyObject *_wrap_PyWindow_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
18424     PyObject *resultobj;
18425     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18426     wxColour *arg2 = 0 ;
18427     wxColour temp2 ;
18428     PyObject * obj0 = 0 ;
18429     PyObject * obj1 = 0 ;
18430     char *kwnames[] = {
18431         (char *) "self",(char *) "c", NULL
18432     };
18433
18434     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
18435     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18436     if (SWIG_arg_fail(1)) SWIG_fail;
18437     {
18438         arg2 = &temp2;
18439         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18440     }
18441     {
18442         PyThreadState* __tstate = wxPyBeginAllowThreads();
18443         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
18444
18445         wxPyEndAllowThreads(__tstate);
18446         if (PyErr_Occurred()) SWIG_fail;
18447     }
18448     Py_INCREF(Py_None); resultobj = Py_None;
18449     return resultobj;
18450     fail:
18451     return NULL;
18452 }
18453
18454
18455 static PyObject *_wrap_PyWindow_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
18456     PyObject *resultobj;
18457     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18458     wxVisualAttributes result;
18459     PyObject * obj0 = 0 ;
18460     char *kwnames[] = {
18461         (char *) "self", NULL
18462     };
18463
18464     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
18465     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18466     if (SWIG_arg_fail(1)) SWIG_fail;
18467     {
18468         PyThreadState* __tstate = wxPyBeginAllowThreads();
18469         result = (arg1)->base_GetDefaultAttributes();
18470
18471         wxPyEndAllowThreads(__tstate);
18472         if (PyErr_Occurred()) SWIG_fail;
18473     }
18474     {
18475         wxVisualAttributes * resultptr;
18476         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
18477         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
18478     }
18479     return resultobj;
18480     fail:
18481     return NULL;
18482 }
18483
18484
18485 static PyObject * PyWindow_swigregister(PyObject *, PyObject *args) {
18486     PyObject *obj;
18487     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18488     SWIG_TypeClientData(SWIGTYPE_p_wxPyWindow, obj);
18489     Py_INCREF(obj);
18490     return Py_BuildValue((char *)"");
18491 }
18492 static PyObject *_wrap_new_PyPanel(PyObject *, PyObject *args, PyObject *kwargs) {
18493     PyObject *resultobj;
18494     wxWindow *arg1 = (wxWindow *) 0 ;
18495     int arg2 = (int) (int)-1 ;
18496     wxPoint const &arg3_defvalue = wxDefaultPosition ;
18497     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
18498     wxSize const &arg4_defvalue = wxDefaultSize ;
18499     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
18500     long arg5 = (long) 0 ;
18501     wxString const &arg6_defvalue = wxPyPanelNameStr ;
18502     wxString *arg6 = (wxString *) &arg6_defvalue ;
18503     wxPyPanel *result;
18504     wxPoint temp3 ;
18505     wxSize temp4 ;
18506     bool temp6 = false ;
18507     PyObject * obj0 = 0 ;
18508     PyObject * obj1 = 0 ;
18509     PyObject * obj2 = 0 ;
18510     PyObject * obj3 = 0 ;
18511     PyObject * obj4 = 0 ;
18512     PyObject * obj5 = 0 ;
18513     char *kwnames[] = {
18514         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
18515     };
18516
18517     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyPanel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18518     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18519     if (SWIG_arg_fail(1)) SWIG_fail;
18520     if (obj1) {
18521         {
18522             arg2 = (int const)(SWIG_As_int(obj1));
18523             if (SWIG_arg_fail(2)) SWIG_fail;
18524         }
18525     }
18526     if (obj2) {
18527         {
18528             arg3 = &temp3;
18529             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18530         }
18531     }
18532     if (obj3) {
18533         {
18534             arg4 = &temp4;
18535             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
18536         }
18537     }
18538     if (obj4) {
18539         {
18540             arg5 = (long)(SWIG_As_long(obj4));
18541             if (SWIG_arg_fail(5)) SWIG_fail;
18542         }
18543     }
18544     if (obj5) {
18545         {
18546             arg6 = wxString_in_helper(obj5);
18547             if (arg6 == NULL) SWIG_fail;
18548             temp6 = true;
18549         }
18550     }
18551     {
18552         if (!wxPyCheckForApp()) SWIG_fail;
18553         PyThreadState* __tstate = wxPyBeginAllowThreads();
18554         result = (wxPyPanel *)new wxPyPanel(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
18555
18556         wxPyEndAllowThreads(__tstate);
18557         if (PyErr_Occurred()) SWIG_fail;
18558     }
18559     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPanel, 1);
18560     {
18561         if (temp6)
18562         delete arg6;
18563     }
18564     return resultobj;
18565     fail:
18566     {
18567         if (temp6)
18568         delete arg6;
18569     }
18570     return NULL;
18571 }
18572
18573
18574 static PyObject *_wrap_new_PrePyPanel(PyObject *, PyObject *args, PyObject *kwargs) {
18575     PyObject *resultobj;
18576     wxPyPanel *result;
18577     char *kwnames[] = {
18578         NULL
18579     };
18580
18581     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyPanel",kwnames)) goto fail;
18582     {
18583         if (!wxPyCheckForApp()) SWIG_fail;
18584         PyThreadState* __tstate = wxPyBeginAllowThreads();
18585         result = (wxPyPanel *)new wxPyPanel();
18586
18587         wxPyEndAllowThreads(__tstate);
18588         if (PyErr_Occurred()) SWIG_fail;
18589     }
18590     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPanel, 1);
18591     return resultobj;
18592     fail:
18593     return NULL;
18594 }
18595
18596
18597 static PyObject *_wrap_PyPanel__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
18598     PyObject *resultobj;
18599     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18600     PyObject *arg2 = (PyObject *) 0 ;
18601     PyObject *arg3 = (PyObject *) 0 ;
18602     PyObject * obj0 = 0 ;
18603     PyObject * obj1 = 0 ;
18604     PyObject * obj2 = 0 ;
18605     char *kwnames[] = {
18606         (char *) "self",(char *) "self",(char *) "_class", NULL
18607     };
18608
18609     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
18610     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18611     if (SWIG_arg_fail(1)) SWIG_fail;
18612     arg2 = obj1;
18613     arg3 = obj2;
18614     {
18615         PyThreadState* __tstate = wxPyBeginAllowThreads();
18616         (arg1)->_setCallbackInfo(arg2,arg3);
18617
18618         wxPyEndAllowThreads(__tstate);
18619         if (PyErr_Occurred()) SWIG_fail;
18620     }
18621     Py_INCREF(Py_None); resultobj = Py_None;
18622     return resultobj;
18623     fail:
18624     return NULL;
18625 }
18626
18627
18628 static PyObject *_wrap_PyPanel_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18629     PyObject *resultobj;
18630     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18631     wxSize *arg2 = 0 ;
18632     wxSize temp2 ;
18633     PyObject * obj0 = 0 ;
18634     PyObject * obj1 = 0 ;
18635     char *kwnames[] = {
18636         (char *) "self",(char *) "size", NULL
18637     };
18638
18639     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
18640     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18641     if (SWIG_arg_fail(1)) SWIG_fail;
18642     {
18643         arg2 = &temp2;
18644         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18645     }
18646     {
18647         PyThreadState* __tstate = wxPyBeginAllowThreads();
18648         (arg1)->SetBestSize((wxSize const &)*arg2);
18649
18650         wxPyEndAllowThreads(__tstate);
18651         if (PyErr_Occurred()) SWIG_fail;
18652     }
18653     Py_INCREF(Py_None); resultobj = Py_None;
18654     return resultobj;
18655     fail:
18656     return NULL;
18657 }
18658
18659
18660 static PyObject *_wrap_PyPanel_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18661     PyObject *resultobj;
18662     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18663     int arg2 ;
18664     int arg3 ;
18665     int arg4 ;
18666     int arg5 ;
18667     PyObject * obj0 = 0 ;
18668     PyObject * obj1 = 0 ;
18669     PyObject * obj2 = 0 ;
18670     PyObject * obj3 = 0 ;
18671     PyObject * obj4 = 0 ;
18672     char *kwnames[] = {
18673         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18674     };
18675
18676     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyPanel_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18677     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18678     if (SWIG_arg_fail(1)) SWIG_fail;
18679     {
18680         arg2 = (int)(SWIG_As_int(obj1));
18681         if (SWIG_arg_fail(2)) SWIG_fail;
18682     }
18683     {
18684         arg3 = (int)(SWIG_As_int(obj2));
18685         if (SWIG_arg_fail(3)) SWIG_fail;
18686     }
18687     {
18688         arg4 = (int)(SWIG_As_int(obj3));
18689         if (SWIG_arg_fail(4)) SWIG_fail;
18690     }
18691     {
18692         arg5 = (int)(SWIG_As_int(obj4));
18693         if (SWIG_arg_fail(5)) SWIG_fail;
18694     }
18695     {
18696         PyThreadState* __tstate = wxPyBeginAllowThreads();
18697         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
18698
18699         wxPyEndAllowThreads(__tstate);
18700         if (PyErr_Occurred()) SWIG_fail;
18701     }
18702     Py_INCREF(Py_None); resultobj = Py_None;
18703     return resultobj;
18704     fail:
18705     return NULL;
18706 }
18707
18708
18709 static PyObject *_wrap_PyPanel_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18710     PyObject *resultobj;
18711     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18712     int arg2 ;
18713     int arg3 ;
18714     int arg4 ;
18715     int arg5 ;
18716     int arg6 = (int) wxSIZE_AUTO ;
18717     PyObject * obj0 = 0 ;
18718     PyObject * obj1 = 0 ;
18719     PyObject * obj2 = 0 ;
18720     PyObject * obj3 = 0 ;
18721     PyObject * obj4 = 0 ;
18722     PyObject * obj5 = 0 ;
18723     char *kwnames[] = {
18724         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
18725     };
18726
18727     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyPanel_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18728     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18729     if (SWIG_arg_fail(1)) SWIG_fail;
18730     {
18731         arg2 = (int)(SWIG_As_int(obj1));
18732         if (SWIG_arg_fail(2)) SWIG_fail;
18733     }
18734     {
18735         arg3 = (int)(SWIG_As_int(obj2));
18736         if (SWIG_arg_fail(3)) SWIG_fail;
18737     }
18738     {
18739         arg4 = (int)(SWIG_As_int(obj3));
18740         if (SWIG_arg_fail(4)) SWIG_fail;
18741     }
18742     {
18743         arg5 = (int)(SWIG_As_int(obj4));
18744         if (SWIG_arg_fail(5)) SWIG_fail;
18745     }
18746     if (obj5) {
18747         {
18748             arg6 = (int)(SWIG_As_int(obj5));
18749             if (SWIG_arg_fail(6)) SWIG_fail;
18750         }
18751     }
18752     {
18753         PyThreadState* __tstate = wxPyBeginAllowThreads();
18754         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
18755
18756         wxPyEndAllowThreads(__tstate);
18757         if (PyErr_Occurred()) SWIG_fail;
18758     }
18759     Py_INCREF(Py_None); resultobj = Py_None;
18760     return resultobj;
18761     fail:
18762     return NULL;
18763 }
18764
18765
18766 static PyObject *_wrap_PyPanel_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18767     PyObject *resultobj;
18768     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18769     int arg2 ;
18770     int arg3 ;
18771     PyObject * obj0 = 0 ;
18772     PyObject * obj1 = 0 ;
18773     PyObject * obj2 = 0 ;
18774     char *kwnames[] = {
18775         (char *) "self",(char *) "width",(char *) "height", NULL
18776     };
18777
18778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18779     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18780     if (SWIG_arg_fail(1)) SWIG_fail;
18781     {
18782         arg2 = (int)(SWIG_As_int(obj1));
18783         if (SWIG_arg_fail(2)) SWIG_fail;
18784     }
18785     {
18786         arg3 = (int)(SWIG_As_int(obj2));
18787         if (SWIG_arg_fail(3)) SWIG_fail;
18788     }
18789     {
18790         PyThreadState* __tstate = wxPyBeginAllowThreads();
18791         (arg1)->base_DoSetClientSize(arg2,arg3);
18792
18793         wxPyEndAllowThreads(__tstate);
18794         if (PyErr_Occurred()) SWIG_fail;
18795     }
18796     Py_INCREF(Py_None); resultobj = Py_None;
18797     return resultobj;
18798     fail:
18799     return NULL;
18800 }
18801
18802
18803 static PyObject *_wrap_PyPanel_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18804     PyObject *resultobj;
18805     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18806     int arg2 ;
18807     int arg3 ;
18808     PyObject * obj0 = 0 ;
18809     PyObject * obj1 = 0 ;
18810     PyObject * obj2 = 0 ;
18811     char *kwnames[] = {
18812         (char *) "self",(char *) "x",(char *) "y", NULL
18813     };
18814
18815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18816     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18817     if (SWIG_arg_fail(1)) SWIG_fail;
18818     {
18819         arg2 = (int)(SWIG_As_int(obj1));
18820         if (SWIG_arg_fail(2)) SWIG_fail;
18821     }
18822     {
18823         arg3 = (int)(SWIG_As_int(obj2));
18824         if (SWIG_arg_fail(3)) SWIG_fail;
18825     }
18826     {
18827         PyThreadState* __tstate = wxPyBeginAllowThreads();
18828         (arg1)->base_DoSetVirtualSize(arg2,arg3);
18829
18830         wxPyEndAllowThreads(__tstate);
18831         if (PyErr_Occurred()) SWIG_fail;
18832     }
18833     Py_INCREF(Py_None); resultobj = Py_None;
18834     return resultobj;
18835     fail:
18836     return NULL;
18837 }
18838
18839
18840 static PyObject *_wrap_PyPanel_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18841     PyObject *resultobj;
18842     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18843     int *arg2 = (int *) 0 ;
18844     int *arg3 = (int *) 0 ;
18845     int temp2 ;
18846     int res2 = 0 ;
18847     int temp3 ;
18848     int res3 = 0 ;
18849     PyObject * obj0 = 0 ;
18850     char *kwnames[] = {
18851         (char *) "self", NULL
18852     };
18853
18854     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18855     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18856     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetSize",kwnames,&obj0)) goto fail;
18857     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18858     if (SWIG_arg_fail(1)) SWIG_fail;
18859     {
18860         PyThreadState* __tstate = wxPyBeginAllowThreads();
18861         ((wxPyPanel const *)arg1)->base_DoGetSize(arg2,arg3);
18862
18863         wxPyEndAllowThreads(__tstate);
18864         if (PyErr_Occurred()) SWIG_fail;
18865     }
18866     Py_INCREF(Py_None); resultobj = Py_None;
18867     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18868     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18869     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18870     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18871     return resultobj;
18872     fail:
18873     return NULL;
18874 }
18875
18876
18877 static PyObject *_wrap_PyPanel_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18878     PyObject *resultobj;
18879     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18880     int *arg2 = (int *) 0 ;
18881     int *arg3 = (int *) 0 ;
18882     int temp2 ;
18883     int res2 = 0 ;
18884     int temp3 ;
18885     int res3 = 0 ;
18886     PyObject * obj0 = 0 ;
18887     char *kwnames[] = {
18888         (char *) "self", NULL
18889     };
18890
18891     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18892     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18893     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetClientSize",kwnames,&obj0)) goto fail;
18894     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18895     if (SWIG_arg_fail(1)) SWIG_fail;
18896     {
18897         PyThreadState* __tstate = wxPyBeginAllowThreads();
18898         ((wxPyPanel const *)arg1)->base_DoGetClientSize(arg2,arg3);
18899
18900         wxPyEndAllowThreads(__tstate);
18901         if (PyErr_Occurred()) SWIG_fail;
18902     }
18903     Py_INCREF(Py_None); resultobj = Py_None;
18904     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18905     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18906     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18907     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18908     return resultobj;
18909     fail:
18910     return NULL;
18911 }
18912
18913
18914 static PyObject *_wrap_PyPanel_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18915     PyObject *resultobj;
18916     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18917     int *arg2 = (int *) 0 ;
18918     int *arg3 = (int *) 0 ;
18919     int temp2 ;
18920     int res2 = 0 ;
18921     int temp3 ;
18922     int res3 = 0 ;
18923     PyObject * obj0 = 0 ;
18924     char *kwnames[] = {
18925         (char *) "self", NULL
18926     };
18927
18928     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18929     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18930     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetPosition",kwnames,&obj0)) goto fail;
18931     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18932     if (SWIG_arg_fail(1)) SWIG_fail;
18933     {
18934         PyThreadState* __tstate = wxPyBeginAllowThreads();
18935         ((wxPyPanel const *)arg1)->base_DoGetPosition(arg2,arg3);
18936
18937         wxPyEndAllowThreads(__tstate);
18938         if (PyErr_Occurred()) SWIG_fail;
18939     }
18940     Py_INCREF(Py_None); resultobj = Py_None;
18941     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18942     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18943     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18944     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18945     return resultobj;
18946     fail:
18947     return NULL;
18948 }
18949
18950
18951 static PyObject *_wrap_PyPanel_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18952     PyObject *resultobj;
18953     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18954     wxSize result;
18955     PyObject * obj0 = 0 ;
18956     char *kwnames[] = {
18957         (char *) "self", NULL
18958     };
18959
18960     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
18961     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18962     if (SWIG_arg_fail(1)) SWIG_fail;
18963     {
18964         PyThreadState* __tstate = wxPyBeginAllowThreads();
18965         result = ((wxPyPanel const *)arg1)->base_DoGetVirtualSize();
18966
18967         wxPyEndAllowThreads(__tstate);
18968         if (PyErr_Occurred()) SWIG_fail;
18969     }
18970     {
18971         wxSize * resultptr;
18972         resultptr = new wxSize((wxSize &)(result));
18973         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18974     }
18975     return resultobj;
18976     fail:
18977     return NULL;
18978 }
18979
18980
18981 static PyObject *_wrap_PyPanel_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18982     PyObject *resultobj;
18983     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18984     wxSize result;
18985     PyObject * obj0 = 0 ;
18986     char *kwnames[] = {
18987         (char *) "self", NULL
18988     };
18989
18990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetBestSize",kwnames,&obj0)) goto fail;
18991     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18992     if (SWIG_arg_fail(1)) SWIG_fail;
18993     {
18994         PyThreadState* __tstate = wxPyBeginAllowThreads();
18995         result = ((wxPyPanel const *)arg1)->base_DoGetBestSize();
18996
18997         wxPyEndAllowThreads(__tstate);
18998         if (PyErr_Occurred()) SWIG_fail;
18999     }
19000     {
19001         wxSize * resultptr;
19002         resultptr = new wxSize((wxSize &)(result));
19003         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19004     }
19005     return resultobj;
19006     fail:
19007     return NULL;
19008 }
19009
19010
19011 static PyObject *_wrap_PyPanel_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
19012     PyObject *resultobj;
19013     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19014     PyObject * obj0 = 0 ;
19015     char *kwnames[] = {
19016         (char *) "self", NULL
19017     };
19018
19019     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_InitDialog",kwnames,&obj0)) goto fail;
19020     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19021     if (SWIG_arg_fail(1)) SWIG_fail;
19022     {
19023         PyThreadState* __tstate = wxPyBeginAllowThreads();
19024         (arg1)->base_InitDialog();
19025
19026         wxPyEndAllowThreads(__tstate);
19027         if (PyErr_Occurred()) SWIG_fail;
19028     }
19029     Py_INCREF(Py_None); resultobj = Py_None;
19030     return resultobj;
19031     fail:
19032     return NULL;
19033 }
19034
19035
19036 static PyObject *_wrap_PyPanel_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19037     PyObject *resultobj;
19038     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19039     bool result;
19040     PyObject * obj0 = 0 ;
19041     char *kwnames[] = {
19042         (char *) "self", NULL
19043     };
19044
19045     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
19046     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19047     if (SWIG_arg_fail(1)) SWIG_fail;
19048     {
19049         PyThreadState* __tstate = wxPyBeginAllowThreads();
19050         result = (bool)(arg1)->base_TransferDataToWindow();
19051
19052         wxPyEndAllowThreads(__tstate);
19053         if (PyErr_Occurred()) SWIG_fail;
19054     }
19055     {
19056         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19057     }
19058     return resultobj;
19059     fail:
19060     return NULL;
19061 }
19062
19063
19064 static PyObject *_wrap_PyPanel_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19065     PyObject *resultobj;
19066     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19067     bool result;
19068     PyObject * obj0 = 0 ;
19069     char *kwnames[] = {
19070         (char *) "self", NULL
19071     };
19072
19073     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
19074     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19075     if (SWIG_arg_fail(1)) SWIG_fail;
19076     {
19077         PyThreadState* __tstate = wxPyBeginAllowThreads();
19078         result = (bool)(arg1)->base_TransferDataFromWindow();
19079
19080         wxPyEndAllowThreads(__tstate);
19081         if (PyErr_Occurred()) SWIG_fail;
19082     }
19083     {
19084         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19085     }
19086     return resultobj;
19087     fail:
19088     return NULL;
19089 }
19090
19091
19092 static PyObject *_wrap_PyPanel_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
19093     PyObject *resultobj;
19094     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19095     bool result;
19096     PyObject * obj0 = 0 ;
19097     char *kwnames[] = {
19098         (char *) "self", NULL
19099     };
19100
19101     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_Validate",kwnames,&obj0)) goto fail;
19102     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19103     if (SWIG_arg_fail(1)) SWIG_fail;
19104     {
19105         PyThreadState* __tstate = wxPyBeginAllowThreads();
19106         result = (bool)(arg1)->base_Validate();
19107
19108         wxPyEndAllowThreads(__tstate);
19109         if (PyErr_Occurred()) SWIG_fail;
19110     }
19111     {
19112         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19113     }
19114     return resultobj;
19115     fail:
19116     return NULL;
19117 }
19118
19119
19120 static PyObject *_wrap_PyPanel_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
19121     PyObject *resultobj;
19122     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19123     bool result;
19124     PyObject * obj0 = 0 ;
19125     char *kwnames[] = {
19126         (char *) "self", NULL
19127     };
19128
19129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_AcceptsFocus",kwnames,&obj0)) goto fail;
19130     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19131     if (SWIG_arg_fail(1)) SWIG_fail;
19132     {
19133         PyThreadState* __tstate = wxPyBeginAllowThreads();
19134         result = (bool)((wxPyPanel const *)arg1)->base_AcceptsFocus();
19135
19136         wxPyEndAllowThreads(__tstate);
19137         if (PyErr_Occurred()) SWIG_fail;
19138     }
19139     {
19140         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19141     }
19142     return resultobj;
19143     fail:
19144     return NULL;
19145 }
19146
19147
19148 static PyObject *_wrap_PyPanel_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
19149     PyObject *resultobj;
19150     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19151     bool result;
19152     PyObject * obj0 = 0 ;
19153     char *kwnames[] = {
19154         (char *) "self", NULL
19155     };
19156
19157     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
19158     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19159     if (SWIG_arg_fail(1)) SWIG_fail;
19160     {
19161         PyThreadState* __tstate = wxPyBeginAllowThreads();
19162         result = (bool)((wxPyPanel const *)arg1)->base_AcceptsFocusFromKeyboard();
19163
19164         wxPyEndAllowThreads(__tstate);
19165         if (PyErr_Occurred()) SWIG_fail;
19166     }
19167     {
19168         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19169     }
19170     return resultobj;
19171     fail:
19172     return NULL;
19173 }
19174
19175
19176 static PyObject *_wrap_PyPanel_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
19177     PyObject *resultobj;
19178     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19179     wxSize result;
19180     PyObject * obj0 = 0 ;
19181     char *kwnames[] = {
19182         (char *) "self", NULL
19183     };
19184
19185     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_GetMaxSize",kwnames,&obj0)) goto fail;
19186     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19187     if (SWIG_arg_fail(1)) SWIG_fail;
19188     {
19189         PyThreadState* __tstate = wxPyBeginAllowThreads();
19190         result = ((wxPyPanel const *)arg1)->base_GetMaxSize();
19191
19192         wxPyEndAllowThreads(__tstate);
19193         if (PyErr_Occurred()) SWIG_fail;
19194     }
19195     {
19196         wxSize * resultptr;
19197         resultptr = new wxSize((wxSize &)(result));
19198         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19199     }
19200     return resultobj;
19201     fail:
19202     return NULL;
19203 }
19204
19205
19206 static PyObject *_wrap_PyPanel_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
19207     PyObject *resultobj;
19208     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19209     wxWindow *arg2 = (wxWindow *) 0 ;
19210     PyObject * obj0 = 0 ;
19211     PyObject * obj1 = 0 ;
19212     char *kwnames[] = {
19213         (char *) "self",(char *) "child", NULL
19214     };
19215
19216     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
19217     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19218     if (SWIG_arg_fail(1)) SWIG_fail;
19219     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19220     if (SWIG_arg_fail(2)) SWIG_fail;
19221     {
19222         PyThreadState* __tstate = wxPyBeginAllowThreads();
19223         (arg1)->base_AddChild(arg2);
19224
19225         wxPyEndAllowThreads(__tstate);
19226         if (PyErr_Occurred()) SWIG_fail;
19227     }
19228     Py_INCREF(Py_None); resultobj = Py_None;
19229     return resultobj;
19230     fail:
19231     return NULL;
19232 }
19233
19234
19235 static PyObject *_wrap_PyPanel_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
19236     PyObject *resultobj;
19237     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19238     wxWindow *arg2 = (wxWindow *) 0 ;
19239     PyObject * obj0 = 0 ;
19240     PyObject * obj1 = 0 ;
19241     char *kwnames[] = {
19242         (char *) "self",(char *) "child", NULL
19243     };
19244
19245     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
19246     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19247     if (SWIG_arg_fail(1)) SWIG_fail;
19248     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19249     if (SWIG_arg_fail(2)) SWIG_fail;
19250     {
19251         PyThreadState* __tstate = wxPyBeginAllowThreads();
19252         (arg1)->base_RemoveChild(arg2);
19253
19254         wxPyEndAllowThreads(__tstate);
19255         if (PyErr_Occurred()) SWIG_fail;
19256     }
19257     Py_INCREF(Py_None); resultobj = Py_None;
19258     return resultobj;
19259     fail:
19260     return NULL;
19261 }
19262
19263
19264 static PyObject *_wrap_PyPanel_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
19265     PyObject *resultobj;
19266     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19267     bool result;
19268     PyObject * obj0 = 0 ;
19269     char *kwnames[] = {
19270         (char *) "self", NULL
19271     };
19272
19273     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
19274     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19275     if (SWIG_arg_fail(1)) SWIG_fail;
19276     {
19277         PyThreadState* __tstate = wxPyBeginAllowThreads();
19278         result = (bool)((wxPyPanel const *)arg1)->base_ShouldInheritColours();
19279
19280         wxPyEndAllowThreads(__tstate);
19281         if (PyErr_Occurred()) SWIG_fail;
19282     }
19283     {
19284         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19285     }
19286     return resultobj;
19287     fail:
19288     return NULL;
19289 }
19290
19291
19292 static PyObject *_wrap_PyPanel_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
19293     PyObject *resultobj;
19294     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19295     wxColour *arg2 = 0 ;
19296     wxColour temp2 ;
19297     PyObject * obj0 = 0 ;
19298     PyObject * obj1 = 0 ;
19299     char *kwnames[] = {
19300         (char *) "self",(char *) "c", NULL
19301     };
19302
19303     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
19304     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19305     if (SWIG_arg_fail(1)) SWIG_fail;
19306     {
19307         arg2 = &temp2;
19308         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19309     }
19310     {
19311         PyThreadState* __tstate = wxPyBeginAllowThreads();
19312         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
19313
19314         wxPyEndAllowThreads(__tstate);
19315         if (PyErr_Occurred()) SWIG_fail;
19316     }
19317     Py_INCREF(Py_None); resultobj = Py_None;
19318     return resultobj;
19319     fail:
19320     return NULL;
19321 }
19322
19323
19324 static PyObject *_wrap_PyPanel_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
19325     PyObject *resultobj;
19326     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19327     wxVisualAttributes result;
19328     PyObject * obj0 = 0 ;
19329     char *kwnames[] = {
19330         (char *) "self", NULL
19331     };
19332
19333     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
19334     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19335     if (SWIG_arg_fail(1)) SWIG_fail;
19336     {
19337         PyThreadState* __tstate = wxPyBeginAllowThreads();
19338         result = (arg1)->base_GetDefaultAttributes();
19339
19340         wxPyEndAllowThreads(__tstate);
19341         if (PyErr_Occurred()) SWIG_fail;
19342     }
19343     {
19344         wxVisualAttributes * resultptr;
19345         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
19346         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
19347     }
19348     return resultobj;
19349     fail:
19350     return NULL;
19351 }
19352
19353
19354 static PyObject * PyPanel_swigregister(PyObject *, PyObject *args) {
19355     PyObject *obj;
19356     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19357     SWIG_TypeClientData(SWIGTYPE_p_wxPyPanel, obj);
19358     Py_INCREF(obj);
19359     return Py_BuildValue((char *)"");
19360 }
19361 static PyObject *_wrap_new_PyScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19362     PyObject *resultobj;
19363     wxWindow *arg1 = (wxWindow *) 0 ;
19364     int arg2 = (int) (int)-1 ;
19365     wxPoint const &arg3_defvalue = wxDefaultPosition ;
19366     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
19367     wxSize const &arg4_defvalue = wxDefaultSize ;
19368     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
19369     long arg5 = (long) 0 ;
19370     wxString const &arg6_defvalue = wxPyPanelNameStr ;
19371     wxString *arg6 = (wxString *) &arg6_defvalue ;
19372     wxPyScrolledWindow *result;
19373     wxPoint temp3 ;
19374     wxSize temp4 ;
19375     bool temp6 = false ;
19376     PyObject * obj0 = 0 ;
19377     PyObject * obj1 = 0 ;
19378     PyObject * obj2 = 0 ;
19379     PyObject * obj3 = 0 ;
19380     PyObject * obj4 = 0 ;
19381     PyObject * obj5 = 0 ;
19382     char *kwnames[] = {
19383         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
19384     };
19385
19386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19387     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19388     if (SWIG_arg_fail(1)) SWIG_fail;
19389     if (obj1) {
19390         {
19391             arg2 = (int const)(SWIG_As_int(obj1));
19392             if (SWIG_arg_fail(2)) SWIG_fail;
19393         }
19394     }
19395     if (obj2) {
19396         {
19397             arg3 = &temp3;
19398             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19399         }
19400     }
19401     if (obj3) {
19402         {
19403             arg4 = &temp4;
19404             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
19405         }
19406     }
19407     if (obj4) {
19408         {
19409             arg5 = (long)(SWIG_As_long(obj4));
19410             if (SWIG_arg_fail(5)) SWIG_fail;
19411         }
19412     }
19413     if (obj5) {
19414         {
19415             arg6 = wxString_in_helper(obj5);
19416             if (arg6 == NULL) SWIG_fail;
19417             temp6 = true;
19418         }
19419     }
19420     {
19421         if (!wxPyCheckForApp()) SWIG_fail;
19422         PyThreadState* __tstate = wxPyBeginAllowThreads();
19423         result = (wxPyScrolledWindow *)new wxPyScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
19424
19425         wxPyEndAllowThreads(__tstate);
19426         if (PyErr_Occurred()) SWIG_fail;
19427     }
19428     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyScrolledWindow, 1);
19429     {
19430         if (temp6)
19431         delete arg6;
19432     }
19433     return resultobj;
19434     fail:
19435     {
19436         if (temp6)
19437         delete arg6;
19438     }
19439     return NULL;
19440 }
19441
19442
19443 static PyObject *_wrap_new_PrePyScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19444     PyObject *resultobj;
19445     wxPyScrolledWindow *result;
19446     char *kwnames[] = {
19447         NULL
19448     };
19449
19450     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyScrolledWindow",kwnames)) goto fail;
19451     {
19452         if (!wxPyCheckForApp()) SWIG_fail;
19453         PyThreadState* __tstate = wxPyBeginAllowThreads();
19454         result = (wxPyScrolledWindow *)new wxPyScrolledWindow();
19455
19456         wxPyEndAllowThreads(__tstate);
19457         if (PyErr_Occurred()) SWIG_fail;
19458     }
19459     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyScrolledWindow, 1);
19460     return resultobj;
19461     fail:
19462     return NULL;
19463 }
19464
19465
19466 static PyObject *_wrap_PyScrolledWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
19467     PyObject *resultobj;
19468     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19469     PyObject *arg2 = (PyObject *) 0 ;
19470     PyObject *arg3 = (PyObject *) 0 ;
19471     PyObject * obj0 = 0 ;
19472     PyObject * obj1 = 0 ;
19473     PyObject * obj2 = 0 ;
19474     char *kwnames[] = {
19475         (char *) "self",(char *) "self",(char *) "_class", NULL
19476     };
19477
19478     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
19479     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19480     if (SWIG_arg_fail(1)) SWIG_fail;
19481     arg2 = obj1;
19482     arg3 = obj2;
19483     {
19484         PyThreadState* __tstate = wxPyBeginAllowThreads();
19485         (arg1)->_setCallbackInfo(arg2,arg3);
19486
19487         wxPyEndAllowThreads(__tstate);
19488         if (PyErr_Occurred()) SWIG_fail;
19489     }
19490     Py_INCREF(Py_None); resultobj = Py_None;
19491     return resultobj;
19492     fail:
19493     return NULL;
19494 }
19495
19496
19497 static PyObject *_wrap_PyScrolledWindow_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19498     PyObject *resultobj;
19499     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19500     wxSize *arg2 = 0 ;
19501     wxSize temp2 ;
19502     PyObject * obj0 = 0 ;
19503     PyObject * obj1 = 0 ;
19504     char *kwnames[] = {
19505         (char *) "self",(char *) "size", NULL
19506     };
19507
19508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
19509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19510     if (SWIG_arg_fail(1)) SWIG_fail;
19511     {
19512         arg2 = &temp2;
19513         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
19514     }
19515     {
19516         PyThreadState* __tstate = wxPyBeginAllowThreads();
19517         (arg1)->SetBestSize((wxSize const &)*arg2);
19518
19519         wxPyEndAllowThreads(__tstate);
19520         if (PyErr_Occurred()) SWIG_fail;
19521     }
19522     Py_INCREF(Py_None); resultobj = Py_None;
19523     return resultobj;
19524     fail:
19525     return NULL;
19526 }
19527
19528
19529 static PyObject *_wrap_PyScrolledWindow_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19530     PyObject *resultobj;
19531     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19532     int arg2 ;
19533     int arg3 ;
19534     int arg4 ;
19535     int arg5 ;
19536     PyObject * obj0 = 0 ;
19537     PyObject * obj1 = 0 ;
19538     PyObject * obj2 = 0 ;
19539     PyObject * obj3 = 0 ;
19540     PyObject * obj4 = 0 ;
19541     char *kwnames[] = {
19542         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
19543     };
19544
19545     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyScrolledWindow_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19546     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19547     if (SWIG_arg_fail(1)) SWIG_fail;
19548     {
19549         arg2 = (int)(SWIG_As_int(obj1));
19550         if (SWIG_arg_fail(2)) SWIG_fail;
19551     }
19552     {
19553         arg3 = (int)(SWIG_As_int(obj2));
19554         if (SWIG_arg_fail(3)) SWIG_fail;
19555     }
19556     {
19557         arg4 = (int)(SWIG_As_int(obj3));
19558         if (SWIG_arg_fail(4)) SWIG_fail;
19559     }
19560     {
19561         arg5 = (int)(SWIG_As_int(obj4));
19562         if (SWIG_arg_fail(5)) SWIG_fail;
19563     }
19564     {
19565         PyThreadState* __tstate = wxPyBeginAllowThreads();
19566         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
19567
19568         wxPyEndAllowThreads(__tstate);
19569         if (PyErr_Occurred()) SWIG_fail;
19570     }
19571     Py_INCREF(Py_None); resultobj = Py_None;
19572     return resultobj;
19573     fail:
19574     return NULL;
19575 }
19576
19577
19578 static PyObject *_wrap_PyScrolledWindow_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19579     PyObject *resultobj;
19580     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19581     int arg2 ;
19582     int arg3 ;
19583     int arg4 ;
19584     int arg5 ;
19585     int arg6 = (int) wxSIZE_AUTO ;
19586     PyObject * obj0 = 0 ;
19587     PyObject * obj1 = 0 ;
19588     PyObject * obj2 = 0 ;
19589     PyObject * obj3 = 0 ;
19590     PyObject * obj4 = 0 ;
19591     PyObject * obj5 = 0 ;
19592     char *kwnames[] = {
19593         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
19594     };
19595
19596     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyScrolledWindow_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19597     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19598     if (SWIG_arg_fail(1)) SWIG_fail;
19599     {
19600         arg2 = (int)(SWIG_As_int(obj1));
19601         if (SWIG_arg_fail(2)) SWIG_fail;
19602     }
19603     {
19604         arg3 = (int)(SWIG_As_int(obj2));
19605         if (SWIG_arg_fail(3)) SWIG_fail;
19606     }
19607     {
19608         arg4 = (int)(SWIG_As_int(obj3));
19609         if (SWIG_arg_fail(4)) SWIG_fail;
19610     }
19611     {
19612         arg5 = (int)(SWIG_As_int(obj4));
19613         if (SWIG_arg_fail(5)) SWIG_fail;
19614     }
19615     if (obj5) {
19616         {
19617             arg6 = (int)(SWIG_As_int(obj5));
19618             if (SWIG_arg_fail(6)) SWIG_fail;
19619         }
19620     }
19621     {
19622         PyThreadState* __tstate = wxPyBeginAllowThreads();
19623         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
19624
19625         wxPyEndAllowThreads(__tstate);
19626         if (PyErr_Occurred()) SWIG_fail;
19627     }
19628     Py_INCREF(Py_None); resultobj = Py_None;
19629     return resultobj;
19630     fail:
19631     return NULL;
19632 }
19633
19634
19635 static PyObject *_wrap_PyScrolledWindow_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19636     PyObject *resultobj;
19637     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19638     int arg2 ;
19639     int arg3 ;
19640     PyObject * obj0 = 0 ;
19641     PyObject * obj1 = 0 ;
19642     PyObject * obj2 = 0 ;
19643     char *kwnames[] = {
19644         (char *) "self",(char *) "width",(char *) "height", NULL
19645     };
19646
19647     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
19648     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19649     if (SWIG_arg_fail(1)) SWIG_fail;
19650     {
19651         arg2 = (int)(SWIG_As_int(obj1));
19652         if (SWIG_arg_fail(2)) SWIG_fail;
19653     }
19654     {
19655         arg3 = (int)(SWIG_As_int(obj2));
19656         if (SWIG_arg_fail(3)) SWIG_fail;
19657     }
19658     {
19659         PyThreadState* __tstate = wxPyBeginAllowThreads();
19660         (arg1)->base_DoSetClientSize(arg2,arg3);
19661
19662         wxPyEndAllowThreads(__tstate);
19663         if (PyErr_Occurred()) SWIG_fail;
19664     }
19665     Py_INCREF(Py_None); resultobj = Py_None;
19666     return resultobj;
19667     fail:
19668     return NULL;
19669 }
19670
19671
19672 static PyObject *_wrap_PyScrolledWindow_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19673     PyObject *resultobj;
19674     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19675     int arg2 ;
19676     int arg3 ;
19677     PyObject * obj0 = 0 ;
19678     PyObject * obj1 = 0 ;
19679     PyObject * obj2 = 0 ;
19680     char *kwnames[] = {
19681         (char *) "self",(char *) "x",(char *) "y", NULL
19682     };
19683
19684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
19685     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19686     if (SWIG_arg_fail(1)) SWIG_fail;
19687     {
19688         arg2 = (int)(SWIG_As_int(obj1));
19689         if (SWIG_arg_fail(2)) SWIG_fail;
19690     }
19691     {
19692         arg3 = (int)(SWIG_As_int(obj2));
19693         if (SWIG_arg_fail(3)) SWIG_fail;
19694     }
19695     {
19696         PyThreadState* __tstate = wxPyBeginAllowThreads();
19697         (arg1)->base_DoSetVirtualSize(arg2,arg3);
19698
19699         wxPyEndAllowThreads(__tstate);
19700         if (PyErr_Occurred()) SWIG_fail;
19701     }
19702     Py_INCREF(Py_None); resultobj = Py_None;
19703     return resultobj;
19704     fail:
19705     return NULL;
19706 }
19707
19708
19709 static PyObject *_wrap_PyScrolledWindow_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19710     PyObject *resultobj;
19711     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19712     int *arg2 = (int *) 0 ;
19713     int *arg3 = (int *) 0 ;
19714     int temp2 ;
19715     int res2 = 0 ;
19716     int temp3 ;
19717     int res3 = 0 ;
19718     PyObject * obj0 = 0 ;
19719     char *kwnames[] = {
19720         (char *) "self", NULL
19721     };
19722
19723     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19724     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetSize",kwnames,&obj0)) goto fail;
19726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19727     if (SWIG_arg_fail(1)) SWIG_fail;
19728     {
19729         PyThreadState* __tstate = wxPyBeginAllowThreads();
19730         ((wxPyScrolledWindow const *)arg1)->base_DoGetSize(arg2,arg3);
19731
19732         wxPyEndAllowThreads(__tstate);
19733         if (PyErr_Occurred()) SWIG_fail;
19734     }
19735     Py_INCREF(Py_None); resultobj = Py_None;
19736     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19737     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19738     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19739     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19740     return resultobj;
19741     fail:
19742     return NULL;
19743 }
19744
19745
19746 static PyObject *_wrap_PyScrolledWindow_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19747     PyObject *resultobj;
19748     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19749     int *arg2 = (int *) 0 ;
19750     int *arg3 = (int *) 0 ;
19751     int temp2 ;
19752     int res2 = 0 ;
19753     int temp3 ;
19754     int res3 = 0 ;
19755     PyObject * obj0 = 0 ;
19756     char *kwnames[] = {
19757         (char *) "self", NULL
19758     };
19759
19760     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19761     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19762     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetClientSize",kwnames,&obj0)) goto fail;
19763     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19764     if (SWIG_arg_fail(1)) SWIG_fail;
19765     {
19766         PyThreadState* __tstate = wxPyBeginAllowThreads();
19767         ((wxPyScrolledWindow const *)arg1)->base_DoGetClientSize(arg2,arg3);
19768
19769         wxPyEndAllowThreads(__tstate);
19770         if (PyErr_Occurred()) SWIG_fail;
19771     }
19772     Py_INCREF(Py_None); resultobj = Py_None;
19773     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19774     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19775     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19776     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19777     return resultobj;
19778     fail:
19779     return NULL;
19780 }
19781
19782
19783 static PyObject *_wrap_PyScrolledWindow_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19784     PyObject *resultobj;
19785     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19786     int *arg2 = (int *) 0 ;
19787     int *arg3 = (int *) 0 ;
19788     int temp2 ;
19789     int res2 = 0 ;
19790     int temp3 ;
19791     int res3 = 0 ;
19792     PyObject * obj0 = 0 ;
19793     char *kwnames[] = {
19794         (char *) "self", NULL
19795     };
19796
19797     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19798     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19799     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetPosition",kwnames,&obj0)) goto fail;
19800     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19801     if (SWIG_arg_fail(1)) SWIG_fail;
19802     {
19803         PyThreadState* __tstate = wxPyBeginAllowThreads();
19804         ((wxPyScrolledWindow const *)arg1)->base_DoGetPosition(arg2,arg3);
19805
19806         wxPyEndAllowThreads(__tstate);
19807         if (PyErr_Occurred()) SWIG_fail;
19808     }
19809     Py_INCREF(Py_None); resultobj = Py_None;
19810     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19811     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19812     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19813     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19814     return resultobj;
19815     fail:
19816     return NULL;
19817 }
19818
19819
19820 static PyObject *_wrap_PyScrolledWindow_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19821     PyObject *resultobj;
19822     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19823     wxSize result;
19824     PyObject * obj0 = 0 ;
19825     char *kwnames[] = {
19826         (char *) "self", NULL
19827     };
19828
19829     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
19830     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19831     if (SWIG_arg_fail(1)) SWIG_fail;
19832     {
19833         PyThreadState* __tstate = wxPyBeginAllowThreads();
19834         result = ((wxPyScrolledWindow const *)arg1)->base_DoGetVirtualSize();
19835
19836         wxPyEndAllowThreads(__tstate);
19837         if (PyErr_Occurred()) SWIG_fail;
19838     }
19839     {
19840         wxSize * resultptr;
19841         resultptr = new wxSize((wxSize &)(result));
19842         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19843     }
19844     return resultobj;
19845     fail:
19846     return NULL;
19847 }
19848
19849
19850 static PyObject *_wrap_PyScrolledWindow_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19851     PyObject *resultobj;
19852     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19853     wxSize result;
19854     PyObject * obj0 = 0 ;
19855     char *kwnames[] = {
19856         (char *) "self", NULL
19857     };
19858
19859     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetBestSize",kwnames,&obj0)) goto fail;
19860     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19861     if (SWIG_arg_fail(1)) SWIG_fail;
19862     {
19863         PyThreadState* __tstate = wxPyBeginAllowThreads();
19864         result = ((wxPyScrolledWindow const *)arg1)->base_DoGetBestSize();
19865
19866         wxPyEndAllowThreads(__tstate);
19867         if (PyErr_Occurred()) SWIG_fail;
19868     }
19869     {
19870         wxSize * resultptr;
19871         resultptr = new wxSize((wxSize &)(result));
19872         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19873     }
19874     return resultobj;
19875     fail:
19876     return NULL;
19877 }
19878
19879
19880 static PyObject *_wrap_PyScrolledWindow_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
19881     PyObject *resultobj;
19882     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19883     PyObject * obj0 = 0 ;
19884     char *kwnames[] = {
19885         (char *) "self", NULL
19886     };
19887
19888     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_InitDialog",kwnames,&obj0)) goto fail;
19889     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19890     if (SWIG_arg_fail(1)) SWIG_fail;
19891     {
19892         PyThreadState* __tstate = wxPyBeginAllowThreads();
19893         (arg1)->base_InitDialog();
19894
19895         wxPyEndAllowThreads(__tstate);
19896         if (PyErr_Occurred()) SWIG_fail;
19897     }
19898     Py_INCREF(Py_None); resultobj = Py_None;
19899     return resultobj;
19900     fail:
19901     return NULL;
19902 }
19903
19904
19905 static PyObject *_wrap_PyScrolledWindow_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19906     PyObject *resultobj;
19907     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19908     bool result;
19909     PyObject * obj0 = 0 ;
19910     char *kwnames[] = {
19911         (char *) "self", NULL
19912     };
19913
19914     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
19915     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19916     if (SWIG_arg_fail(1)) SWIG_fail;
19917     {
19918         PyThreadState* __tstate = wxPyBeginAllowThreads();
19919         result = (bool)(arg1)->base_TransferDataToWindow();
19920
19921         wxPyEndAllowThreads(__tstate);
19922         if (PyErr_Occurred()) SWIG_fail;
19923     }
19924     {
19925         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19926     }
19927     return resultobj;
19928     fail:
19929     return NULL;
19930 }
19931
19932
19933 static PyObject *_wrap_PyScrolledWindow_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19934     PyObject *resultobj;
19935     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19936     bool result;
19937     PyObject * obj0 = 0 ;
19938     char *kwnames[] = {
19939         (char *) "self", NULL
19940     };
19941
19942     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
19943     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19944     if (SWIG_arg_fail(1)) SWIG_fail;
19945     {
19946         PyThreadState* __tstate = wxPyBeginAllowThreads();
19947         result = (bool)(arg1)->base_TransferDataFromWindow();
19948
19949         wxPyEndAllowThreads(__tstate);
19950         if (PyErr_Occurred()) SWIG_fail;
19951     }
19952     {
19953         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19954     }
19955     return resultobj;
19956     fail:
19957     return NULL;
19958 }
19959
19960
19961 static PyObject *_wrap_PyScrolledWindow_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
19962     PyObject *resultobj;
19963     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19964     bool result;
19965     PyObject * obj0 = 0 ;
19966     char *kwnames[] = {
19967         (char *) "self", NULL
19968     };
19969
19970     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_Validate",kwnames,&obj0)) goto fail;
19971     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19972     if (SWIG_arg_fail(1)) SWIG_fail;
19973     {
19974         PyThreadState* __tstate = wxPyBeginAllowThreads();
19975         result = (bool)(arg1)->base_Validate();
19976
19977         wxPyEndAllowThreads(__tstate);
19978         if (PyErr_Occurred()) SWIG_fail;
19979     }
19980     {
19981         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19982     }
19983     return resultobj;
19984     fail:
19985     return NULL;
19986 }
19987
19988
19989 static PyObject *_wrap_PyScrolledWindow_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
19990     PyObject *resultobj;
19991     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19992     bool result;
19993     PyObject * obj0 = 0 ;
19994     char *kwnames[] = {
19995         (char *) "self", NULL
19996     };
19997
19998     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_AcceptsFocus",kwnames,&obj0)) goto fail;
19999     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20000     if (SWIG_arg_fail(1)) SWIG_fail;
20001     {
20002         PyThreadState* __tstate = wxPyBeginAllowThreads();
20003         result = (bool)((wxPyScrolledWindow const *)arg1)->base_AcceptsFocus();
20004
20005         wxPyEndAllowThreads(__tstate);
20006         if (PyErr_Occurred()) SWIG_fail;
20007     }
20008     {
20009         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20010     }
20011     return resultobj;
20012     fail:
20013     return NULL;
20014 }
20015
20016
20017 static PyObject *_wrap_PyScrolledWindow_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
20018     PyObject *resultobj;
20019     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20020     bool result;
20021     PyObject * obj0 = 0 ;
20022     char *kwnames[] = {
20023         (char *) "self", NULL
20024     };
20025
20026     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
20027     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20028     if (SWIG_arg_fail(1)) SWIG_fail;
20029     {
20030         PyThreadState* __tstate = wxPyBeginAllowThreads();
20031         result = (bool)((wxPyScrolledWindow const *)arg1)->base_AcceptsFocusFromKeyboard();
20032
20033         wxPyEndAllowThreads(__tstate);
20034         if (PyErr_Occurred()) SWIG_fail;
20035     }
20036     {
20037         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20038     }
20039     return resultobj;
20040     fail:
20041     return NULL;
20042 }
20043
20044
20045 static PyObject *_wrap_PyScrolledWindow_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
20046     PyObject *resultobj;
20047     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20048     wxSize result;
20049     PyObject * obj0 = 0 ;
20050     char *kwnames[] = {
20051         (char *) "self", NULL
20052     };
20053
20054     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_GetMaxSize",kwnames,&obj0)) goto fail;
20055     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20056     if (SWIG_arg_fail(1)) SWIG_fail;
20057     {
20058         PyThreadState* __tstate = wxPyBeginAllowThreads();
20059         result = ((wxPyScrolledWindow const *)arg1)->base_GetMaxSize();
20060
20061         wxPyEndAllowThreads(__tstate);
20062         if (PyErr_Occurred()) SWIG_fail;
20063     }
20064     {
20065         wxSize * resultptr;
20066         resultptr = new wxSize((wxSize &)(result));
20067         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20068     }
20069     return resultobj;
20070     fail:
20071     return NULL;
20072 }
20073
20074
20075 static PyObject *_wrap_PyScrolledWindow_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
20076     PyObject *resultobj;
20077     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20078     wxWindow *arg2 = (wxWindow *) 0 ;
20079     PyObject * obj0 = 0 ;
20080     PyObject * obj1 = 0 ;
20081     char *kwnames[] = {
20082         (char *) "self",(char *) "child", NULL
20083     };
20084
20085     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
20086     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20087     if (SWIG_arg_fail(1)) SWIG_fail;
20088     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20089     if (SWIG_arg_fail(2)) SWIG_fail;
20090     {
20091         PyThreadState* __tstate = wxPyBeginAllowThreads();
20092         (arg1)->base_AddChild(arg2);
20093
20094         wxPyEndAllowThreads(__tstate);
20095         if (PyErr_Occurred()) SWIG_fail;
20096     }
20097     Py_INCREF(Py_None); resultobj = Py_None;
20098     return resultobj;
20099     fail:
20100     return NULL;
20101 }
20102
20103
20104 static PyObject *_wrap_PyScrolledWindow_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
20105     PyObject *resultobj;
20106     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20107     wxWindow *arg2 = (wxWindow *) 0 ;
20108     PyObject * obj0 = 0 ;
20109     PyObject * obj1 = 0 ;
20110     char *kwnames[] = {
20111         (char *) "self",(char *) "child", NULL
20112     };
20113
20114     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
20115     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20116     if (SWIG_arg_fail(1)) SWIG_fail;
20117     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20118     if (SWIG_arg_fail(2)) SWIG_fail;
20119     {
20120         PyThreadState* __tstate = wxPyBeginAllowThreads();
20121         (arg1)->base_RemoveChild(arg2);
20122
20123         wxPyEndAllowThreads(__tstate);
20124         if (PyErr_Occurred()) SWIG_fail;
20125     }
20126     Py_INCREF(Py_None); resultobj = Py_None;
20127     return resultobj;
20128     fail:
20129     return NULL;
20130 }
20131
20132
20133 static PyObject *_wrap_PyScrolledWindow_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
20134     PyObject *resultobj;
20135     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20136     bool result;
20137     PyObject * obj0 = 0 ;
20138     char *kwnames[] = {
20139         (char *) "self", NULL
20140     };
20141
20142     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
20143     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20144     if (SWIG_arg_fail(1)) SWIG_fail;
20145     {
20146         PyThreadState* __tstate = wxPyBeginAllowThreads();
20147         result = (bool)((wxPyScrolledWindow const *)arg1)->base_ShouldInheritColours();
20148
20149         wxPyEndAllowThreads(__tstate);
20150         if (PyErr_Occurred()) SWIG_fail;
20151     }
20152     {
20153         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20154     }
20155     return resultobj;
20156     fail:
20157     return NULL;
20158 }
20159
20160
20161 static PyObject *_wrap_PyScrolledWindow_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
20162     PyObject *resultobj;
20163     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20164     wxColour *arg2 = 0 ;
20165     wxColour temp2 ;
20166     PyObject * obj0 = 0 ;
20167     PyObject * obj1 = 0 ;
20168     char *kwnames[] = {
20169         (char *) "self",(char *) "c", NULL
20170     };
20171
20172     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
20173     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20174     if (SWIG_arg_fail(1)) SWIG_fail;
20175     {
20176         arg2 = &temp2;
20177         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20178     }
20179     {
20180         PyThreadState* __tstate = wxPyBeginAllowThreads();
20181         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
20182
20183         wxPyEndAllowThreads(__tstate);
20184         if (PyErr_Occurred()) SWIG_fail;
20185     }
20186     Py_INCREF(Py_None); resultobj = Py_None;
20187     return resultobj;
20188     fail:
20189     return NULL;
20190 }
20191
20192
20193 static PyObject *_wrap_PyScrolledWindow_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
20194     PyObject *resultobj;
20195     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20196     wxVisualAttributes result;
20197     PyObject * obj0 = 0 ;
20198     char *kwnames[] = {
20199         (char *) "self", NULL
20200     };
20201
20202     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
20203     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20204     if (SWIG_arg_fail(1)) SWIG_fail;
20205     {
20206         PyThreadState* __tstate = wxPyBeginAllowThreads();
20207         result = (arg1)->base_GetDefaultAttributes();
20208
20209         wxPyEndAllowThreads(__tstate);
20210         if (PyErr_Occurred()) SWIG_fail;
20211     }
20212     {
20213         wxVisualAttributes * resultptr;
20214         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
20215         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
20216     }
20217     return resultobj;
20218     fail:
20219     return NULL;
20220 }
20221
20222
20223 static PyObject * PyScrolledWindow_swigregister(PyObject *, PyObject *args) {
20224     PyObject *obj;
20225     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20226     SWIG_TypeClientData(SWIGTYPE_p_wxPyScrolledWindow, obj);
20227     Py_INCREF(obj);
20228     return Py_BuildValue((char *)"");
20229 }
20230 static int _wrap_PrintoutTitleStr_set(PyObject *) {
20231     PyErr_SetString(PyExc_TypeError,"Variable PrintoutTitleStr is read-only.");
20232     return 1;
20233 }
20234
20235
20236 static PyObject *_wrap_PrintoutTitleStr_get(void) {
20237     PyObject *pyobj;
20238
20239     {
20240 #if wxUSE_UNICODE
20241         pyobj = PyUnicode_FromWideChar((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
20242 #else
20243         pyobj = PyString_FromStringAndSize((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
20244 #endif
20245     }
20246     return pyobj;
20247 }
20248
20249
20250 static int _wrap_PreviewCanvasNameStr_set(PyObject *) {
20251     PyErr_SetString(PyExc_TypeError,"Variable PreviewCanvasNameStr is read-only.");
20252     return 1;
20253 }
20254
20255
20256 static PyObject *_wrap_PreviewCanvasNameStr_get(void) {
20257     PyObject *pyobj;
20258
20259     {
20260 #if wxUSE_UNICODE
20261         pyobj = PyUnicode_FromWideChar((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
20262 #else
20263         pyobj = PyString_FromStringAndSize((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
20264 #endif
20265     }
20266     return pyobj;
20267 }
20268
20269
20270 static PyObject *_wrap_new_PrintData__SWIG_0(PyObject *, PyObject *args) {
20271     PyObject *resultobj;
20272     wxPrintData *result;
20273
20274     if(!PyArg_ParseTuple(args,(char *)":new_PrintData")) goto fail;
20275     {
20276         PyThreadState* __tstate = wxPyBeginAllowThreads();
20277         result = (wxPrintData *)new wxPrintData();
20278
20279         wxPyEndAllowThreads(__tstate);
20280         if (PyErr_Occurred()) SWIG_fail;
20281     }
20282     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 1);
20283     return resultobj;
20284     fail:
20285     return NULL;
20286 }
20287
20288
20289 static PyObject *_wrap_new_PrintData__SWIG_1(PyObject *, PyObject *args) {
20290     PyObject *resultobj;
20291     wxPrintData *arg1 = 0 ;
20292     wxPrintData *result;
20293     PyObject * obj0 = 0 ;
20294
20295     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintData",&obj0)) goto fail;
20296     {
20297         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20298         if (SWIG_arg_fail(1)) SWIG_fail;
20299         if (arg1 == NULL) {
20300             SWIG_null_ref("wxPrintData");
20301         }
20302         if (SWIG_arg_fail(1)) SWIG_fail;
20303     }
20304     {
20305         PyThreadState* __tstate = wxPyBeginAllowThreads();
20306         result = (wxPrintData *)new wxPrintData((wxPrintData const &)*arg1);
20307
20308         wxPyEndAllowThreads(__tstate);
20309         if (PyErr_Occurred()) SWIG_fail;
20310     }
20311     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 1);
20312     return resultobj;
20313     fail:
20314     return NULL;
20315 }
20316
20317
20318 static PyObject *_wrap_new_PrintData(PyObject *self, PyObject *args) {
20319     int argc;
20320     PyObject *argv[2];
20321     int ii;
20322
20323     argc = PyObject_Length(args);
20324     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
20325         argv[ii] = PyTuple_GetItem(args,ii);
20326     }
20327     if (argc == 0) {
20328         return _wrap_new_PrintData__SWIG_0(self,args);
20329     }
20330     if (argc == 1) {
20331         int _v;
20332         {
20333             void *ptr = 0;
20334             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
20335                 _v = 0;
20336                 PyErr_Clear();
20337             } else {
20338                 _v = (ptr != 0);
20339             }
20340         }
20341         if (_v) {
20342             return _wrap_new_PrintData__SWIG_1(self,args);
20343         }
20344     }
20345
20346     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintData'");
20347     return NULL;
20348 }
20349
20350
20351 static PyObject *_wrap_delete_PrintData(PyObject *, PyObject *args, PyObject *kwargs) {
20352     PyObject *resultobj;
20353     wxPrintData *arg1 = (wxPrintData *) 0 ;
20354     PyObject * obj0 = 0 ;
20355     char *kwnames[] = {
20356         (char *) "self", NULL
20357     };
20358
20359     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PrintData",kwnames,&obj0)) goto fail;
20360     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20361     if (SWIG_arg_fail(1)) SWIG_fail;
20362     {
20363         PyThreadState* __tstate = wxPyBeginAllowThreads();
20364         delete arg1;
20365
20366         wxPyEndAllowThreads(__tstate);
20367         if (PyErr_Occurred()) SWIG_fail;
20368     }
20369     Py_INCREF(Py_None); resultobj = Py_None;
20370     return resultobj;
20371     fail:
20372     return NULL;
20373 }
20374
20375
20376 static PyObject *_wrap_PrintData_GetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
20377     PyObject *resultobj;
20378     wxPrintData *arg1 = (wxPrintData *) 0 ;
20379     int result;
20380     PyObject * obj0 = 0 ;
20381     char *kwnames[] = {
20382         (char *) "self", NULL
20383     };
20384
20385     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetNoCopies",kwnames,&obj0)) goto fail;
20386     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20387     if (SWIG_arg_fail(1)) SWIG_fail;
20388     {
20389         PyThreadState* __tstate = wxPyBeginAllowThreads();
20390         result = (int)(arg1)->GetNoCopies();
20391
20392         wxPyEndAllowThreads(__tstate);
20393         if (PyErr_Occurred()) SWIG_fail;
20394     }
20395     {
20396         resultobj = SWIG_From_int((int)(result));
20397     }
20398     return resultobj;
20399     fail:
20400     return NULL;
20401 }
20402
20403
20404 static PyObject *_wrap_PrintData_GetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
20405     PyObject *resultobj;
20406     wxPrintData *arg1 = (wxPrintData *) 0 ;
20407     bool result;
20408     PyObject * obj0 = 0 ;
20409     char *kwnames[] = {
20410         (char *) "self", NULL
20411     };
20412
20413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetCollate",kwnames,&obj0)) goto fail;
20414     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20415     if (SWIG_arg_fail(1)) SWIG_fail;
20416     {
20417         PyThreadState* __tstate = wxPyBeginAllowThreads();
20418         result = (bool)(arg1)->GetCollate();
20419
20420         wxPyEndAllowThreads(__tstate);
20421         if (PyErr_Occurred()) SWIG_fail;
20422     }
20423     {
20424         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20425     }
20426     return resultobj;
20427     fail:
20428     return NULL;
20429 }
20430
20431
20432 static PyObject *_wrap_PrintData_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
20433     PyObject *resultobj;
20434     wxPrintData *arg1 = (wxPrintData *) 0 ;
20435     int result;
20436     PyObject * obj0 = 0 ;
20437     char *kwnames[] = {
20438         (char *) "self", NULL
20439     };
20440
20441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetOrientation",kwnames,&obj0)) goto fail;
20442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20443     if (SWIG_arg_fail(1)) SWIG_fail;
20444     {
20445         PyThreadState* __tstate = wxPyBeginAllowThreads();
20446         result = (int)(arg1)->GetOrientation();
20447
20448         wxPyEndAllowThreads(__tstate);
20449         if (PyErr_Occurred()) SWIG_fail;
20450     }
20451     {
20452         resultobj = SWIG_From_int((int)(result));
20453     }
20454     return resultobj;
20455     fail:
20456     return NULL;
20457 }
20458
20459
20460 static PyObject *_wrap_PrintData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
20461     PyObject *resultobj;
20462     wxPrintData *arg1 = (wxPrintData *) 0 ;
20463     bool result;
20464     PyObject * obj0 = 0 ;
20465     char *kwnames[] = {
20466         (char *) "self", NULL
20467     };
20468
20469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_Ok",kwnames,&obj0)) goto fail;
20470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20471     if (SWIG_arg_fail(1)) SWIG_fail;
20472     {
20473         PyThreadState* __tstate = wxPyBeginAllowThreads();
20474         result = (bool)(arg1)->Ok();
20475
20476         wxPyEndAllowThreads(__tstate);
20477         if (PyErr_Occurred()) SWIG_fail;
20478     }
20479     {
20480         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20481     }
20482     return resultobj;
20483     fail:
20484     return NULL;
20485 }
20486
20487
20488 static PyObject *_wrap_PrintData_GetPrinterName(PyObject *, PyObject *args, PyObject *kwargs) {
20489     PyObject *resultobj;
20490     wxPrintData *arg1 = (wxPrintData *) 0 ;
20491     wxString *result;
20492     PyObject * obj0 = 0 ;
20493     char *kwnames[] = {
20494         (char *) "self", NULL
20495     };
20496
20497     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterName",kwnames,&obj0)) goto fail;
20498     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20499     if (SWIG_arg_fail(1)) SWIG_fail;
20500     {
20501         PyThreadState* __tstate = wxPyBeginAllowThreads();
20502         {
20503             wxString const &_result_ref = (arg1)->GetPrinterName();
20504             result = (wxString *) &_result_ref;
20505         }
20506
20507         wxPyEndAllowThreads(__tstate);
20508         if (PyErr_Occurred()) SWIG_fail;
20509     }
20510     {
20511 #if wxUSE_UNICODE
20512         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20513 #else
20514         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20515 #endif
20516     }
20517     return resultobj;
20518     fail:
20519     return NULL;
20520 }
20521
20522
20523 static PyObject *_wrap_PrintData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
20524     PyObject *resultobj;
20525     wxPrintData *arg1 = (wxPrintData *) 0 ;
20526     bool result;
20527     PyObject * obj0 = 0 ;
20528     char *kwnames[] = {
20529         (char *) "self", NULL
20530     };
20531
20532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetColour",kwnames,&obj0)) goto fail;
20533     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20534     if (SWIG_arg_fail(1)) SWIG_fail;
20535     {
20536         PyThreadState* __tstate = wxPyBeginAllowThreads();
20537         result = (bool)(arg1)->GetColour();
20538
20539         wxPyEndAllowThreads(__tstate);
20540         if (PyErr_Occurred()) SWIG_fail;
20541     }
20542     {
20543         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20544     }
20545     return resultobj;
20546     fail:
20547     return NULL;
20548 }
20549
20550
20551 static PyObject *_wrap_PrintData_GetDuplex(PyObject *, PyObject *args, PyObject *kwargs) {
20552     PyObject *resultobj;
20553     wxPrintData *arg1 = (wxPrintData *) 0 ;
20554     wxDuplexMode result;
20555     PyObject * obj0 = 0 ;
20556     char *kwnames[] = {
20557         (char *) "self", NULL
20558     };
20559
20560     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetDuplex",kwnames,&obj0)) goto fail;
20561     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20562     if (SWIG_arg_fail(1)) SWIG_fail;
20563     {
20564         PyThreadState* __tstate = wxPyBeginAllowThreads();
20565         result = (wxDuplexMode)(arg1)->GetDuplex();
20566
20567         wxPyEndAllowThreads(__tstate);
20568         if (PyErr_Occurred()) SWIG_fail;
20569     }
20570     resultobj = SWIG_From_int((result));
20571     return resultobj;
20572     fail:
20573     return NULL;
20574 }
20575
20576
20577 static PyObject *_wrap_PrintData_GetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
20578     PyObject *resultobj;
20579     wxPrintData *arg1 = (wxPrintData *) 0 ;
20580     wxPaperSize result;
20581     PyObject * obj0 = 0 ;
20582     char *kwnames[] = {
20583         (char *) "self", NULL
20584     };
20585
20586     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPaperId",kwnames,&obj0)) goto fail;
20587     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20588     if (SWIG_arg_fail(1)) SWIG_fail;
20589     {
20590         PyThreadState* __tstate = wxPyBeginAllowThreads();
20591         result = (wxPaperSize)(arg1)->GetPaperId();
20592
20593         wxPyEndAllowThreads(__tstate);
20594         if (PyErr_Occurred()) SWIG_fail;
20595     }
20596     resultobj = SWIG_From_int((result));
20597     return resultobj;
20598     fail:
20599     return NULL;
20600 }
20601
20602
20603 static PyObject *_wrap_PrintData_GetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
20604     PyObject *resultobj;
20605     wxPrintData *arg1 = (wxPrintData *) 0 ;
20606     wxSize *result;
20607     PyObject * obj0 = 0 ;
20608     char *kwnames[] = {
20609         (char *) "self", NULL
20610     };
20611
20612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPaperSize",kwnames,&obj0)) goto fail;
20613     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20614     if (SWIG_arg_fail(1)) SWIG_fail;
20615     {
20616         PyThreadState* __tstate = wxPyBeginAllowThreads();
20617         {
20618             wxSize const &_result_ref = (arg1)->GetPaperSize();
20619             result = (wxSize *) &_result_ref;
20620         }
20621
20622         wxPyEndAllowThreads(__tstate);
20623         if (PyErr_Occurred()) SWIG_fail;
20624     }
20625     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20626     return resultobj;
20627     fail:
20628     return NULL;
20629 }
20630
20631
20632 static PyObject *_wrap_PrintData_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
20633     PyObject *resultobj;
20634     wxPrintData *arg1 = (wxPrintData *) 0 ;
20635     int result;
20636     PyObject * obj0 = 0 ;
20637     char *kwnames[] = {
20638         (char *) "self", NULL
20639     };
20640
20641     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetQuality",kwnames,&obj0)) goto fail;
20642     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20643     if (SWIG_arg_fail(1)) SWIG_fail;
20644     {
20645         PyThreadState* __tstate = wxPyBeginAllowThreads();
20646         result = (int)(arg1)->GetQuality();
20647
20648         wxPyEndAllowThreads(__tstate);
20649         if (PyErr_Occurred()) SWIG_fail;
20650     }
20651     {
20652         resultobj = SWIG_From_int((int)(result));
20653     }
20654     return resultobj;
20655     fail:
20656     return NULL;
20657 }
20658
20659
20660 static PyObject *_wrap_PrintData_GetBin(PyObject *, PyObject *args, PyObject *kwargs) {
20661     PyObject *resultobj;
20662     wxPrintData *arg1 = (wxPrintData *) 0 ;
20663     wxPrintBin result;
20664     PyObject * obj0 = 0 ;
20665     char *kwnames[] = {
20666         (char *) "self", NULL
20667     };
20668
20669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetBin",kwnames,&obj0)) goto fail;
20670     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20671     if (SWIG_arg_fail(1)) SWIG_fail;
20672     {
20673         PyThreadState* __tstate = wxPyBeginAllowThreads();
20674         result = (wxPrintBin)(arg1)->GetBin();
20675
20676         wxPyEndAllowThreads(__tstate);
20677         if (PyErr_Occurred()) SWIG_fail;
20678     }
20679     resultobj = SWIG_From_int((result));
20680     return resultobj;
20681     fail:
20682     return NULL;
20683 }
20684
20685
20686 static PyObject *_wrap_PrintData_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
20687     PyObject *resultobj;
20688     wxPrintData *arg1 = (wxPrintData *) 0 ;
20689     wxPrintMode result;
20690     PyObject * obj0 = 0 ;
20691     char *kwnames[] = {
20692         (char *) "self", NULL
20693     };
20694
20695     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrintMode",kwnames,&obj0)) goto fail;
20696     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20697     if (SWIG_arg_fail(1)) SWIG_fail;
20698     {
20699         PyThreadState* __tstate = wxPyBeginAllowThreads();
20700         result = (wxPrintMode)((wxPrintData const *)arg1)->GetPrintMode();
20701
20702         wxPyEndAllowThreads(__tstate);
20703         if (PyErr_Occurred()) SWIG_fail;
20704     }
20705     resultobj = SWIG_From_int((result));
20706     return resultobj;
20707     fail:
20708     return NULL;
20709 }
20710
20711
20712 static PyObject *_wrap_PrintData_SetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
20713     PyObject *resultobj;
20714     wxPrintData *arg1 = (wxPrintData *) 0 ;
20715     int arg2 ;
20716     PyObject * obj0 = 0 ;
20717     PyObject * obj1 = 0 ;
20718     char *kwnames[] = {
20719         (char *) "self",(char *) "v", NULL
20720     };
20721
20722     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetNoCopies",kwnames,&obj0,&obj1)) goto fail;
20723     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20724     if (SWIG_arg_fail(1)) SWIG_fail;
20725     {
20726         arg2 = (int)(SWIG_As_int(obj1));
20727         if (SWIG_arg_fail(2)) SWIG_fail;
20728     }
20729     {
20730         PyThreadState* __tstate = wxPyBeginAllowThreads();
20731         (arg1)->SetNoCopies(arg2);
20732
20733         wxPyEndAllowThreads(__tstate);
20734         if (PyErr_Occurred()) SWIG_fail;
20735     }
20736     Py_INCREF(Py_None); resultobj = Py_None;
20737     return resultobj;
20738     fail:
20739     return NULL;
20740 }
20741
20742
20743 static PyObject *_wrap_PrintData_SetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
20744     PyObject *resultobj;
20745     wxPrintData *arg1 = (wxPrintData *) 0 ;
20746     bool arg2 ;
20747     PyObject * obj0 = 0 ;
20748     PyObject * obj1 = 0 ;
20749     char *kwnames[] = {
20750         (char *) "self",(char *) "flag", NULL
20751     };
20752
20753     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetCollate",kwnames,&obj0,&obj1)) goto fail;
20754     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20755     if (SWIG_arg_fail(1)) SWIG_fail;
20756     {
20757         arg2 = (bool)(SWIG_As_bool(obj1));
20758         if (SWIG_arg_fail(2)) SWIG_fail;
20759     }
20760     {
20761         PyThreadState* __tstate = wxPyBeginAllowThreads();
20762         (arg1)->SetCollate(arg2);
20763
20764         wxPyEndAllowThreads(__tstate);
20765         if (PyErr_Occurred()) SWIG_fail;
20766     }
20767     Py_INCREF(Py_None); resultobj = Py_None;
20768     return resultobj;
20769     fail:
20770     return NULL;
20771 }
20772
20773
20774 static PyObject *_wrap_PrintData_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
20775     PyObject *resultobj;
20776     wxPrintData *arg1 = (wxPrintData *) 0 ;
20777     int arg2 ;
20778     PyObject * obj0 = 0 ;
20779     PyObject * obj1 = 0 ;
20780     char *kwnames[] = {
20781         (char *) "self",(char *) "orient", NULL
20782     };
20783
20784     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
20785     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20786     if (SWIG_arg_fail(1)) SWIG_fail;
20787     {
20788         arg2 = (int)(SWIG_As_int(obj1));
20789         if (SWIG_arg_fail(2)) SWIG_fail;
20790     }
20791     {
20792         PyThreadState* __tstate = wxPyBeginAllowThreads();
20793         (arg1)->SetOrientation(arg2);
20794
20795         wxPyEndAllowThreads(__tstate);
20796         if (PyErr_Occurred()) SWIG_fail;
20797     }
20798     Py_INCREF(Py_None); resultobj = Py_None;
20799     return resultobj;
20800     fail:
20801     return NULL;
20802 }
20803
20804
20805 static PyObject *_wrap_PrintData_SetPrinterName(PyObject *, PyObject *args, PyObject *kwargs) {
20806     PyObject *resultobj;
20807     wxPrintData *arg1 = (wxPrintData *) 0 ;
20808     wxString *arg2 = 0 ;
20809     bool temp2 = false ;
20810     PyObject * obj0 = 0 ;
20811     PyObject * obj1 = 0 ;
20812     char *kwnames[] = {
20813         (char *) "self",(char *) "name", NULL
20814     };
20815
20816     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterName",kwnames,&obj0,&obj1)) goto fail;
20817     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20818     if (SWIG_arg_fail(1)) SWIG_fail;
20819     {
20820         arg2 = wxString_in_helper(obj1);
20821         if (arg2 == NULL) SWIG_fail;
20822         temp2 = true;
20823     }
20824     {
20825         PyThreadState* __tstate = wxPyBeginAllowThreads();
20826         (arg1)->SetPrinterName((wxString const &)*arg2);
20827
20828         wxPyEndAllowThreads(__tstate);
20829         if (PyErr_Occurred()) SWIG_fail;
20830     }
20831     Py_INCREF(Py_None); resultobj = Py_None;
20832     {
20833         if (temp2)
20834         delete arg2;
20835     }
20836     return resultobj;
20837     fail:
20838     {
20839         if (temp2)
20840         delete arg2;
20841     }
20842     return NULL;
20843 }
20844
20845
20846 static PyObject *_wrap_PrintData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
20847     PyObject *resultobj;
20848     wxPrintData *arg1 = (wxPrintData *) 0 ;
20849     bool arg2 ;
20850     PyObject * obj0 = 0 ;
20851     PyObject * obj1 = 0 ;
20852     char *kwnames[] = {
20853         (char *) "self",(char *) "colour", NULL
20854     };
20855
20856     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetColour",kwnames,&obj0,&obj1)) goto fail;
20857     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20858     if (SWIG_arg_fail(1)) SWIG_fail;
20859     {
20860         arg2 = (bool)(SWIG_As_bool(obj1));
20861         if (SWIG_arg_fail(2)) SWIG_fail;
20862     }
20863     {
20864         PyThreadState* __tstate = wxPyBeginAllowThreads();
20865         (arg1)->SetColour(arg2);
20866
20867         wxPyEndAllowThreads(__tstate);
20868         if (PyErr_Occurred()) SWIG_fail;
20869     }
20870     Py_INCREF(Py_None); resultobj = Py_None;
20871     return resultobj;
20872     fail:
20873     return NULL;
20874 }
20875
20876
20877 static PyObject *_wrap_PrintData_SetDuplex(PyObject *, PyObject *args, PyObject *kwargs) {
20878     PyObject *resultobj;
20879     wxPrintData *arg1 = (wxPrintData *) 0 ;
20880     wxDuplexMode arg2 ;
20881     PyObject * obj0 = 0 ;
20882     PyObject * obj1 = 0 ;
20883     char *kwnames[] = {
20884         (char *) "self",(char *) "duplex", NULL
20885     };
20886
20887     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetDuplex",kwnames,&obj0,&obj1)) goto fail;
20888     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20889     if (SWIG_arg_fail(1)) SWIG_fail;
20890     {
20891         arg2 = (wxDuplexMode)(SWIG_As_int(obj1));
20892         if (SWIG_arg_fail(2)) SWIG_fail;
20893     }
20894     {
20895         PyThreadState* __tstate = wxPyBeginAllowThreads();
20896         (arg1)->SetDuplex((wxDuplexMode )arg2);
20897
20898         wxPyEndAllowThreads(__tstate);
20899         if (PyErr_Occurred()) SWIG_fail;
20900     }
20901     Py_INCREF(Py_None); resultobj = Py_None;
20902     return resultobj;
20903     fail:
20904     return NULL;
20905 }
20906
20907
20908 static PyObject *_wrap_PrintData_SetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
20909     PyObject *resultobj;
20910     wxPrintData *arg1 = (wxPrintData *) 0 ;
20911     wxPaperSize arg2 ;
20912     PyObject * obj0 = 0 ;
20913     PyObject * obj1 = 0 ;
20914     char *kwnames[] = {
20915         (char *) "self",(char *) "sizeId", NULL
20916     };
20917
20918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPaperId",kwnames,&obj0,&obj1)) goto fail;
20919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20920     if (SWIG_arg_fail(1)) SWIG_fail;
20921     {
20922         arg2 = (wxPaperSize)(SWIG_As_int(obj1));
20923         if (SWIG_arg_fail(2)) SWIG_fail;
20924     }
20925     {
20926         PyThreadState* __tstate = wxPyBeginAllowThreads();
20927         (arg1)->SetPaperId((wxPaperSize )arg2);
20928
20929         wxPyEndAllowThreads(__tstate);
20930         if (PyErr_Occurred()) SWIG_fail;
20931     }
20932     Py_INCREF(Py_None); resultobj = Py_None;
20933     return resultobj;
20934     fail:
20935     return NULL;
20936 }
20937
20938
20939 static PyObject *_wrap_PrintData_SetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
20940     PyObject *resultobj;
20941     wxPrintData *arg1 = (wxPrintData *) 0 ;
20942     wxSize *arg2 = 0 ;
20943     wxSize temp2 ;
20944     PyObject * obj0 = 0 ;
20945     PyObject * obj1 = 0 ;
20946     char *kwnames[] = {
20947         (char *) "self",(char *) "sz", NULL
20948     };
20949
20950     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPaperSize",kwnames,&obj0,&obj1)) goto fail;
20951     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20952     if (SWIG_arg_fail(1)) SWIG_fail;
20953     {
20954         arg2 = &temp2;
20955         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
20956     }
20957     {
20958         PyThreadState* __tstate = wxPyBeginAllowThreads();
20959         (arg1)->SetPaperSize((wxSize const &)*arg2);
20960
20961         wxPyEndAllowThreads(__tstate);
20962         if (PyErr_Occurred()) SWIG_fail;
20963     }
20964     Py_INCREF(Py_None); resultobj = Py_None;
20965     return resultobj;
20966     fail:
20967     return NULL;
20968 }
20969
20970
20971 static PyObject *_wrap_PrintData_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
20972     PyObject *resultobj;
20973     wxPrintData *arg1 = (wxPrintData *) 0 ;
20974     int arg2 ;
20975     PyObject * obj0 = 0 ;
20976     PyObject * obj1 = 0 ;
20977     char *kwnames[] = {
20978         (char *) "self",(char *) "quality", NULL
20979     };
20980
20981     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetQuality",kwnames,&obj0,&obj1)) goto fail;
20982     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20983     if (SWIG_arg_fail(1)) SWIG_fail;
20984     {
20985         arg2 = (int)(SWIG_As_int(obj1));
20986         if (SWIG_arg_fail(2)) SWIG_fail;
20987     }
20988     {
20989         PyThreadState* __tstate = wxPyBeginAllowThreads();
20990         (arg1)->SetQuality(arg2);
20991
20992         wxPyEndAllowThreads(__tstate);
20993         if (PyErr_Occurred()) SWIG_fail;
20994     }
20995     Py_INCREF(Py_None); resultobj = Py_None;
20996     return resultobj;
20997     fail:
20998     return NULL;
20999 }
21000
21001
21002 static PyObject *_wrap_PrintData_SetBin(PyObject *, PyObject *args, PyObject *kwargs) {
21003     PyObject *resultobj;
21004     wxPrintData *arg1 = (wxPrintData *) 0 ;
21005     wxPrintBin arg2 ;
21006     PyObject * obj0 = 0 ;
21007     PyObject * obj1 = 0 ;
21008     char *kwnames[] = {
21009         (char *) "self",(char *) "bin", NULL
21010     };
21011
21012     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetBin",kwnames,&obj0,&obj1)) goto fail;
21013     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21014     if (SWIG_arg_fail(1)) SWIG_fail;
21015     {
21016         arg2 = (wxPrintBin)(SWIG_As_int(obj1));
21017         if (SWIG_arg_fail(2)) SWIG_fail;
21018     }
21019     {
21020         PyThreadState* __tstate = wxPyBeginAllowThreads();
21021         (arg1)->SetBin((wxPrintBin )arg2);
21022
21023         wxPyEndAllowThreads(__tstate);
21024         if (PyErr_Occurred()) SWIG_fail;
21025     }
21026     Py_INCREF(Py_None); resultobj = Py_None;
21027     return resultobj;
21028     fail:
21029     return NULL;
21030 }
21031
21032
21033 static PyObject *_wrap_PrintData_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
21034     PyObject *resultobj;
21035     wxPrintData *arg1 = (wxPrintData *) 0 ;
21036     wxPrintMode arg2 ;
21037     PyObject * obj0 = 0 ;
21038     PyObject * obj1 = 0 ;
21039     char *kwnames[] = {
21040         (char *) "self",(char *) "printMode", NULL
21041     };
21042
21043     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
21044     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21045     if (SWIG_arg_fail(1)) SWIG_fail;
21046     {
21047         arg2 = (wxPrintMode)(SWIG_As_int(obj1));
21048         if (SWIG_arg_fail(2)) SWIG_fail;
21049     }
21050     {
21051         PyThreadState* __tstate = wxPyBeginAllowThreads();
21052         (arg1)->SetPrintMode((wxPrintMode )arg2);
21053
21054         wxPyEndAllowThreads(__tstate);
21055         if (PyErr_Occurred()) SWIG_fail;
21056     }
21057     Py_INCREF(Py_None); resultobj = Py_None;
21058     return resultobj;
21059     fail:
21060     return NULL;
21061 }
21062
21063
21064 static PyObject *_wrap_PrintData_GetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
21065     PyObject *resultobj;
21066     wxPrintData *arg1 = (wxPrintData *) 0 ;
21067     wxString result;
21068     PyObject * obj0 = 0 ;
21069     char *kwnames[] = {
21070         (char *) "self", NULL
21071     };
21072
21073     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetFilename",kwnames,&obj0)) goto fail;
21074     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21075     if (SWIG_arg_fail(1)) SWIG_fail;
21076     {
21077         PyThreadState* __tstate = wxPyBeginAllowThreads();
21078         result = ((wxPrintData const *)arg1)->GetFilename();
21079
21080         wxPyEndAllowThreads(__tstate);
21081         if (PyErr_Occurred()) SWIG_fail;
21082     }
21083     {
21084 #if wxUSE_UNICODE
21085         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21086 #else
21087         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21088 #endif
21089     }
21090     return resultobj;
21091     fail:
21092     return NULL;
21093 }
21094
21095
21096 static PyObject *_wrap_PrintData_SetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
21097     PyObject *resultobj;
21098     wxPrintData *arg1 = (wxPrintData *) 0 ;
21099     wxString *arg2 = 0 ;
21100     bool temp2 = false ;
21101     PyObject * obj0 = 0 ;
21102     PyObject * obj1 = 0 ;
21103     char *kwnames[] = {
21104         (char *) "self",(char *) "filename", NULL
21105     };
21106
21107     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetFilename",kwnames,&obj0,&obj1)) goto fail;
21108     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21109     if (SWIG_arg_fail(1)) SWIG_fail;
21110     {
21111         arg2 = wxString_in_helper(obj1);
21112         if (arg2 == NULL) SWIG_fail;
21113         temp2 = true;
21114     }
21115     {
21116         PyThreadState* __tstate = wxPyBeginAllowThreads();
21117         (arg1)->SetFilename((wxString const &)*arg2);
21118
21119         wxPyEndAllowThreads(__tstate);
21120         if (PyErr_Occurred()) SWIG_fail;
21121     }
21122     Py_INCREF(Py_None); resultobj = Py_None;
21123     {
21124         if (temp2)
21125         delete arg2;
21126     }
21127     return resultobj;
21128     fail:
21129     {
21130         if (temp2)
21131         delete arg2;
21132     }
21133     return NULL;
21134 }
21135
21136
21137 static PyObject *_wrap_PrintData_GetPrivData(PyObject *, PyObject *args, PyObject *kwargs) {
21138     PyObject *resultobj;
21139     wxPrintData *arg1 = (wxPrintData *) 0 ;
21140     PyObject *result;
21141     PyObject * obj0 = 0 ;
21142     char *kwnames[] = {
21143         (char *) "self", NULL
21144     };
21145
21146     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrivData",kwnames,&obj0)) goto fail;
21147     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21148     if (SWIG_arg_fail(1)) SWIG_fail;
21149     {
21150         PyThreadState* __tstate = wxPyBeginAllowThreads();
21151         result = (PyObject *)wxPrintData_GetPrivData(arg1);
21152
21153         wxPyEndAllowThreads(__tstate);
21154         if (PyErr_Occurred()) SWIG_fail;
21155     }
21156     resultobj = result;
21157     return resultobj;
21158     fail:
21159     return NULL;
21160 }
21161
21162
21163 static PyObject *_wrap_PrintData_SetPrivData(PyObject *, PyObject *args, PyObject *kwargs) {
21164     PyObject *resultobj;
21165     wxPrintData *arg1 = (wxPrintData *) 0 ;
21166     PyObject *arg2 = (PyObject *) 0 ;
21167     PyObject * obj0 = 0 ;
21168     PyObject * obj1 = 0 ;
21169     char *kwnames[] = {
21170         (char *) "self",(char *) "data", NULL
21171     };
21172
21173     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrivData",kwnames,&obj0,&obj1)) goto fail;
21174     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21175     if (SWIG_arg_fail(1)) SWIG_fail;
21176     arg2 = obj1;
21177     {
21178         PyThreadState* __tstate = wxPyBeginAllowThreads();
21179         wxPrintData_SetPrivData(arg1,arg2);
21180
21181         wxPyEndAllowThreads(__tstate);
21182         if (PyErr_Occurred()) SWIG_fail;
21183     }
21184     Py_INCREF(Py_None); resultobj = Py_None;
21185     return resultobj;
21186     fail:
21187     return NULL;
21188 }
21189
21190
21191 static PyObject *_wrap_PrintData_GetPrinterCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21192     PyObject *resultobj;
21193     wxPrintData *arg1 = (wxPrintData *) 0 ;
21194     wxString *result;
21195     PyObject * obj0 = 0 ;
21196     char *kwnames[] = {
21197         (char *) "self", NULL
21198     };
21199
21200     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterCommand",kwnames,&obj0)) goto fail;
21201     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21202     if (SWIG_arg_fail(1)) SWIG_fail;
21203     {
21204         PyThreadState* __tstate = wxPyBeginAllowThreads();
21205         {
21206             wxString const &_result_ref = (arg1)->GetPrinterCommand();
21207             result = (wxString *) &_result_ref;
21208         }
21209
21210         wxPyEndAllowThreads(__tstate);
21211         if (PyErr_Occurred()) SWIG_fail;
21212     }
21213     {
21214 #if wxUSE_UNICODE
21215         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21216 #else
21217         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21218 #endif
21219     }
21220     return resultobj;
21221     fail:
21222     return NULL;
21223 }
21224
21225
21226 static PyObject *_wrap_PrintData_GetPrinterOptions(PyObject *, PyObject *args, PyObject *kwargs) {
21227     PyObject *resultobj;
21228     wxPrintData *arg1 = (wxPrintData *) 0 ;
21229     wxString *result;
21230     PyObject * obj0 = 0 ;
21231     char *kwnames[] = {
21232         (char *) "self", NULL
21233     };
21234
21235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterOptions",kwnames,&obj0)) goto fail;
21236     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21237     if (SWIG_arg_fail(1)) SWIG_fail;
21238     {
21239         PyThreadState* __tstate = wxPyBeginAllowThreads();
21240         {
21241             wxString const &_result_ref = (arg1)->GetPrinterOptions();
21242             result = (wxString *) &_result_ref;
21243         }
21244
21245         wxPyEndAllowThreads(__tstate);
21246         if (PyErr_Occurred()) SWIG_fail;
21247     }
21248     {
21249 #if wxUSE_UNICODE
21250         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21251 #else
21252         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21253 #endif
21254     }
21255     return resultobj;
21256     fail:
21257     return NULL;
21258 }
21259
21260
21261 static PyObject *_wrap_PrintData_GetPreviewCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21262     PyObject *resultobj;
21263     wxPrintData *arg1 = (wxPrintData *) 0 ;
21264     wxString *result;
21265     PyObject * obj0 = 0 ;
21266     char *kwnames[] = {
21267         (char *) "self", NULL
21268     };
21269
21270     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPreviewCommand",kwnames,&obj0)) goto fail;
21271     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21272     if (SWIG_arg_fail(1)) SWIG_fail;
21273     {
21274         PyThreadState* __tstate = wxPyBeginAllowThreads();
21275         {
21276             wxString const &_result_ref = (arg1)->GetPreviewCommand();
21277             result = (wxString *) &_result_ref;
21278         }
21279
21280         wxPyEndAllowThreads(__tstate);
21281         if (PyErr_Occurred()) SWIG_fail;
21282     }
21283     {
21284 #if wxUSE_UNICODE
21285         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21286 #else
21287         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21288 #endif
21289     }
21290     return resultobj;
21291     fail:
21292     return NULL;
21293 }
21294
21295
21296 static PyObject *_wrap_PrintData_GetFontMetricPath(PyObject *, PyObject *args, PyObject *kwargs) {
21297     PyObject *resultobj;
21298     wxPrintData *arg1 = (wxPrintData *) 0 ;
21299     wxString *result;
21300     PyObject * obj0 = 0 ;
21301     char *kwnames[] = {
21302         (char *) "self", NULL
21303     };
21304
21305     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetFontMetricPath",kwnames,&obj0)) goto fail;
21306     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21307     if (SWIG_arg_fail(1)) SWIG_fail;
21308     {
21309         PyThreadState* __tstate = wxPyBeginAllowThreads();
21310         {
21311             wxString const &_result_ref = (arg1)->GetFontMetricPath();
21312             result = (wxString *) &_result_ref;
21313         }
21314
21315         wxPyEndAllowThreads(__tstate);
21316         if (PyErr_Occurred()) SWIG_fail;
21317     }
21318     {
21319 #if wxUSE_UNICODE
21320         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21321 #else
21322         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21323 #endif
21324     }
21325     return resultobj;
21326     fail:
21327     return NULL;
21328 }
21329
21330
21331 static PyObject *_wrap_PrintData_GetPrinterScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
21332     PyObject *resultobj;
21333     wxPrintData *arg1 = (wxPrintData *) 0 ;
21334     double result;
21335     PyObject * obj0 = 0 ;
21336     char *kwnames[] = {
21337         (char *) "self", NULL
21338     };
21339
21340     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterScaleX",kwnames,&obj0)) goto fail;
21341     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21342     if (SWIG_arg_fail(1)) SWIG_fail;
21343     {
21344         PyThreadState* __tstate = wxPyBeginAllowThreads();
21345         result = (double)(arg1)->GetPrinterScaleX();
21346
21347         wxPyEndAllowThreads(__tstate);
21348         if (PyErr_Occurred()) SWIG_fail;
21349     }
21350     {
21351         resultobj = SWIG_From_double((double)(result));
21352     }
21353     return resultobj;
21354     fail:
21355     return NULL;
21356 }
21357
21358
21359 static PyObject *_wrap_PrintData_GetPrinterScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
21360     PyObject *resultobj;
21361     wxPrintData *arg1 = (wxPrintData *) 0 ;
21362     double result;
21363     PyObject * obj0 = 0 ;
21364     char *kwnames[] = {
21365         (char *) "self", NULL
21366     };
21367
21368     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterScaleY",kwnames,&obj0)) goto fail;
21369     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21370     if (SWIG_arg_fail(1)) SWIG_fail;
21371     {
21372         PyThreadState* __tstate = wxPyBeginAllowThreads();
21373         result = (double)(arg1)->GetPrinterScaleY();
21374
21375         wxPyEndAllowThreads(__tstate);
21376         if (PyErr_Occurred()) SWIG_fail;
21377     }
21378     {
21379         resultobj = SWIG_From_double((double)(result));
21380     }
21381     return resultobj;
21382     fail:
21383     return NULL;
21384 }
21385
21386
21387 static PyObject *_wrap_PrintData_GetPrinterTranslateX(PyObject *, PyObject *args, PyObject *kwargs) {
21388     PyObject *resultobj;
21389     wxPrintData *arg1 = (wxPrintData *) 0 ;
21390     long result;
21391     PyObject * obj0 = 0 ;
21392     char *kwnames[] = {
21393         (char *) "self", NULL
21394     };
21395
21396     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterTranslateX",kwnames,&obj0)) goto fail;
21397     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21398     if (SWIG_arg_fail(1)) SWIG_fail;
21399     {
21400         PyThreadState* __tstate = wxPyBeginAllowThreads();
21401         result = (long)(arg1)->GetPrinterTranslateX();
21402
21403         wxPyEndAllowThreads(__tstate);
21404         if (PyErr_Occurred()) SWIG_fail;
21405     }
21406     {
21407         resultobj = SWIG_From_long((long)(result));
21408     }
21409     return resultobj;
21410     fail:
21411     return NULL;
21412 }
21413
21414
21415 static PyObject *_wrap_PrintData_GetPrinterTranslateY(PyObject *, PyObject *args, PyObject *kwargs) {
21416     PyObject *resultobj;
21417     wxPrintData *arg1 = (wxPrintData *) 0 ;
21418     long result;
21419     PyObject * obj0 = 0 ;
21420     char *kwnames[] = {
21421         (char *) "self", NULL
21422     };
21423
21424     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterTranslateY",kwnames,&obj0)) goto fail;
21425     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21426     if (SWIG_arg_fail(1)) SWIG_fail;
21427     {
21428         PyThreadState* __tstate = wxPyBeginAllowThreads();
21429         result = (long)(arg1)->GetPrinterTranslateY();
21430
21431         wxPyEndAllowThreads(__tstate);
21432         if (PyErr_Occurred()) SWIG_fail;
21433     }
21434     {
21435         resultobj = SWIG_From_long((long)(result));
21436     }
21437     return resultobj;
21438     fail:
21439     return NULL;
21440 }
21441
21442
21443 static PyObject *_wrap_PrintData_SetPrinterCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21444     PyObject *resultobj;
21445     wxPrintData *arg1 = (wxPrintData *) 0 ;
21446     wxString *arg2 = 0 ;
21447     bool temp2 = false ;
21448     PyObject * obj0 = 0 ;
21449     PyObject * obj1 = 0 ;
21450     char *kwnames[] = {
21451         (char *) "self",(char *) "command", NULL
21452     };
21453
21454     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterCommand",kwnames,&obj0,&obj1)) goto fail;
21455     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21456     if (SWIG_arg_fail(1)) SWIG_fail;
21457     {
21458         arg2 = wxString_in_helper(obj1);
21459         if (arg2 == NULL) SWIG_fail;
21460         temp2 = true;
21461     }
21462     {
21463         PyThreadState* __tstate = wxPyBeginAllowThreads();
21464         (arg1)->SetPrinterCommand((wxString const &)*arg2);
21465
21466         wxPyEndAllowThreads(__tstate);
21467         if (PyErr_Occurred()) SWIG_fail;
21468     }
21469     Py_INCREF(Py_None); resultobj = Py_None;
21470     {
21471         if (temp2)
21472         delete arg2;
21473     }
21474     return resultobj;
21475     fail:
21476     {
21477         if (temp2)
21478         delete arg2;
21479     }
21480     return NULL;
21481 }
21482
21483
21484 static PyObject *_wrap_PrintData_SetPrinterOptions(PyObject *, PyObject *args, PyObject *kwargs) {
21485     PyObject *resultobj;
21486     wxPrintData *arg1 = (wxPrintData *) 0 ;
21487     wxString *arg2 = 0 ;
21488     bool temp2 = false ;
21489     PyObject * obj0 = 0 ;
21490     PyObject * obj1 = 0 ;
21491     char *kwnames[] = {
21492         (char *) "self",(char *) "options", NULL
21493     };
21494
21495     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterOptions",kwnames,&obj0,&obj1)) goto fail;
21496     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21497     if (SWIG_arg_fail(1)) SWIG_fail;
21498     {
21499         arg2 = wxString_in_helper(obj1);
21500         if (arg2 == NULL) SWIG_fail;
21501         temp2 = true;
21502     }
21503     {
21504         PyThreadState* __tstate = wxPyBeginAllowThreads();
21505         (arg1)->SetPrinterOptions((wxString const &)*arg2);
21506
21507         wxPyEndAllowThreads(__tstate);
21508         if (PyErr_Occurred()) SWIG_fail;
21509     }
21510     Py_INCREF(Py_None); resultobj = Py_None;
21511     {
21512         if (temp2)
21513         delete arg2;
21514     }
21515     return resultobj;
21516     fail:
21517     {
21518         if (temp2)
21519         delete arg2;
21520     }
21521     return NULL;
21522 }
21523
21524
21525 static PyObject *_wrap_PrintData_SetPreviewCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21526     PyObject *resultobj;
21527     wxPrintData *arg1 = (wxPrintData *) 0 ;
21528     wxString *arg2 = 0 ;
21529     bool temp2 = false ;
21530     PyObject * obj0 = 0 ;
21531     PyObject * obj1 = 0 ;
21532     char *kwnames[] = {
21533         (char *) "self",(char *) "command", NULL
21534     };
21535
21536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPreviewCommand",kwnames,&obj0,&obj1)) goto fail;
21537     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21538     if (SWIG_arg_fail(1)) SWIG_fail;
21539     {
21540         arg2 = wxString_in_helper(obj1);
21541         if (arg2 == NULL) SWIG_fail;
21542         temp2 = true;
21543     }
21544     {
21545         PyThreadState* __tstate = wxPyBeginAllowThreads();
21546         (arg1)->SetPreviewCommand((wxString const &)*arg2);
21547
21548         wxPyEndAllowThreads(__tstate);
21549         if (PyErr_Occurred()) SWIG_fail;
21550     }
21551     Py_INCREF(Py_None); resultobj = Py_None;
21552     {
21553         if (temp2)
21554         delete arg2;
21555     }
21556     return resultobj;
21557     fail:
21558     {
21559         if (temp2)
21560         delete arg2;
21561     }
21562     return NULL;
21563 }
21564
21565
21566 static PyObject *_wrap_PrintData_SetFontMetricPath(PyObject *, PyObject *args, PyObject *kwargs) {
21567     PyObject *resultobj;
21568     wxPrintData *arg1 = (wxPrintData *) 0 ;
21569     wxString *arg2 = 0 ;
21570     bool temp2 = false ;
21571     PyObject * obj0 = 0 ;
21572     PyObject * obj1 = 0 ;
21573     char *kwnames[] = {
21574         (char *) "self",(char *) "path", NULL
21575     };
21576
21577     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetFontMetricPath",kwnames,&obj0,&obj1)) goto fail;
21578     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21579     if (SWIG_arg_fail(1)) SWIG_fail;
21580     {
21581         arg2 = wxString_in_helper(obj1);
21582         if (arg2 == NULL) SWIG_fail;
21583         temp2 = true;
21584     }
21585     {
21586         PyThreadState* __tstate = wxPyBeginAllowThreads();
21587         (arg1)->SetFontMetricPath((wxString const &)*arg2);
21588
21589         wxPyEndAllowThreads(__tstate);
21590         if (PyErr_Occurred()) SWIG_fail;
21591     }
21592     Py_INCREF(Py_None); resultobj = Py_None;
21593     {
21594         if (temp2)
21595         delete arg2;
21596     }
21597     return resultobj;
21598     fail:
21599     {
21600         if (temp2)
21601         delete arg2;
21602     }
21603     return NULL;
21604 }
21605
21606
21607 static PyObject *_wrap_PrintData_SetPrinterScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
21608     PyObject *resultobj;
21609     wxPrintData *arg1 = (wxPrintData *) 0 ;
21610     double arg2 ;
21611     PyObject * obj0 = 0 ;
21612     PyObject * obj1 = 0 ;
21613     char *kwnames[] = {
21614         (char *) "self",(char *) "x", NULL
21615     };
21616
21617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterScaleX",kwnames,&obj0,&obj1)) goto fail;
21618     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21619     if (SWIG_arg_fail(1)) SWIG_fail;
21620     {
21621         arg2 = (double)(SWIG_As_double(obj1));
21622         if (SWIG_arg_fail(2)) SWIG_fail;
21623     }
21624     {
21625         PyThreadState* __tstate = wxPyBeginAllowThreads();
21626         (arg1)->SetPrinterScaleX(arg2);
21627
21628         wxPyEndAllowThreads(__tstate);
21629         if (PyErr_Occurred()) SWIG_fail;
21630     }
21631     Py_INCREF(Py_None); resultobj = Py_None;
21632     return resultobj;
21633     fail:
21634     return NULL;
21635 }
21636
21637
21638 static PyObject *_wrap_PrintData_SetPrinterScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
21639     PyObject *resultobj;
21640     wxPrintData *arg1 = (wxPrintData *) 0 ;
21641     double arg2 ;
21642     PyObject * obj0 = 0 ;
21643     PyObject * obj1 = 0 ;
21644     char *kwnames[] = {
21645         (char *) "self",(char *) "y", NULL
21646     };
21647
21648     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterScaleY",kwnames,&obj0,&obj1)) goto fail;
21649     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21650     if (SWIG_arg_fail(1)) SWIG_fail;
21651     {
21652         arg2 = (double)(SWIG_As_double(obj1));
21653         if (SWIG_arg_fail(2)) SWIG_fail;
21654     }
21655     {
21656         PyThreadState* __tstate = wxPyBeginAllowThreads();
21657         (arg1)->SetPrinterScaleY(arg2);
21658
21659         wxPyEndAllowThreads(__tstate);
21660         if (PyErr_Occurred()) SWIG_fail;
21661     }
21662     Py_INCREF(Py_None); resultobj = Py_None;
21663     return resultobj;
21664     fail:
21665     return NULL;
21666 }
21667
21668
21669 static PyObject *_wrap_PrintData_SetPrinterScaling(PyObject *, PyObject *args, PyObject *kwargs) {
21670     PyObject *resultobj;
21671     wxPrintData *arg1 = (wxPrintData *) 0 ;
21672     double arg2 ;
21673     double arg3 ;
21674     PyObject * obj0 = 0 ;
21675     PyObject * obj1 = 0 ;
21676     PyObject * obj2 = 0 ;
21677     char *kwnames[] = {
21678         (char *) "self",(char *) "x",(char *) "y", NULL
21679     };
21680
21681     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintData_SetPrinterScaling",kwnames,&obj0,&obj1,&obj2)) goto fail;
21682     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21683     if (SWIG_arg_fail(1)) SWIG_fail;
21684     {
21685         arg2 = (double)(SWIG_As_double(obj1));
21686         if (SWIG_arg_fail(2)) SWIG_fail;
21687     }
21688     {
21689         arg3 = (double)(SWIG_As_double(obj2));
21690         if (SWIG_arg_fail(3)) SWIG_fail;
21691     }
21692     {
21693         PyThreadState* __tstate = wxPyBeginAllowThreads();
21694         (arg1)->SetPrinterScaling(arg2,arg3);
21695
21696         wxPyEndAllowThreads(__tstate);
21697         if (PyErr_Occurred()) SWIG_fail;
21698     }
21699     Py_INCREF(Py_None); resultobj = Py_None;
21700     return resultobj;
21701     fail:
21702     return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_PrintData_SetPrinterTranslateX(PyObject *, PyObject *args, PyObject *kwargs) {
21707     PyObject *resultobj;
21708     wxPrintData *arg1 = (wxPrintData *) 0 ;
21709     long arg2 ;
21710     PyObject * obj0 = 0 ;
21711     PyObject * obj1 = 0 ;
21712     char *kwnames[] = {
21713         (char *) "self",(char *) "x", NULL
21714     };
21715
21716     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterTranslateX",kwnames,&obj0,&obj1)) goto fail;
21717     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21718     if (SWIG_arg_fail(1)) SWIG_fail;
21719     {
21720         arg2 = (long)(SWIG_As_long(obj1));
21721         if (SWIG_arg_fail(2)) SWIG_fail;
21722     }
21723     {
21724         PyThreadState* __tstate = wxPyBeginAllowThreads();
21725         (arg1)->SetPrinterTranslateX(arg2);
21726
21727         wxPyEndAllowThreads(__tstate);
21728         if (PyErr_Occurred()) SWIG_fail;
21729     }
21730     Py_INCREF(Py_None); resultobj = Py_None;
21731     return resultobj;
21732     fail:
21733     return NULL;
21734 }
21735
21736
21737 static PyObject *_wrap_PrintData_SetPrinterTranslateY(PyObject *, PyObject *args, PyObject *kwargs) {
21738     PyObject *resultobj;
21739     wxPrintData *arg1 = (wxPrintData *) 0 ;
21740     long arg2 ;
21741     PyObject * obj0 = 0 ;
21742     PyObject * obj1 = 0 ;
21743     char *kwnames[] = {
21744         (char *) "self",(char *) "y", NULL
21745     };
21746
21747     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterTranslateY",kwnames,&obj0,&obj1)) goto fail;
21748     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21749     if (SWIG_arg_fail(1)) SWIG_fail;
21750     {
21751         arg2 = (long)(SWIG_As_long(obj1));
21752         if (SWIG_arg_fail(2)) SWIG_fail;
21753     }
21754     {
21755         PyThreadState* __tstate = wxPyBeginAllowThreads();
21756         (arg1)->SetPrinterTranslateY(arg2);
21757
21758         wxPyEndAllowThreads(__tstate);
21759         if (PyErr_Occurred()) SWIG_fail;
21760     }
21761     Py_INCREF(Py_None); resultobj = Py_None;
21762     return resultobj;
21763     fail:
21764     return NULL;
21765 }
21766
21767
21768 static PyObject *_wrap_PrintData_SetPrinterTranslation(PyObject *, PyObject *args, PyObject *kwargs) {
21769     PyObject *resultobj;
21770     wxPrintData *arg1 = (wxPrintData *) 0 ;
21771     long arg2 ;
21772     long arg3 ;
21773     PyObject * obj0 = 0 ;
21774     PyObject * obj1 = 0 ;
21775     PyObject * obj2 = 0 ;
21776     char *kwnames[] = {
21777         (char *) "self",(char *) "x",(char *) "y", NULL
21778     };
21779
21780     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintData_SetPrinterTranslation",kwnames,&obj0,&obj1,&obj2)) goto fail;
21781     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21782     if (SWIG_arg_fail(1)) SWIG_fail;
21783     {
21784         arg2 = (long)(SWIG_As_long(obj1));
21785         if (SWIG_arg_fail(2)) SWIG_fail;
21786     }
21787     {
21788         arg3 = (long)(SWIG_As_long(obj2));
21789         if (SWIG_arg_fail(3)) SWIG_fail;
21790     }
21791     {
21792         PyThreadState* __tstate = wxPyBeginAllowThreads();
21793         (arg1)->SetPrinterTranslation(arg2,arg3);
21794
21795         wxPyEndAllowThreads(__tstate);
21796         if (PyErr_Occurred()) SWIG_fail;
21797     }
21798     Py_INCREF(Py_None); resultobj = Py_None;
21799     return resultobj;
21800     fail:
21801     return NULL;
21802 }
21803
21804
21805 static PyObject * PrintData_swigregister(PyObject *, PyObject *args) {
21806     PyObject *obj;
21807     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21808     SWIG_TypeClientData(SWIGTYPE_p_wxPrintData, obj);
21809     Py_INCREF(obj);
21810     return Py_BuildValue((char *)"");
21811 }
21812 static PyObject *_wrap_new_PageSetupDialogData__SWIG_0(PyObject *, PyObject *args) {
21813     PyObject *resultobj;
21814     wxPageSetupDialogData *result;
21815
21816     if(!PyArg_ParseTuple(args,(char *)":new_PageSetupDialogData")) goto fail;
21817     {
21818         PyThreadState* __tstate = wxPyBeginAllowThreads();
21819         result = (wxPageSetupDialogData *)new wxPageSetupDialogData();
21820
21821         wxPyEndAllowThreads(__tstate);
21822         if (PyErr_Occurred()) SWIG_fail;
21823     }
21824     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21825     return resultobj;
21826     fail:
21827     return NULL;
21828 }
21829
21830
21831 static PyObject *_wrap_new_PageSetupDialogData__SWIG_1(PyObject *, PyObject *args) {
21832     PyObject *resultobj;
21833     wxPageSetupDialogData *arg1 = 0 ;
21834     wxPageSetupDialogData *result;
21835     PyObject * obj0 = 0 ;
21836
21837     if(!PyArg_ParseTuple(args,(char *)"O:new_PageSetupDialogData",&obj0)) goto fail;
21838     {
21839         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21840         if (SWIG_arg_fail(1)) SWIG_fail;
21841         if (arg1 == NULL) {
21842             SWIG_null_ref("wxPageSetupDialogData");
21843         }
21844         if (SWIG_arg_fail(1)) SWIG_fail;
21845     }
21846     {
21847         PyThreadState* __tstate = wxPyBeginAllowThreads();
21848         result = (wxPageSetupDialogData *)new wxPageSetupDialogData((wxPageSetupDialogData const &)*arg1);
21849
21850         wxPyEndAllowThreads(__tstate);
21851         if (PyErr_Occurred()) SWIG_fail;
21852     }
21853     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21854     return resultobj;
21855     fail:
21856     return NULL;
21857 }
21858
21859
21860 static PyObject *_wrap_new_PageSetupDialogData__SWIG_2(PyObject *, PyObject *args) {
21861     PyObject *resultobj;
21862     wxPrintData *arg1 = 0 ;
21863     wxPageSetupDialogData *result;
21864     PyObject * obj0 = 0 ;
21865
21866     if(!PyArg_ParseTuple(args,(char *)"O:new_PageSetupDialogData",&obj0)) goto fail;
21867     {
21868         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21869         if (SWIG_arg_fail(1)) SWIG_fail;
21870         if (arg1 == NULL) {
21871             SWIG_null_ref("wxPrintData");
21872         }
21873         if (SWIG_arg_fail(1)) SWIG_fail;
21874     }
21875     {
21876         PyThreadState* __tstate = wxPyBeginAllowThreads();
21877         result = (wxPageSetupDialogData *)new wxPageSetupDialogData((wxPrintData const &)*arg1);
21878
21879         wxPyEndAllowThreads(__tstate);
21880         if (PyErr_Occurred()) SWIG_fail;
21881     }
21882     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21883     return resultobj;
21884     fail:
21885     return NULL;
21886 }
21887
21888
21889 static PyObject *_wrap_new_PageSetupDialogData(PyObject *self, PyObject *args) {
21890     int argc;
21891     PyObject *argv[2];
21892     int ii;
21893
21894     argc = PyObject_Length(args);
21895     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
21896         argv[ii] = PyTuple_GetItem(args,ii);
21897     }
21898     if (argc == 0) {
21899         return _wrap_new_PageSetupDialogData__SWIG_0(self,args);
21900     }
21901     if (argc == 1) {
21902         int _v;
21903         {
21904             void *ptr = 0;
21905             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPageSetupDialogData, 0) == -1) {
21906                 _v = 0;
21907                 PyErr_Clear();
21908             } else {
21909                 _v = (ptr != 0);
21910             }
21911         }
21912         if (_v) {
21913             return _wrap_new_PageSetupDialogData__SWIG_1(self,args);
21914         }
21915     }
21916     if (argc == 1) {
21917         int _v;
21918         {
21919             void *ptr = 0;
21920             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
21921                 _v = 0;
21922                 PyErr_Clear();
21923             } else {
21924                 _v = (ptr != 0);
21925             }
21926         }
21927         if (_v) {
21928             return _wrap_new_PageSetupDialogData__SWIG_2(self,args);
21929         }
21930     }
21931
21932     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PageSetupDialogData'");
21933     return NULL;
21934 }
21935
21936
21937 static PyObject *_wrap_delete_PageSetupDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
21938     PyObject *resultobj;
21939     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
21940     PyObject * obj0 = 0 ;
21941     char *kwnames[] = {
21942         (char *) "self", NULL
21943     };
21944
21945     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PageSetupDialogData",kwnames,&obj0)) goto fail;
21946     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21947     if (SWIG_arg_fail(1)) SWIG_fail;
21948     {
21949         PyThreadState* __tstate = wxPyBeginAllowThreads();
21950         delete arg1;
21951
21952         wxPyEndAllowThreads(__tstate);
21953         if (PyErr_Occurred()) SWIG_fail;
21954     }
21955     Py_INCREF(Py_None); resultobj = Py_None;
21956     return resultobj;
21957     fail:
21958     return NULL;
21959 }
21960
21961
21962 static PyObject *_wrap_PageSetupDialogData_EnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
21963     PyObject *resultobj;
21964     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
21965     bool arg2 ;
21966     PyObject * obj0 = 0 ;
21967     PyObject * obj1 = 0 ;
21968     char *kwnames[] = {
21969         (char *) "self",(char *) "flag", NULL
21970     };
21971
21972     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableHelp",kwnames,&obj0,&obj1)) goto fail;
21973     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21974     if (SWIG_arg_fail(1)) SWIG_fail;
21975     {
21976         arg2 = (bool)(SWIG_As_bool(obj1));
21977         if (SWIG_arg_fail(2)) SWIG_fail;
21978     }
21979     {
21980         PyThreadState* __tstate = wxPyBeginAllowThreads();
21981         (arg1)->EnableHelp(arg2);
21982
21983         wxPyEndAllowThreads(__tstate);
21984         if (PyErr_Occurred()) SWIG_fail;
21985     }
21986     Py_INCREF(Py_None); resultobj = Py_None;
21987     return resultobj;
21988     fail:
21989     return NULL;
21990 }
21991
21992
21993 static PyObject *_wrap_PageSetupDialogData_EnableMargins(PyObject *, PyObject *args, PyObject *kwargs) {
21994     PyObject *resultobj;
21995     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
21996     bool arg2 ;
21997     PyObject * obj0 = 0 ;
21998     PyObject * obj1 = 0 ;
21999     char *kwnames[] = {
22000         (char *) "self",(char *) "flag", NULL
22001     };
22002
22003     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableMargins",kwnames,&obj0,&obj1)) goto fail;
22004     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22005     if (SWIG_arg_fail(1)) SWIG_fail;
22006     {
22007         arg2 = (bool)(SWIG_As_bool(obj1));
22008         if (SWIG_arg_fail(2)) SWIG_fail;
22009     }
22010     {
22011         PyThreadState* __tstate = wxPyBeginAllowThreads();
22012         (arg1)->EnableMargins(arg2);
22013
22014         wxPyEndAllowThreads(__tstate);
22015         if (PyErr_Occurred()) SWIG_fail;
22016     }
22017     Py_INCREF(Py_None); resultobj = Py_None;
22018     return resultobj;
22019     fail:
22020     return NULL;
22021 }
22022
22023
22024 static PyObject *_wrap_PageSetupDialogData_EnableOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
22025     PyObject *resultobj;
22026     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22027     bool arg2 ;
22028     PyObject * obj0 = 0 ;
22029     PyObject * obj1 = 0 ;
22030     char *kwnames[] = {
22031         (char *) "self",(char *) "flag", NULL
22032     };
22033
22034     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableOrientation",kwnames,&obj0,&obj1)) goto fail;
22035     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22036     if (SWIG_arg_fail(1)) SWIG_fail;
22037     {
22038         arg2 = (bool)(SWIG_As_bool(obj1));
22039         if (SWIG_arg_fail(2)) SWIG_fail;
22040     }
22041     {
22042         PyThreadState* __tstate = wxPyBeginAllowThreads();
22043         (arg1)->EnableOrientation(arg2);
22044
22045         wxPyEndAllowThreads(__tstate);
22046         if (PyErr_Occurred()) SWIG_fail;
22047     }
22048     Py_INCREF(Py_None); resultobj = Py_None;
22049     return resultobj;
22050     fail:
22051     return NULL;
22052 }
22053
22054
22055 static PyObject *_wrap_PageSetupDialogData_EnablePaper(PyObject *, PyObject *args, PyObject *kwargs) {
22056     PyObject *resultobj;
22057     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22058     bool arg2 ;
22059     PyObject * obj0 = 0 ;
22060     PyObject * obj1 = 0 ;
22061     char *kwnames[] = {
22062         (char *) "self",(char *) "flag", NULL
22063     };
22064
22065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnablePaper",kwnames,&obj0,&obj1)) goto fail;
22066     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22067     if (SWIG_arg_fail(1)) SWIG_fail;
22068     {
22069         arg2 = (bool)(SWIG_As_bool(obj1));
22070         if (SWIG_arg_fail(2)) SWIG_fail;
22071     }
22072     {
22073         PyThreadState* __tstate = wxPyBeginAllowThreads();
22074         (arg1)->EnablePaper(arg2);
22075
22076         wxPyEndAllowThreads(__tstate);
22077         if (PyErr_Occurred()) SWIG_fail;
22078     }
22079     Py_INCREF(Py_None); resultobj = Py_None;
22080     return resultobj;
22081     fail:
22082     return NULL;
22083 }
22084
22085
22086 static PyObject *_wrap_PageSetupDialogData_EnablePrinter(PyObject *, PyObject *args, PyObject *kwargs) {
22087     PyObject *resultobj;
22088     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22089     bool arg2 ;
22090     PyObject * obj0 = 0 ;
22091     PyObject * obj1 = 0 ;
22092     char *kwnames[] = {
22093         (char *) "self",(char *) "flag", NULL
22094     };
22095
22096     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnablePrinter",kwnames,&obj0,&obj1)) goto fail;
22097     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22098     if (SWIG_arg_fail(1)) SWIG_fail;
22099     {
22100         arg2 = (bool)(SWIG_As_bool(obj1));
22101         if (SWIG_arg_fail(2)) SWIG_fail;
22102     }
22103     {
22104         PyThreadState* __tstate = wxPyBeginAllowThreads();
22105         (arg1)->EnablePrinter(arg2);
22106
22107         wxPyEndAllowThreads(__tstate);
22108         if (PyErr_Occurred()) SWIG_fail;
22109     }
22110     Py_INCREF(Py_None); resultobj = Py_None;
22111     return resultobj;
22112     fail:
22113     return NULL;
22114 }
22115
22116
22117 static PyObject *_wrap_PageSetupDialogData_GetDefaultMinMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22118     PyObject *resultobj;
22119     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22120     bool result;
22121     PyObject * obj0 = 0 ;
22122     char *kwnames[] = {
22123         (char *) "self", NULL
22124     };
22125
22126     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetDefaultMinMargins",kwnames,&obj0)) goto fail;
22127     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22128     if (SWIG_arg_fail(1)) SWIG_fail;
22129     {
22130         PyThreadState* __tstate = wxPyBeginAllowThreads();
22131         result = (bool)(arg1)->GetDefaultMinMargins();
22132
22133         wxPyEndAllowThreads(__tstate);
22134         if (PyErr_Occurred()) SWIG_fail;
22135     }
22136     {
22137         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22138     }
22139     return resultobj;
22140     fail:
22141     return NULL;
22142 }
22143
22144
22145 static PyObject *_wrap_PageSetupDialogData_GetEnableMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22146     PyObject *resultobj;
22147     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22148     bool result;
22149     PyObject * obj0 = 0 ;
22150     char *kwnames[] = {
22151         (char *) "self", NULL
22152     };
22153
22154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableMargins",kwnames,&obj0)) goto fail;
22155     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22156     if (SWIG_arg_fail(1)) SWIG_fail;
22157     {
22158         PyThreadState* __tstate = wxPyBeginAllowThreads();
22159         result = (bool)(arg1)->GetEnableMargins();
22160
22161         wxPyEndAllowThreads(__tstate);
22162         if (PyErr_Occurred()) SWIG_fail;
22163     }
22164     {
22165         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22166     }
22167     return resultobj;
22168     fail:
22169     return NULL;
22170 }
22171
22172
22173 static PyObject *_wrap_PageSetupDialogData_GetEnableOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
22174     PyObject *resultobj;
22175     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22176     bool result;
22177     PyObject * obj0 = 0 ;
22178     char *kwnames[] = {
22179         (char *) "self", NULL
22180     };
22181
22182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableOrientation",kwnames,&obj0)) goto fail;
22183     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22184     if (SWIG_arg_fail(1)) SWIG_fail;
22185     {
22186         PyThreadState* __tstate = wxPyBeginAllowThreads();
22187         result = (bool)(arg1)->GetEnableOrientation();
22188
22189         wxPyEndAllowThreads(__tstate);
22190         if (PyErr_Occurred()) SWIG_fail;
22191     }
22192     {
22193         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22194     }
22195     return resultobj;
22196     fail:
22197     return NULL;
22198 }
22199
22200
22201 static PyObject *_wrap_PageSetupDialogData_GetEnablePaper(PyObject *, PyObject *args, PyObject *kwargs) {
22202     PyObject *resultobj;
22203     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22204     bool result;
22205     PyObject * obj0 = 0 ;
22206     char *kwnames[] = {
22207         (char *) "self", NULL
22208     };
22209
22210     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnablePaper",kwnames,&obj0)) goto fail;
22211     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22212     if (SWIG_arg_fail(1)) SWIG_fail;
22213     {
22214         PyThreadState* __tstate = wxPyBeginAllowThreads();
22215         result = (bool)(arg1)->GetEnablePaper();
22216
22217         wxPyEndAllowThreads(__tstate);
22218         if (PyErr_Occurred()) SWIG_fail;
22219     }
22220     {
22221         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22222     }
22223     return resultobj;
22224     fail:
22225     return NULL;
22226 }
22227
22228
22229 static PyObject *_wrap_PageSetupDialogData_GetEnablePrinter(PyObject *, PyObject *args, PyObject *kwargs) {
22230     PyObject *resultobj;
22231     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22232     bool result;
22233     PyObject * obj0 = 0 ;
22234     char *kwnames[] = {
22235         (char *) "self", NULL
22236     };
22237
22238     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnablePrinter",kwnames,&obj0)) goto fail;
22239     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22240     if (SWIG_arg_fail(1)) SWIG_fail;
22241     {
22242         PyThreadState* __tstate = wxPyBeginAllowThreads();
22243         result = (bool)(arg1)->GetEnablePrinter();
22244
22245         wxPyEndAllowThreads(__tstate);
22246         if (PyErr_Occurred()) SWIG_fail;
22247     }
22248     {
22249         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22250     }
22251     return resultobj;
22252     fail:
22253     return NULL;
22254 }
22255
22256
22257 static PyObject *_wrap_PageSetupDialogData_GetEnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
22258     PyObject *resultobj;
22259     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22260     bool result;
22261     PyObject * obj0 = 0 ;
22262     char *kwnames[] = {
22263         (char *) "self", NULL
22264     };
22265
22266     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableHelp",kwnames,&obj0)) goto fail;
22267     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22268     if (SWIG_arg_fail(1)) SWIG_fail;
22269     {
22270         PyThreadState* __tstate = wxPyBeginAllowThreads();
22271         result = (bool)(arg1)->GetEnableHelp();
22272
22273         wxPyEndAllowThreads(__tstate);
22274         if (PyErr_Occurred()) SWIG_fail;
22275     }
22276     {
22277         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22278     }
22279     return resultobj;
22280     fail:
22281     return NULL;
22282 }
22283
22284
22285 static PyObject *_wrap_PageSetupDialogData_GetDefaultInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22286     PyObject *resultobj;
22287     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22288     bool result;
22289     PyObject * obj0 = 0 ;
22290     char *kwnames[] = {
22291         (char *) "self", NULL
22292     };
22293
22294     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetDefaultInfo",kwnames,&obj0)) goto fail;
22295     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22296     if (SWIG_arg_fail(1)) SWIG_fail;
22297     {
22298         PyThreadState* __tstate = wxPyBeginAllowThreads();
22299         result = (bool)(arg1)->GetDefaultInfo();
22300
22301         wxPyEndAllowThreads(__tstate);
22302         if (PyErr_Occurred()) SWIG_fail;
22303     }
22304     {
22305         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22306     }
22307     return resultobj;
22308     fail:
22309     return NULL;
22310 }
22311
22312
22313 static PyObject *_wrap_PageSetupDialogData_GetMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22314     PyObject *resultobj;
22315     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22316     wxPoint result;
22317     PyObject * obj0 = 0 ;
22318     char *kwnames[] = {
22319         (char *) "self", NULL
22320     };
22321
22322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMarginTopLeft",kwnames,&obj0)) goto fail;
22323     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22324     if (SWIG_arg_fail(1)) SWIG_fail;
22325     {
22326         PyThreadState* __tstate = wxPyBeginAllowThreads();
22327         result = (arg1)->GetMarginTopLeft();
22328
22329         wxPyEndAllowThreads(__tstate);
22330         if (PyErr_Occurred()) SWIG_fail;
22331     }
22332     {
22333         wxPoint * resultptr;
22334         resultptr = new wxPoint((wxPoint &)(result));
22335         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22336     }
22337     return resultobj;
22338     fail:
22339     return NULL;
22340 }
22341
22342
22343 static PyObject *_wrap_PageSetupDialogData_GetMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22344     PyObject *resultobj;
22345     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22346     wxPoint result;
22347     PyObject * obj0 = 0 ;
22348     char *kwnames[] = {
22349         (char *) "self", NULL
22350     };
22351
22352     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMarginBottomRight",kwnames,&obj0)) goto fail;
22353     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22354     if (SWIG_arg_fail(1)) SWIG_fail;
22355     {
22356         PyThreadState* __tstate = wxPyBeginAllowThreads();
22357         result = (arg1)->GetMarginBottomRight();
22358
22359         wxPyEndAllowThreads(__tstate);
22360         if (PyErr_Occurred()) SWIG_fail;
22361     }
22362     {
22363         wxPoint * resultptr;
22364         resultptr = new wxPoint((wxPoint &)(result));
22365         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22366     }
22367     return resultobj;
22368     fail:
22369     return NULL;
22370 }
22371
22372
22373 static PyObject *_wrap_PageSetupDialogData_GetMinMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22374     PyObject *resultobj;
22375     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22376     wxPoint result;
22377     PyObject * obj0 = 0 ;
22378     char *kwnames[] = {
22379         (char *) "self", NULL
22380     };
22381
22382     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMinMarginTopLeft",kwnames,&obj0)) goto fail;
22383     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22384     if (SWIG_arg_fail(1)) SWIG_fail;
22385     {
22386         PyThreadState* __tstate = wxPyBeginAllowThreads();
22387         result = (arg1)->GetMinMarginTopLeft();
22388
22389         wxPyEndAllowThreads(__tstate);
22390         if (PyErr_Occurred()) SWIG_fail;
22391     }
22392     {
22393         wxPoint * resultptr;
22394         resultptr = new wxPoint((wxPoint &)(result));
22395         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22396     }
22397     return resultobj;
22398     fail:
22399     return NULL;
22400 }
22401
22402
22403 static PyObject *_wrap_PageSetupDialogData_GetMinMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22404     PyObject *resultobj;
22405     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22406     wxPoint result;
22407     PyObject * obj0 = 0 ;
22408     char *kwnames[] = {
22409         (char *) "self", NULL
22410     };
22411
22412     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMinMarginBottomRight",kwnames,&obj0)) goto fail;
22413     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22414     if (SWIG_arg_fail(1)) SWIG_fail;
22415     {
22416         PyThreadState* __tstate = wxPyBeginAllowThreads();
22417         result = (arg1)->GetMinMarginBottomRight();
22418
22419         wxPyEndAllowThreads(__tstate);
22420         if (PyErr_Occurred()) SWIG_fail;
22421     }
22422     {
22423         wxPoint * resultptr;
22424         resultptr = new wxPoint((wxPoint &)(result));
22425         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22426     }
22427     return resultobj;
22428     fail:
22429     return NULL;
22430 }
22431
22432
22433 static PyObject *_wrap_PageSetupDialogData_GetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
22434     PyObject *resultobj;
22435     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22436     wxPaperSize result;
22437     PyObject * obj0 = 0 ;
22438     char *kwnames[] = {
22439         (char *) "self", NULL
22440     };
22441
22442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPaperId",kwnames,&obj0)) goto fail;
22443     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22444     if (SWIG_arg_fail(1)) SWIG_fail;
22445     {
22446         PyThreadState* __tstate = wxPyBeginAllowThreads();
22447         result = (wxPaperSize)(arg1)->GetPaperId();
22448
22449         wxPyEndAllowThreads(__tstate);
22450         if (PyErr_Occurred()) SWIG_fail;
22451     }
22452     resultobj = SWIG_From_int((result));
22453     return resultobj;
22454     fail:
22455     return NULL;
22456 }
22457
22458
22459 static PyObject *_wrap_PageSetupDialogData_GetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22460     PyObject *resultobj;
22461     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22462     wxSize result;
22463     PyObject * obj0 = 0 ;
22464     char *kwnames[] = {
22465         (char *) "self", NULL
22466     };
22467
22468     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPaperSize",kwnames,&obj0)) goto fail;
22469     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22470     if (SWIG_arg_fail(1)) SWIG_fail;
22471     {
22472         PyThreadState* __tstate = wxPyBeginAllowThreads();
22473         result = (arg1)->GetPaperSize();
22474
22475         wxPyEndAllowThreads(__tstate);
22476         if (PyErr_Occurred()) SWIG_fail;
22477     }
22478     {
22479         wxSize * resultptr;
22480         resultptr = new wxSize((wxSize &)(result));
22481         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
22482     }
22483     return resultobj;
22484     fail:
22485     return NULL;
22486 }
22487
22488
22489 static PyObject *_wrap_PageSetupDialogData_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
22490     PyObject *resultobj;
22491     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22492     wxPrintData *result;
22493     PyObject * obj0 = 0 ;
22494     char *kwnames[] = {
22495         (char *) "self", NULL
22496     };
22497
22498     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPrintData",kwnames,&obj0)) goto fail;
22499     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22500     if (SWIG_arg_fail(1)) SWIG_fail;
22501     {
22502         PyThreadState* __tstate = wxPyBeginAllowThreads();
22503         {
22504             wxPrintData &_result_ref = (arg1)->GetPrintData();
22505             result = (wxPrintData *) &_result_ref;
22506         }
22507
22508         wxPyEndAllowThreads(__tstate);
22509         if (PyErr_Occurred()) SWIG_fail;
22510     }
22511     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
22512     return resultobj;
22513     fail:
22514     return NULL;
22515 }
22516
22517
22518 static PyObject *_wrap_PageSetupDialogData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
22519     PyObject *resultobj;
22520     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22521     bool result;
22522     PyObject * obj0 = 0 ;
22523     char *kwnames[] = {
22524         (char *) "self", NULL
22525     };
22526
22527     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_Ok",kwnames,&obj0)) goto fail;
22528     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22529     if (SWIG_arg_fail(1)) SWIG_fail;
22530     {
22531         PyThreadState* __tstate = wxPyBeginAllowThreads();
22532         result = (bool)(arg1)->Ok();
22533
22534         wxPyEndAllowThreads(__tstate);
22535         if (PyErr_Occurred()) SWIG_fail;
22536     }
22537     {
22538         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22539     }
22540     return resultobj;
22541     fail:
22542     return NULL;
22543 }
22544
22545
22546 static PyObject *_wrap_PageSetupDialogData_SetDefaultInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22547     PyObject *resultobj;
22548     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22549     bool arg2 ;
22550     PyObject * obj0 = 0 ;
22551     PyObject * obj1 = 0 ;
22552     char *kwnames[] = {
22553         (char *) "self",(char *) "flag", NULL
22554     };
22555
22556     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetDefaultInfo",kwnames,&obj0,&obj1)) goto fail;
22557     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22558     if (SWIG_arg_fail(1)) SWIG_fail;
22559     {
22560         arg2 = (bool)(SWIG_As_bool(obj1));
22561         if (SWIG_arg_fail(2)) SWIG_fail;
22562     }
22563     {
22564         PyThreadState* __tstate = wxPyBeginAllowThreads();
22565         (arg1)->SetDefaultInfo(arg2);
22566
22567         wxPyEndAllowThreads(__tstate);
22568         if (PyErr_Occurred()) SWIG_fail;
22569     }
22570     Py_INCREF(Py_None); resultobj = Py_None;
22571     return resultobj;
22572     fail:
22573     return NULL;
22574 }
22575
22576
22577 static PyObject *_wrap_PageSetupDialogData_SetDefaultMinMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22578     PyObject *resultobj;
22579     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22580     bool arg2 ;
22581     PyObject * obj0 = 0 ;
22582     PyObject * obj1 = 0 ;
22583     char *kwnames[] = {
22584         (char *) "self",(char *) "flag", NULL
22585     };
22586
22587     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetDefaultMinMargins",kwnames,&obj0,&obj1)) goto fail;
22588     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22589     if (SWIG_arg_fail(1)) SWIG_fail;
22590     {
22591         arg2 = (bool)(SWIG_As_bool(obj1));
22592         if (SWIG_arg_fail(2)) SWIG_fail;
22593     }
22594     {
22595         PyThreadState* __tstate = wxPyBeginAllowThreads();
22596         (arg1)->SetDefaultMinMargins(arg2);
22597
22598         wxPyEndAllowThreads(__tstate);
22599         if (PyErr_Occurred()) SWIG_fail;
22600     }
22601     Py_INCREF(Py_None); resultobj = Py_None;
22602     return resultobj;
22603     fail:
22604     return NULL;
22605 }
22606
22607
22608 static PyObject *_wrap_PageSetupDialogData_SetMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22609     PyObject *resultobj;
22610     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22611     wxPoint *arg2 = 0 ;
22612     wxPoint temp2 ;
22613     PyObject * obj0 = 0 ;
22614     PyObject * obj1 = 0 ;
22615     char *kwnames[] = {
22616         (char *) "self",(char *) "pt", NULL
22617     };
22618
22619     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMarginTopLeft",kwnames,&obj0,&obj1)) goto fail;
22620     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22621     if (SWIG_arg_fail(1)) SWIG_fail;
22622     {
22623         arg2 = &temp2;
22624         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22625     }
22626     {
22627         PyThreadState* __tstate = wxPyBeginAllowThreads();
22628         (arg1)->SetMarginTopLeft((wxPoint const &)*arg2);
22629
22630         wxPyEndAllowThreads(__tstate);
22631         if (PyErr_Occurred()) SWIG_fail;
22632     }
22633     Py_INCREF(Py_None); resultobj = Py_None;
22634     return resultobj;
22635     fail:
22636     return NULL;
22637 }
22638
22639
22640 static PyObject *_wrap_PageSetupDialogData_SetMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22641     PyObject *resultobj;
22642     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22643     wxPoint *arg2 = 0 ;
22644     wxPoint temp2 ;
22645     PyObject * obj0 = 0 ;
22646     PyObject * obj1 = 0 ;
22647     char *kwnames[] = {
22648         (char *) "self",(char *) "pt", NULL
22649     };
22650
22651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMarginBottomRight",kwnames,&obj0,&obj1)) goto fail;
22652     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22653     if (SWIG_arg_fail(1)) SWIG_fail;
22654     {
22655         arg2 = &temp2;
22656         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22657     }
22658     {
22659         PyThreadState* __tstate = wxPyBeginAllowThreads();
22660         (arg1)->SetMarginBottomRight((wxPoint const &)*arg2);
22661
22662         wxPyEndAllowThreads(__tstate);
22663         if (PyErr_Occurred()) SWIG_fail;
22664     }
22665     Py_INCREF(Py_None); resultobj = Py_None;
22666     return resultobj;
22667     fail:
22668     return NULL;
22669 }
22670
22671
22672 static PyObject *_wrap_PageSetupDialogData_SetMinMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22673     PyObject *resultobj;
22674     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22675     wxPoint *arg2 = 0 ;
22676     wxPoint temp2 ;
22677     PyObject * obj0 = 0 ;
22678     PyObject * obj1 = 0 ;
22679     char *kwnames[] = {
22680         (char *) "self",(char *) "pt", NULL
22681     };
22682
22683     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMinMarginTopLeft",kwnames,&obj0,&obj1)) goto fail;
22684     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22685     if (SWIG_arg_fail(1)) SWIG_fail;
22686     {
22687         arg2 = &temp2;
22688         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22689     }
22690     {
22691         PyThreadState* __tstate = wxPyBeginAllowThreads();
22692         (arg1)->SetMinMarginTopLeft((wxPoint const &)*arg2);
22693
22694         wxPyEndAllowThreads(__tstate);
22695         if (PyErr_Occurred()) SWIG_fail;
22696     }
22697     Py_INCREF(Py_None); resultobj = Py_None;
22698     return resultobj;
22699     fail:
22700     return NULL;
22701 }
22702
22703
22704 static PyObject *_wrap_PageSetupDialogData_SetMinMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22705     PyObject *resultobj;
22706     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22707     wxPoint *arg2 = 0 ;
22708     wxPoint temp2 ;
22709     PyObject * obj0 = 0 ;
22710     PyObject * obj1 = 0 ;
22711     char *kwnames[] = {
22712         (char *) "self",(char *) "pt", NULL
22713     };
22714
22715     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMinMarginBottomRight",kwnames,&obj0,&obj1)) goto fail;
22716     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22717     if (SWIG_arg_fail(1)) SWIG_fail;
22718     {
22719         arg2 = &temp2;
22720         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22721     }
22722     {
22723         PyThreadState* __tstate = wxPyBeginAllowThreads();
22724         (arg1)->SetMinMarginBottomRight((wxPoint const &)*arg2);
22725
22726         wxPyEndAllowThreads(__tstate);
22727         if (PyErr_Occurred()) SWIG_fail;
22728     }
22729     Py_INCREF(Py_None); resultobj = Py_None;
22730     return resultobj;
22731     fail:
22732     return NULL;
22733 }
22734
22735
22736 static PyObject *_wrap_PageSetupDialogData_SetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
22737     PyObject *resultobj;
22738     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22739     wxPaperSize arg2 ;
22740     PyObject * obj0 = 0 ;
22741     PyObject * obj1 = 0 ;
22742     char *kwnames[] = {
22743         (char *) "self",(char *) "id", NULL
22744     };
22745
22746     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPaperId",kwnames,&obj0,&obj1)) goto fail;
22747     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22748     if (SWIG_arg_fail(1)) SWIG_fail;
22749     {
22750         arg2 = (wxPaperSize)(SWIG_As_int(obj1));
22751         if (SWIG_arg_fail(2)) SWIG_fail;
22752     }
22753     {
22754         PyThreadState* __tstate = wxPyBeginAllowThreads();
22755         (arg1)->SetPaperId((wxPaperSize )arg2);
22756
22757         wxPyEndAllowThreads(__tstate);
22758         if (PyErr_Occurred()) SWIG_fail;
22759     }
22760     Py_INCREF(Py_None); resultobj = Py_None;
22761     return resultobj;
22762     fail:
22763     return NULL;
22764 }
22765
22766
22767 static PyObject *_wrap_PageSetupDialogData_SetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22768     PyObject *resultobj;
22769     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22770     wxSize *arg2 = 0 ;
22771     wxSize temp2 ;
22772     PyObject * obj0 = 0 ;
22773     PyObject * obj1 = 0 ;
22774     char *kwnames[] = {
22775         (char *) "self",(char *) "size", NULL
22776     };
22777
22778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPaperSize",kwnames,&obj0,&obj1)) goto fail;
22779     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22780     if (SWIG_arg_fail(1)) SWIG_fail;
22781     {
22782         arg2 = &temp2;
22783         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
22784     }
22785     {
22786         PyThreadState* __tstate = wxPyBeginAllowThreads();
22787         (arg1)->SetPaperSize((wxSize const &)*arg2);
22788
22789         wxPyEndAllowThreads(__tstate);
22790         if (PyErr_Occurred()) SWIG_fail;
22791     }
22792     Py_INCREF(Py_None); resultobj = Py_None;
22793     return resultobj;
22794     fail:
22795     return NULL;
22796 }
22797
22798
22799 static PyObject *_wrap_PageSetupDialogData_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
22800     PyObject *resultobj;
22801     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22802     wxPrintData *arg2 = 0 ;
22803     PyObject * obj0 = 0 ;
22804     PyObject * obj1 = 0 ;
22805     char *kwnames[] = {
22806         (char *) "self",(char *) "printData", NULL
22807     };
22808
22809     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
22810     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22811     if (SWIG_arg_fail(1)) SWIG_fail;
22812     {
22813         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
22814         if (SWIG_arg_fail(2)) SWIG_fail;
22815         if (arg2 == NULL) {
22816             SWIG_null_ref("wxPrintData");
22817         }
22818         if (SWIG_arg_fail(2)) SWIG_fail;
22819     }
22820     {
22821         PyThreadState* __tstate = wxPyBeginAllowThreads();
22822         (arg1)->SetPrintData((wxPrintData const &)*arg2);
22823
22824         wxPyEndAllowThreads(__tstate);
22825         if (PyErr_Occurred()) SWIG_fail;
22826     }
22827     Py_INCREF(Py_None); resultobj = Py_None;
22828     return resultobj;
22829     fail:
22830     return NULL;
22831 }
22832
22833
22834 static PyObject *_wrap_PageSetupDialogData_CalculateIdFromPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22835     PyObject *resultobj;
22836     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22837     PyObject * obj0 = 0 ;
22838     char *kwnames[] = {
22839         (char *) "self", NULL
22840     };
22841
22842     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_CalculateIdFromPaperSize",kwnames,&obj0)) goto fail;
22843     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22844     if (SWIG_arg_fail(1)) SWIG_fail;
22845     {
22846         PyThreadState* __tstate = wxPyBeginAllowThreads();
22847         (arg1)->CalculateIdFromPaperSize();
22848
22849         wxPyEndAllowThreads(__tstate);
22850         if (PyErr_Occurred()) SWIG_fail;
22851     }
22852     Py_INCREF(Py_None); resultobj = Py_None;
22853     return resultobj;
22854     fail:
22855     return NULL;
22856 }
22857
22858
22859 static PyObject *_wrap_PageSetupDialogData_CalculatePaperSizeFromId(PyObject *, PyObject *args, PyObject *kwargs) {
22860     PyObject *resultobj;
22861     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22862     PyObject * obj0 = 0 ;
22863     char *kwnames[] = {
22864         (char *) "self", NULL
22865     };
22866
22867     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_CalculatePaperSizeFromId",kwnames,&obj0)) goto fail;
22868     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22869     if (SWIG_arg_fail(1)) SWIG_fail;
22870     {
22871         PyThreadState* __tstate = wxPyBeginAllowThreads();
22872         (arg1)->CalculatePaperSizeFromId();
22873
22874         wxPyEndAllowThreads(__tstate);
22875         if (PyErr_Occurred()) SWIG_fail;
22876     }
22877     Py_INCREF(Py_None); resultobj = Py_None;
22878     return resultobj;
22879     fail:
22880     return NULL;
22881 }
22882
22883
22884 static PyObject * PageSetupDialogData_swigregister(PyObject *, PyObject *args) {
22885     PyObject *obj;
22886     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22887     SWIG_TypeClientData(SWIGTYPE_p_wxPageSetupDialogData, obj);
22888     Py_INCREF(obj);
22889     return Py_BuildValue((char *)"");
22890 }
22891 static PyObject *_wrap_new_PageSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
22892     PyObject *resultobj;
22893     wxWindow *arg1 = (wxWindow *) 0 ;
22894     wxPageSetupDialogData *arg2 = (wxPageSetupDialogData *) NULL ;
22895     wxPageSetupDialog *result;
22896     PyObject * obj0 = 0 ;
22897     PyObject * obj1 = 0 ;
22898     char *kwnames[] = {
22899         (char *) "parent",(char *) "data", NULL
22900     };
22901
22902     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PageSetupDialog",kwnames,&obj0,&obj1)) goto fail;
22903     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22904     if (SWIG_arg_fail(1)) SWIG_fail;
22905     if (obj1) {
22906         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22907         if (SWIG_arg_fail(2)) SWIG_fail;
22908     }
22909     {
22910         if (!wxPyCheckForApp()) SWIG_fail;
22911         PyThreadState* __tstate = wxPyBeginAllowThreads();
22912         result = (wxPageSetupDialog *)new wxPageSetupDialog(arg1,arg2);
22913
22914         wxPyEndAllowThreads(__tstate);
22915         if (PyErr_Occurred()) SWIG_fail;
22916     }
22917     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialog, 1);
22918     return resultobj;
22919     fail:
22920     return NULL;
22921 }
22922
22923
22924 static PyObject *_wrap_PageSetupDialog_GetPageSetupData(PyObject *, PyObject *args, PyObject *kwargs) {
22925     PyObject *resultobj;
22926     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
22927     wxPageSetupDialogData *result;
22928     PyObject * obj0 = 0 ;
22929     char *kwnames[] = {
22930         (char *) "self", NULL
22931     };
22932
22933     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_GetPageSetupData",kwnames,&obj0)) goto fail;
22934     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
22935     if (SWIG_arg_fail(1)) SWIG_fail;
22936     {
22937         PyThreadState* __tstate = wxPyBeginAllowThreads();
22938         {
22939             wxPageSetupDialogData &_result_ref = (arg1)->GetPageSetupData();
22940             result = (wxPageSetupDialogData *) &_result_ref;
22941         }
22942
22943         wxPyEndAllowThreads(__tstate);
22944         if (PyErr_Occurred()) SWIG_fail;
22945     }
22946     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 0);
22947     return resultobj;
22948     fail:
22949     return NULL;
22950 }
22951
22952
22953 static PyObject *_wrap_PageSetupDialog_GetPageSetupDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
22954     PyObject *resultobj;
22955     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
22956     wxPageSetupDialogData *result;
22957     PyObject * obj0 = 0 ;
22958     char *kwnames[] = {
22959         (char *) "self", NULL
22960     };
22961
22962     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_GetPageSetupDialogData",kwnames,&obj0)) goto fail;
22963     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
22964     if (SWIG_arg_fail(1)) SWIG_fail;
22965     {
22966         PyThreadState* __tstate = wxPyBeginAllowThreads();
22967         {
22968             wxPageSetupDialogData &_result_ref = (arg1)->GetPageSetupDialogData();
22969             result = (wxPageSetupDialogData *) &_result_ref;
22970         }
22971
22972         wxPyEndAllowThreads(__tstate);
22973         if (PyErr_Occurred()) SWIG_fail;
22974     }
22975     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 0);
22976     return resultobj;
22977     fail:
22978     return NULL;
22979 }
22980
22981
22982 static PyObject *_wrap_PageSetupDialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
22983     PyObject *resultobj;
22984     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
22985     int result;
22986     PyObject * obj0 = 0 ;
22987     char *kwnames[] = {
22988         (char *) "self", NULL
22989     };
22990
22991     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_ShowModal",kwnames,&obj0)) goto fail;
22992     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
22993     if (SWIG_arg_fail(1)) SWIG_fail;
22994     {
22995         PyThreadState* __tstate = wxPyBeginAllowThreads();
22996         result = (int)(arg1)->ShowModal();
22997
22998         wxPyEndAllowThreads(__tstate);
22999         if (PyErr_Occurred()) SWIG_fail;
23000     }
23001     {
23002         resultobj = SWIG_From_int((int)(result));
23003     }
23004     return resultobj;
23005     fail:
23006     return NULL;
23007 }
23008
23009
23010 static PyObject * PageSetupDialog_swigregister(PyObject *, PyObject *args) {
23011     PyObject *obj;
23012     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23013     SWIG_TypeClientData(SWIGTYPE_p_wxPageSetupDialog, obj);
23014     Py_INCREF(obj);
23015     return Py_BuildValue((char *)"");
23016 }
23017 static PyObject *_wrap_new_PrintDialogData__SWIG_0(PyObject *, PyObject *args) {
23018     PyObject *resultobj;
23019     wxPrintDialogData *result;
23020
23021     if(!PyArg_ParseTuple(args,(char *)":new_PrintDialogData")) goto fail;
23022     {
23023         PyThreadState* __tstate = wxPyBeginAllowThreads();
23024         result = (wxPrintDialogData *)new wxPrintDialogData();
23025
23026         wxPyEndAllowThreads(__tstate);
23027         if (PyErr_Occurred()) SWIG_fail;
23028     }
23029     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23030     return resultobj;
23031     fail:
23032     return NULL;
23033 }
23034
23035
23036 static PyObject *_wrap_new_PrintDialogData__SWIG_1(PyObject *, PyObject *args) {
23037     PyObject *resultobj;
23038     wxPrintData *arg1 = 0 ;
23039     wxPrintDialogData *result;
23040     PyObject * obj0 = 0 ;
23041
23042     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintDialogData",&obj0)) goto fail;
23043     {
23044         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
23045         if (SWIG_arg_fail(1)) SWIG_fail;
23046         if (arg1 == NULL) {
23047             SWIG_null_ref("wxPrintData");
23048         }
23049         if (SWIG_arg_fail(1)) SWIG_fail;
23050     }
23051     {
23052         PyThreadState* __tstate = wxPyBeginAllowThreads();
23053         result = (wxPrintDialogData *)new wxPrintDialogData((wxPrintData const &)*arg1);
23054
23055         wxPyEndAllowThreads(__tstate);
23056         if (PyErr_Occurred()) SWIG_fail;
23057     }
23058     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23059     return resultobj;
23060     fail:
23061     return NULL;
23062 }
23063
23064
23065 static PyObject *_wrap_new_PrintDialogData__SWIG_2(PyObject *, PyObject *args) {
23066     PyObject *resultobj;
23067     wxPrintDialogData *arg1 = 0 ;
23068     wxPrintDialogData *result;
23069     PyObject * obj0 = 0 ;
23070
23071     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintDialogData",&obj0)) goto fail;
23072     {
23073         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23074         if (SWIG_arg_fail(1)) SWIG_fail;
23075         if (arg1 == NULL) {
23076             SWIG_null_ref("wxPrintDialogData");
23077         }
23078         if (SWIG_arg_fail(1)) SWIG_fail;
23079     }
23080     {
23081         PyThreadState* __tstate = wxPyBeginAllowThreads();
23082         result = (wxPrintDialogData *)new wxPrintDialogData((wxPrintDialogData const &)*arg1);
23083
23084         wxPyEndAllowThreads(__tstate);
23085         if (PyErr_Occurred()) SWIG_fail;
23086     }
23087     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23088     return resultobj;
23089     fail:
23090     return NULL;
23091 }
23092
23093
23094 static PyObject *_wrap_new_PrintDialogData(PyObject *self, PyObject *args) {
23095     int argc;
23096     PyObject *argv[2];
23097     int ii;
23098
23099     argc = PyObject_Length(args);
23100     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
23101         argv[ii] = PyTuple_GetItem(args,ii);
23102     }
23103     if (argc == 0) {
23104         return _wrap_new_PrintDialogData__SWIG_0(self,args);
23105     }
23106     if (argc == 1) {
23107         int _v;
23108         {
23109             void *ptr = 0;
23110             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
23111                 _v = 0;
23112                 PyErr_Clear();
23113             } else {
23114                 _v = (ptr != 0);
23115             }
23116         }
23117         if (_v) {
23118             return _wrap_new_PrintDialogData__SWIG_1(self,args);
23119         }
23120     }
23121     if (argc == 1) {
23122         int _v;
23123         {
23124             void *ptr = 0;
23125             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
23126                 _v = 0;
23127                 PyErr_Clear();
23128             } else {
23129                 _v = (ptr != 0);
23130             }
23131         }
23132         if (_v) {
23133             return _wrap_new_PrintDialogData__SWIG_2(self,args);
23134         }
23135     }
23136
23137     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintDialogData'");
23138     return NULL;
23139 }
23140
23141
23142 static PyObject *_wrap_delete_PrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
23143     PyObject *resultobj;
23144     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23145     PyObject * obj0 = 0 ;
23146     char *kwnames[] = {
23147         (char *) "self", NULL
23148     };
23149
23150     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PrintDialogData",kwnames,&obj0)) goto fail;
23151     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23152     if (SWIG_arg_fail(1)) SWIG_fail;
23153     {
23154         PyThreadState* __tstate = wxPyBeginAllowThreads();
23155         delete arg1;
23156
23157         wxPyEndAllowThreads(__tstate);
23158         if (PyErr_Occurred()) SWIG_fail;
23159     }
23160     Py_INCREF(Py_None); resultobj = Py_None;
23161     return resultobj;
23162     fail:
23163     return NULL;
23164 }
23165
23166
23167 static PyObject *_wrap_PrintDialogData_GetFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
23168     PyObject *resultobj;
23169     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23170     int result;
23171     PyObject * obj0 = 0 ;
23172     char *kwnames[] = {
23173         (char *) "self", NULL
23174     };
23175
23176     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetFromPage",kwnames,&obj0)) goto fail;
23177     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23178     if (SWIG_arg_fail(1)) SWIG_fail;
23179     {
23180         PyThreadState* __tstate = wxPyBeginAllowThreads();
23181         result = (int)((wxPrintDialogData const *)arg1)->GetFromPage();
23182
23183         wxPyEndAllowThreads(__tstate);
23184         if (PyErr_Occurred()) SWIG_fail;
23185     }
23186     {
23187         resultobj = SWIG_From_int((int)(result));
23188     }
23189     return resultobj;
23190     fail:
23191     return NULL;
23192 }
23193
23194
23195 static PyObject *_wrap_PrintDialogData_GetToPage(PyObject *, PyObject *args, PyObject *kwargs) {
23196     PyObject *resultobj;
23197     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23198     int result;
23199     PyObject * obj0 = 0 ;
23200     char *kwnames[] = {
23201         (char *) "self", NULL
23202     };
23203
23204     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetToPage",kwnames,&obj0)) goto fail;
23205     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23206     if (SWIG_arg_fail(1)) SWIG_fail;
23207     {
23208         PyThreadState* __tstate = wxPyBeginAllowThreads();
23209         result = (int)((wxPrintDialogData const *)arg1)->GetToPage();
23210
23211         wxPyEndAllowThreads(__tstate);
23212         if (PyErr_Occurred()) SWIG_fail;
23213     }
23214     {
23215         resultobj = SWIG_From_int((int)(result));
23216     }
23217     return resultobj;
23218     fail:
23219     return NULL;
23220 }
23221
23222
23223 static PyObject *_wrap_PrintDialogData_GetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
23224     PyObject *resultobj;
23225     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23226     int result;
23227     PyObject * obj0 = 0 ;
23228     char *kwnames[] = {
23229         (char *) "self", NULL
23230     };
23231
23232     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetMinPage",kwnames,&obj0)) goto fail;
23233     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23234     if (SWIG_arg_fail(1)) SWIG_fail;
23235     {
23236         PyThreadState* __tstate = wxPyBeginAllowThreads();
23237         result = (int)((wxPrintDialogData const *)arg1)->GetMinPage();
23238
23239         wxPyEndAllowThreads(__tstate);
23240         if (PyErr_Occurred()) SWIG_fail;
23241     }
23242     {
23243         resultobj = SWIG_From_int((int)(result));
23244     }
23245     return resultobj;
23246     fail:
23247     return NULL;
23248 }
23249
23250
23251 static PyObject *_wrap_PrintDialogData_GetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
23252     PyObject *resultobj;
23253     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23254     int result;
23255     PyObject * obj0 = 0 ;
23256     char *kwnames[] = {
23257         (char *) "self", NULL
23258     };
23259
23260     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetMaxPage",kwnames,&obj0)) goto fail;
23261     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23262     if (SWIG_arg_fail(1)) SWIG_fail;
23263     {
23264         PyThreadState* __tstate = wxPyBeginAllowThreads();
23265         result = (int)((wxPrintDialogData const *)arg1)->GetMaxPage();
23266
23267         wxPyEndAllowThreads(__tstate);
23268         if (PyErr_Occurred()) SWIG_fail;
23269     }
23270     {
23271         resultobj = SWIG_From_int((int)(result));
23272     }
23273     return resultobj;
23274     fail:
23275     return NULL;
23276 }
23277
23278
23279 static PyObject *_wrap_PrintDialogData_GetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
23280     PyObject *resultobj;
23281     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23282     int result;
23283     PyObject * obj0 = 0 ;
23284     char *kwnames[] = {
23285         (char *) "self", NULL
23286     };
23287
23288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetNoCopies",kwnames,&obj0)) goto fail;
23289     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23290     if (SWIG_arg_fail(1)) SWIG_fail;
23291     {
23292         PyThreadState* __tstate = wxPyBeginAllowThreads();
23293         result = (int)((wxPrintDialogData const *)arg1)->GetNoCopies();
23294
23295         wxPyEndAllowThreads(__tstate);
23296         if (PyErr_Occurred()) SWIG_fail;
23297     }
23298     {
23299         resultobj = SWIG_From_int((int)(result));
23300     }
23301     return resultobj;
23302     fail:
23303     return NULL;
23304 }
23305
23306
23307 static PyObject *_wrap_PrintDialogData_GetAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
23308     PyObject *resultobj;
23309     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23310     bool result;
23311     PyObject * obj0 = 0 ;
23312     char *kwnames[] = {
23313         (char *) "self", NULL
23314     };
23315
23316     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetAllPages",kwnames,&obj0)) goto fail;
23317     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23318     if (SWIG_arg_fail(1)) SWIG_fail;
23319     {
23320         PyThreadState* __tstate = wxPyBeginAllowThreads();
23321         result = (bool)((wxPrintDialogData const *)arg1)->GetAllPages();
23322
23323         wxPyEndAllowThreads(__tstate);
23324         if (PyErr_Occurred()) SWIG_fail;
23325     }
23326     {
23327         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23328     }
23329     return resultobj;
23330     fail:
23331     return NULL;
23332 }
23333
23334
23335 static PyObject *_wrap_PrintDialogData_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23336     PyObject *resultobj;
23337     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23338     bool result;
23339     PyObject * obj0 = 0 ;
23340     char *kwnames[] = {
23341         (char *) "self", NULL
23342     };
23343
23344     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetSelection",kwnames,&obj0)) goto fail;
23345     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23346     if (SWIG_arg_fail(1)) SWIG_fail;
23347     {
23348         PyThreadState* __tstate = wxPyBeginAllowThreads();
23349         result = (bool)((wxPrintDialogData const *)arg1)->GetSelection();
23350
23351         wxPyEndAllowThreads(__tstate);
23352         if (PyErr_Occurred()) SWIG_fail;
23353     }
23354     {
23355         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23356     }
23357     return resultobj;
23358     fail:
23359     return NULL;
23360 }
23361
23362
23363 static PyObject *_wrap_PrintDialogData_GetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
23364     PyObject *resultobj;
23365     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23366     bool result;
23367     PyObject * obj0 = 0 ;
23368     char *kwnames[] = {
23369         (char *) "self", NULL
23370     };
23371
23372     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetCollate",kwnames,&obj0)) goto fail;
23373     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23374     if (SWIG_arg_fail(1)) SWIG_fail;
23375     {
23376         PyThreadState* __tstate = wxPyBeginAllowThreads();
23377         result = (bool)((wxPrintDialogData const *)arg1)->GetCollate();
23378
23379         wxPyEndAllowThreads(__tstate);
23380         if (PyErr_Occurred()) SWIG_fail;
23381     }
23382     {
23383         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23384     }
23385     return resultobj;
23386     fail:
23387     return NULL;
23388 }
23389
23390
23391 static PyObject *_wrap_PrintDialogData_GetPrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23392     PyObject *resultobj;
23393     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23394     bool result;
23395     PyObject * obj0 = 0 ;
23396     char *kwnames[] = {
23397         (char *) "self", NULL
23398     };
23399
23400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetPrintToFile",kwnames,&obj0)) goto fail;
23401     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23402     if (SWIG_arg_fail(1)) SWIG_fail;
23403     {
23404         PyThreadState* __tstate = wxPyBeginAllowThreads();
23405         result = (bool)((wxPrintDialogData const *)arg1)->GetPrintToFile();
23406
23407         wxPyEndAllowThreads(__tstate);
23408         if (PyErr_Occurred()) SWIG_fail;
23409     }
23410     {
23411         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23412     }
23413     return resultobj;
23414     fail:
23415     return NULL;
23416 }
23417
23418
23419 static PyObject *_wrap_PrintDialogData_GetSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23420     PyObject *resultobj;
23421     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23422     bool result;
23423     PyObject * obj0 = 0 ;
23424     char *kwnames[] = {
23425         (char *) "self", NULL
23426     };
23427
23428     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetSetupDialog",kwnames,&obj0)) goto fail;
23429     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23430     if (SWIG_arg_fail(1)) SWIG_fail;
23431     {
23432         PyThreadState* __tstate = wxPyBeginAllowThreads();
23433         result = (bool)((wxPrintDialogData const *)arg1)->GetSetupDialog();
23434
23435         wxPyEndAllowThreads(__tstate);
23436         if (PyErr_Occurred()) SWIG_fail;
23437     }
23438     {
23439         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23440     }
23441     return resultobj;
23442     fail:
23443     return NULL;
23444 }
23445
23446
23447 static PyObject *_wrap_PrintDialogData_SetSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23448     PyObject *resultobj;
23449     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23450     bool arg2 ;
23451     PyObject * obj0 = 0 ;
23452     PyObject * obj1 = 0 ;
23453     char *kwnames[] = {
23454         (char *) "self",(char *) "flag", NULL
23455     };
23456
23457     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetSetupDialog",kwnames,&obj0,&obj1)) goto fail;
23458     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23459     if (SWIG_arg_fail(1)) SWIG_fail;
23460     {
23461         arg2 = (bool)(SWIG_As_bool(obj1));
23462         if (SWIG_arg_fail(2)) SWIG_fail;
23463     }
23464     {
23465         PyThreadState* __tstate = wxPyBeginAllowThreads();
23466         (arg1)->SetSetupDialog(arg2);
23467
23468         wxPyEndAllowThreads(__tstate);
23469         if (PyErr_Occurred()) SWIG_fail;
23470     }
23471     Py_INCREF(Py_None); resultobj = Py_None;
23472     return resultobj;
23473     fail:
23474     return NULL;
23475 }
23476
23477
23478 static PyObject *_wrap_PrintDialogData_SetFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
23479     PyObject *resultobj;
23480     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23481     int arg2 ;
23482     PyObject * obj0 = 0 ;
23483     PyObject * obj1 = 0 ;
23484     char *kwnames[] = {
23485         (char *) "self",(char *) "v", NULL
23486     };
23487
23488     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetFromPage",kwnames,&obj0,&obj1)) goto fail;
23489     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23490     if (SWIG_arg_fail(1)) SWIG_fail;
23491     {
23492         arg2 = (int)(SWIG_As_int(obj1));
23493         if (SWIG_arg_fail(2)) SWIG_fail;
23494     }
23495     {
23496         PyThreadState* __tstate = wxPyBeginAllowThreads();
23497         (arg1)->SetFromPage(arg2);
23498
23499         wxPyEndAllowThreads(__tstate);
23500         if (PyErr_Occurred()) SWIG_fail;
23501     }
23502     Py_INCREF(Py_None); resultobj = Py_None;
23503     return resultobj;
23504     fail:
23505     return NULL;
23506 }
23507
23508
23509 static PyObject *_wrap_PrintDialogData_SetToPage(PyObject *, PyObject *args, PyObject *kwargs) {
23510     PyObject *resultobj;
23511     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23512     int arg2 ;
23513     PyObject * obj0 = 0 ;
23514     PyObject * obj1 = 0 ;
23515     char *kwnames[] = {
23516         (char *) "self",(char *) "v", NULL
23517     };
23518
23519     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetToPage",kwnames,&obj0,&obj1)) goto fail;
23520     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23521     if (SWIG_arg_fail(1)) SWIG_fail;
23522     {
23523         arg2 = (int)(SWIG_As_int(obj1));
23524         if (SWIG_arg_fail(2)) SWIG_fail;
23525     }
23526     {
23527         PyThreadState* __tstate = wxPyBeginAllowThreads();
23528         (arg1)->SetToPage(arg2);
23529
23530         wxPyEndAllowThreads(__tstate);
23531         if (PyErr_Occurred()) SWIG_fail;
23532     }
23533     Py_INCREF(Py_None); resultobj = Py_None;
23534     return resultobj;
23535     fail:
23536     return NULL;
23537 }
23538
23539
23540 static PyObject *_wrap_PrintDialogData_SetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
23541     PyObject *resultobj;
23542     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23543     int arg2 ;
23544     PyObject * obj0 = 0 ;
23545     PyObject * obj1 = 0 ;
23546     char *kwnames[] = {
23547         (char *) "self",(char *) "v", NULL
23548     };
23549
23550     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetMinPage",kwnames,&obj0,&obj1)) goto fail;
23551     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23552     if (SWIG_arg_fail(1)) SWIG_fail;
23553     {
23554         arg2 = (int)(SWIG_As_int(obj1));
23555         if (SWIG_arg_fail(2)) SWIG_fail;
23556     }
23557     {
23558         PyThreadState* __tstate = wxPyBeginAllowThreads();
23559         (arg1)->SetMinPage(arg2);
23560
23561         wxPyEndAllowThreads(__tstate);
23562         if (PyErr_Occurred()) SWIG_fail;
23563     }
23564     Py_INCREF(Py_None); resultobj = Py_None;
23565     return resultobj;
23566     fail:
23567     return NULL;
23568 }
23569
23570
23571 static PyObject *_wrap_PrintDialogData_SetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
23572     PyObject *resultobj;
23573     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23574     int arg2 ;
23575     PyObject * obj0 = 0 ;
23576     PyObject * obj1 = 0 ;
23577     char *kwnames[] = {
23578         (char *) "self",(char *) "v", NULL
23579     };
23580
23581     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetMaxPage",kwnames,&obj0,&obj1)) goto fail;
23582     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23583     if (SWIG_arg_fail(1)) SWIG_fail;
23584     {
23585         arg2 = (int)(SWIG_As_int(obj1));
23586         if (SWIG_arg_fail(2)) SWIG_fail;
23587     }
23588     {
23589         PyThreadState* __tstate = wxPyBeginAllowThreads();
23590         (arg1)->SetMaxPage(arg2);
23591
23592         wxPyEndAllowThreads(__tstate);
23593         if (PyErr_Occurred()) SWIG_fail;
23594     }
23595     Py_INCREF(Py_None); resultobj = Py_None;
23596     return resultobj;
23597     fail:
23598     return NULL;
23599 }
23600
23601
23602 static PyObject *_wrap_PrintDialogData_SetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
23603     PyObject *resultobj;
23604     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23605     int arg2 ;
23606     PyObject * obj0 = 0 ;
23607     PyObject * obj1 = 0 ;
23608     char *kwnames[] = {
23609         (char *) "self",(char *) "v", NULL
23610     };
23611
23612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetNoCopies",kwnames,&obj0,&obj1)) goto fail;
23613     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23614     if (SWIG_arg_fail(1)) SWIG_fail;
23615     {
23616         arg2 = (int)(SWIG_As_int(obj1));
23617         if (SWIG_arg_fail(2)) SWIG_fail;
23618     }
23619     {
23620         PyThreadState* __tstate = wxPyBeginAllowThreads();
23621         (arg1)->SetNoCopies(arg2);
23622
23623         wxPyEndAllowThreads(__tstate);
23624         if (PyErr_Occurred()) SWIG_fail;
23625     }
23626     Py_INCREF(Py_None); resultobj = Py_None;
23627     return resultobj;
23628     fail:
23629     return NULL;
23630 }
23631
23632
23633 static PyObject *_wrap_PrintDialogData_SetAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
23634     PyObject *resultobj;
23635     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23636     bool arg2 ;
23637     PyObject * obj0 = 0 ;
23638     PyObject * obj1 = 0 ;
23639     char *kwnames[] = {
23640         (char *) "self",(char *) "flag", NULL
23641     };
23642
23643     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetAllPages",kwnames,&obj0,&obj1)) goto fail;
23644     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23645     if (SWIG_arg_fail(1)) SWIG_fail;
23646     {
23647         arg2 = (bool)(SWIG_As_bool(obj1));
23648         if (SWIG_arg_fail(2)) SWIG_fail;
23649     }
23650     {
23651         PyThreadState* __tstate = wxPyBeginAllowThreads();
23652         (arg1)->SetAllPages(arg2);
23653
23654         wxPyEndAllowThreads(__tstate);
23655         if (PyErr_Occurred()) SWIG_fail;
23656     }
23657     Py_INCREF(Py_None); resultobj = Py_None;
23658     return resultobj;
23659     fail:
23660     return NULL;
23661 }
23662
23663
23664 static PyObject *_wrap_PrintDialogData_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23665     PyObject *resultobj;
23666     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23667     bool arg2 ;
23668     PyObject * obj0 = 0 ;
23669     PyObject * obj1 = 0 ;
23670     char *kwnames[] = {
23671         (char *) "self",(char *) "flag", NULL
23672     };
23673
23674     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetSelection",kwnames,&obj0,&obj1)) goto fail;
23675     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23676     if (SWIG_arg_fail(1)) SWIG_fail;
23677     {
23678         arg2 = (bool)(SWIG_As_bool(obj1));
23679         if (SWIG_arg_fail(2)) SWIG_fail;
23680     }
23681     {
23682         PyThreadState* __tstate = wxPyBeginAllowThreads();
23683         (arg1)->SetSelection(arg2);
23684
23685         wxPyEndAllowThreads(__tstate);
23686         if (PyErr_Occurred()) SWIG_fail;
23687     }
23688     Py_INCREF(Py_None); resultobj = Py_None;
23689     return resultobj;
23690     fail:
23691     return NULL;
23692 }
23693
23694
23695 static PyObject *_wrap_PrintDialogData_SetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
23696     PyObject *resultobj;
23697     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23698     bool arg2 ;
23699     PyObject * obj0 = 0 ;
23700     PyObject * obj1 = 0 ;
23701     char *kwnames[] = {
23702         (char *) "self",(char *) "flag", NULL
23703     };
23704
23705     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetCollate",kwnames,&obj0,&obj1)) goto fail;
23706     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23707     if (SWIG_arg_fail(1)) SWIG_fail;
23708     {
23709         arg2 = (bool)(SWIG_As_bool(obj1));
23710         if (SWIG_arg_fail(2)) SWIG_fail;
23711     }
23712     {
23713         PyThreadState* __tstate = wxPyBeginAllowThreads();
23714         (arg1)->SetCollate(arg2);
23715
23716         wxPyEndAllowThreads(__tstate);
23717         if (PyErr_Occurred()) SWIG_fail;
23718     }
23719     Py_INCREF(Py_None); resultobj = Py_None;
23720     return resultobj;
23721     fail:
23722     return NULL;
23723 }
23724
23725
23726 static PyObject *_wrap_PrintDialogData_SetPrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23727     PyObject *resultobj;
23728     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23729     bool arg2 ;
23730     PyObject * obj0 = 0 ;
23731     PyObject * obj1 = 0 ;
23732     char *kwnames[] = {
23733         (char *) "self",(char *) "flag", NULL
23734     };
23735
23736     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetPrintToFile",kwnames,&obj0,&obj1)) goto fail;
23737     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23738     if (SWIG_arg_fail(1)) SWIG_fail;
23739     {
23740         arg2 = (bool)(SWIG_As_bool(obj1));
23741         if (SWIG_arg_fail(2)) SWIG_fail;
23742     }
23743     {
23744         PyThreadState* __tstate = wxPyBeginAllowThreads();
23745         (arg1)->SetPrintToFile(arg2);
23746
23747         wxPyEndAllowThreads(__tstate);
23748         if (PyErr_Occurred()) SWIG_fail;
23749     }
23750     Py_INCREF(Py_None); resultobj = Py_None;
23751     return resultobj;
23752     fail:
23753     return NULL;
23754 }
23755
23756
23757 static PyObject *_wrap_PrintDialogData_EnablePrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23758     PyObject *resultobj;
23759     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23760     bool arg2 ;
23761     PyObject * obj0 = 0 ;
23762     PyObject * obj1 = 0 ;
23763     char *kwnames[] = {
23764         (char *) "self",(char *) "flag", NULL
23765     };
23766
23767     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnablePrintToFile",kwnames,&obj0,&obj1)) goto fail;
23768     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23769     if (SWIG_arg_fail(1)) SWIG_fail;
23770     {
23771         arg2 = (bool)(SWIG_As_bool(obj1));
23772         if (SWIG_arg_fail(2)) SWIG_fail;
23773     }
23774     {
23775         PyThreadState* __tstate = wxPyBeginAllowThreads();
23776         (arg1)->EnablePrintToFile(arg2);
23777
23778         wxPyEndAllowThreads(__tstate);
23779         if (PyErr_Occurred()) SWIG_fail;
23780     }
23781     Py_INCREF(Py_None); resultobj = Py_None;
23782     return resultobj;
23783     fail:
23784     return NULL;
23785 }
23786
23787
23788 static PyObject *_wrap_PrintDialogData_EnableSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23789     PyObject *resultobj;
23790     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23791     bool arg2 ;
23792     PyObject * obj0 = 0 ;
23793     PyObject * obj1 = 0 ;
23794     char *kwnames[] = {
23795         (char *) "self",(char *) "flag", NULL
23796     };
23797
23798     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnableSelection",kwnames,&obj0,&obj1)) goto fail;
23799     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23800     if (SWIG_arg_fail(1)) SWIG_fail;
23801     {
23802         arg2 = (bool)(SWIG_As_bool(obj1));
23803         if (SWIG_arg_fail(2)) SWIG_fail;
23804     }
23805     {
23806         PyThreadState* __tstate = wxPyBeginAllowThreads();
23807         (arg1)->EnableSelection(arg2);
23808
23809         wxPyEndAllowThreads(__tstate);
23810         if (PyErr_Occurred()) SWIG_fail;
23811     }
23812     Py_INCREF(Py_None); resultobj = Py_None;
23813     return resultobj;
23814     fail:
23815     return NULL;
23816 }
23817
23818
23819 static PyObject *_wrap_PrintDialogData_EnablePageNumbers(PyObject *, PyObject *args, PyObject *kwargs) {
23820     PyObject *resultobj;
23821     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23822     bool arg2 ;
23823     PyObject * obj0 = 0 ;
23824     PyObject * obj1 = 0 ;
23825     char *kwnames[] = {
23826         (char *) "self",(char *) "flag", NULL
23827     };
23828
23829     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnablePageNumbers",kwnames,&obj0,&obj1)) goto fail;
23830     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23831     if (SWIG_arg_fail(1)) SWIG_fail;
23832     {
23833         arg2 = (bool)(SWIG_As_bool(obj1));
23834         if (SWIG_arg_fail(2)) SWIG_fail;
23835     }
23836     {
23837         PyThreadState* __tstate = wxPyBeginAllowThreads();
23838         (arg1)->EnablePageNumbers(arg2);
23839
23840         wxPyEndAllowThreads(__tstate);
23841         if (PyErr_Occurred()) SWIG_fail;
23842     }
23843     Py_INCREF(Py_None); resultobj = Py_None;
23844     return resultobj;
23845     fail:
23846     return NULL;
23847 }
23848
23849
23850 static PyObject *_wrap_PrintDialogData_EnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
23851     PyObject *resultobj;
23852     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23853     bool arg2 ;
23854     PyObject * obj0 = 0 ;
23855     PyObject * obj1 = 0 ;
23856     char *kwnames[] = {
23857         (char *) "self",(char *) "flag", NULL
23858     };
23859
23860     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnableHelp",kwnames,&obj0,&obj1)) goto fail;
23861     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23862     if (SWIG_arg_fail(1)) SWIG_fail;
23863     {
23864         arg2 = (bool)(SWIG_As_bool(obj1));
23865         if (SWIG_arg_fail(2)) SWIG_fail;
23866     }
23867     {
23868         PyThreadState* __tstate = wxPyBeginAllowThreads();
23869         (arg1)->EnableHelp(arg2);
23870
23871         wxPyEndAllowThreads(__tstate);
23872         if (PyErr_Occurred()) SWIG_fail;
23873     }
23874     Py_INCREF(Py_None); resultobj = Py_None;
23875     return resultobj;
23876     fail:
23877     return NULL;
23878 }
23879
23880
23881 static PyObject *_wrap_PrintDialogData_GetEnablePrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23882     PyObject *resultobj;
23883     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23884     bool result;
23885     PyObject * obj0 = 0 ;
23886     char *kwnames[] = {
23887         (char *) "self", NULL
23888     };
23889
23890     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnablePrintToFile",kwnames,&obj0)) goto fail;
23891     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23892     if (SWIG_arg_fail(1)) SWIG_fail;
23893     {
23894         PyThreadState* __tstate = wxPyBeginAllowThreads();
23895         result = (bool)((wxPrintDialogData const *)arg1)->GetEnablePrintToFile();
23896
23897         wxPyEndAllowThreads(__tstate);
23898         if (PyErr_Occurred()) SWIG_fail;
23899     }
23900     {
23901         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23902     }
23903     return resultobj;
23904     fail:
23905     return NULL;
23906 }
23907
23908
23909 static PyObject *_wrap_PrintDialogData_GetEnableSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23910     PyObject *resultobj;
23911     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23912     bool result;
23913     PyObject * obj0 = 0 ;
23914     char *kwnames[] = {
23915         (char *) "self", NULL
23916     };
23917
23918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnableSelection",kwnames,&obj0)) goto fail;
23919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23920     if (SWIG_arg_fail(1)) SWIG_fail;
23921     {
23922         PyThreadState* __tstate = wxPyBeginAllowThreads();
23923         result = (bool)((wxPrintDialogData const *)arg1)->GetEnableSelection();
23924
23925         wxPyEndAllowThreads(__tstate);
23926         if (PyErr_Occurred()) SWIG_fail;
23927     }
23928     {
23929         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23930     }
23931     return resultobj;
23932     fail:
23933     return NULL;
23934 }
23935
23936
23937 static PyObject *_wrap_PrintDialogData_GetEnablePageNumbers(PyObject *, PyObject *args, PyObject *kwargs) {
23938     PyObject *resultobj;
23939     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23940     bool result;
23941     PyObject * obj0 = 0 ;
23942     char *kwnames[] = {
23943         (char *) "self", NULL
23944     };
23945
23946     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnablePageNumbers",kwnames,&obj0)) goto fail;
23947     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23948     if (SWIG_arg_fail(1)) SWIG_fail;
23949     {
23950         PyThreadState* __tstate = wxPyBeginAllowThreads();
23951         result = (bool)((wxPrintDialogData const *)arg1)->GetEnablePageNumbers();
23952
23953         wxPyEndAllowThreads(__tstate);
23954         if (PyErr_Occurred()) SWIG_fail;
23955     }
23956     {
23957         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23958     }
23959     return resultobj;
23960     fail:
23961     return NULL;
23962 }
23963
23964
23965 static PyObject *_wrap_PrintDialogData_GetEnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
23966     PyObject *resultobj;
23967     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23968     bool result;
23969     PyObject * obj0 = 0 ;
23970     char *kwnames[] = {
23971         (char *) "self", NULL
23972     };
23973
23974     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnableHelp",kwnames,&obj0)) goto fail;
23975     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23976     if (SWIG_arg_fail(1)) SWIG_fail;
23977     {
23978         PyThreadState* __tstate = wxPyBeginAllowThreads();
23979         result = (bool)((wxPrintDialogData const *)arg1)->GetEnableHelp();
23980
23981         wxPyEndAllowThreads(__tstate);
23982         if (PyErr_Occurred()) SWIG_fail;
23983     }
23984     {
23985         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23986     }
23987     return resultobj;
23988     fail:
23989     return NULL;
23990 }
23991
23992
23993 static PyObject *_wrap_PrintDialogData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23994     PyObject *resultobj;
23995     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23996     bool result;
23997     PyObject * obj0 = 0 ;
23998     char *kwnames[] = {
23999         (char *) "self", NULL
24000     };
24001
24002     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_Ok",kwnames,&obj0)) goto fail;
24003     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24004     if (SWIG_arg_fail(1)) SWIG_fail;
24005     {
24006         PyThreadState* __tstate = wxPyBeginAllowThreads();
24007         result = (bool)((wxPrintDialogData const *)arg1)->Ok();
24008
24009         wxPyEndAllowThreads(__tstate);
24010         if (PyErr_Occurred()) SWIG_fail;
24011     }
24012     {
24013         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24014     }
24015     return resultobj;
24016     fail:
24017     return NULL;
24018 }
24019
24020
24021 static PyObject *_wrap_PrintDialogData_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24022     PyObject *resultobj;
24023     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24024     wxPrintData *result;
24025     PyObject * obj0 = 0 ;
24026     char *kwnames[] = {
24027         (char *) "self", NULL
24028     };
24029
24030     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetPrintData",kwnames,&obj0)) goto fail;
24031     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24032     if (SWIG_arg_fail(1)) SWIG_fail;
24033     {
24034         PyThreadState* __tstate = wxPyBeginAllowThreads();
24035         {
24036             wxPrintData &_result_ref = (arg1)->GetPrintData();
24037             result = (wxPrintData *) &_result_ref;
24038         }
24039
24040         wxPyEndAllowThreads(__tstate);
24041         if (PyErr_Occurred()) SWIG_fail;
24042     }
24043     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
24044     return resultobj;
24045     fail:
24046     return NULL;
24047 }
24048
24049
24050 static PyObject *_wrap_PrintDialogData_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24051     PyObject *resultobj;
24052     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24053     wxPrintData *arg2 = 0 ;
24054     PyObject * obj0 = 0 ;
24055     PyObject * obj1 = 0 ;
24056     char *kwnames[] = {
24057         (char *) "self",(char *) "printData", NULL
24058     };
24059
24060     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
24061     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24062     if (SWIG_arg_fail(1)) SWIG_fail;
24063     {
24064         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
24065         if (SWIG_arg_fail(2)) SWIG_fail;
24066         if (arg2 == NULL) {
24067             SWIG_null_ref("wxPrintData");
24068         }
24069         if (SWIG_arg_fail(2)) SWIG_fail;
24070     }
24071     {
24072         PyThreadState* __tstate = wxPyBeginAllowThreads();
24073         (arg1)->SetPrintData((wxPrintData const &)*arg2);
24074
24075         wxPyEndAllowThreads(__tstate);
24076         if (PyErr_Occurred()) SWIG_fail;
24077     }
24078     Py_INCREF(Py_None); resultobj = Py_None;
24079     return resultobj;
24080     fail:
24081     return NULL;
24082 }
24083
24084
24085 static PyObject * PrintDialogData_swigregister(PyObject *, PyObject *args) {
24086     PyObject *obj;
24087     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24088     SWIG_TypeClientData(SWIGTYPE_p_wxPrintDialogData, obj);
24089     Py_INCREF(obj);
24090     return Py_BuildValue((char *)"");
24091 }
24092 static PyObject *_wrap_new_PrintDialog(PyObject *, PyObject *args, PyObject *kwargs) {
24093     PyObject *resultobj;
24094     wxWindow *arg1 = (wxWindow *) 0 ;
24095     wxPrintDialogData *arg2 = (wxPrintDialogData *) NULL ;
24096     wxPrintDialog *result;
24097     PyObject * obj0 = 0 ;
24098     PyObject * obj1 = 0 ;
24099     char *kwnames[] = {
24100         (char *) "parent",(char *) "data", NULL
24101     };
24102
24103     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PrintDialog",kwnames,&obj0,&obj1)) goto fail;
24104     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24105     if (SWIG_arg_fail(1)) SWIG_fail;
24106     if (obj1) {
24107         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24108         if (SWIG_arg_fail(2)) SWIG_fail;
24109     }
24110     {
24111         if (!wxPyCheckForApp()) SWIG_fail;
24112         PyThreadState* __tstate = wxPyBeginAllowThreads();
24113         result = (wxPrintDialog *)new wxPrintDialog(arg1,arg2);
24114
24115         wxPyEndAllowThreads(__tstate);
24116         if (PyErr_Occurred()) SWIG_fail;
24117     }
24118     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialog, 1);
24119     return resultobj;
24120     fail:
24121     return NULL;
24122 }
24123
24124
24125 static PyObject *_wrap_PrintDialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
24126     PyObject *resultobj;
24127     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24128     int result;
24129     PyObject * obj0 = 0 ;
24130     char *kwnames[] = {
24131         (char *) "self", NULL
24132     };
24133
24134     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_ShowModal",kwnames,&obj0)) goto fail;
24135     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24136     if (SWIG_arg_fail(1)) SWIG_fail;
24137     {
24138         PyThreadState* __tstate = wxPyBeginAllowThreads();
24139         result = (int)(arg1)->ShowModal();
24140
24141         wxPyEndAllowThreads(__tstate);
24142         if (PyErr_Occurred()) SWIG_fail;
24143     }
24144     {
24145         resultobj = SWIG_From_int((int)(result));
24146     }
24147     return resultobj;
24148     fail:
24149     return NULL;
24150 }
24151
24152
24153 static PyObject *_wrap_PrintDialog_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
24154     PyObject *resultobj;
24155     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24156     wxPrintDialogData *result;
24157     PyObject * obj0 = 0 ;
24158     char *kwnames[] = {
24159         (char *) "self", NULL
24160     };
24161
24162     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintDialogData",kwnames,&obj0)) goto fail;
24163     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24164     if (SWIG_arg_fail(1)) SWIG_fail;
24165     {
24166         PyThreadState* __tstate = wxPyBeginAllowThreads();
24167         {
24168             wxPrintDialogData &_result_ref = (arg1)->GetPrintDialogData();
24169             result = (wxPrintDialogData *) &_result_ref;
24170         }
24171
24172         wxPyEndAllowThreads(__tstate);
24173         if (PyErr_Occurred()) SWIG_fail;
24174     }
24175     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
24176     return resultobj;
24177     fail:
24178     return NULL;
24179 }
24180
24181
24182 static PyObject *_wrap_PrintDialog_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24183     PyObject *resultobj;
24184     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24185     wxPrintData *result;
24186     PyObject * obj0 = 0 ;
24187     char *kwnames[] = {
24188         (char *) "self", NULL
24189     };
24190
24191     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintData",kwnames,&obj0)) goto fail;
24192     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24193     if (SWIG_arg_fail(1)) SWIG_fail;
24194     {
24195         PyThreadState* __tstate = wxPyBeginAllowThreads();
24196         {
24197             wxPrintData &_result_ref = (arg1)->GetPrintData();
24198             result = (wxPrintData *) &_result_ref;
24199         }
24200
24201         wxPyEndAllowThreads(__tstate);
24202         if (PyErr_Occurred()) SWIG_fail;
24203     }
24204     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
24205     return resultobj;
24206     fail:
24207     return NULL;
24208 }
24209
24210
24211 static PyObject *_wrap_PrintDialog_GetPrintDC(PyObject *, PyObject *args, PyObject *kwargs) {
24212     PyObject *resultobj;
24213     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24214     wxDC *result;
24215     PyObject * obj0 = 0 ;
24216     char *kwnames[] = {
24217         (char *) "self", NULL
24218     };
24219
24220     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintDC",kwnames,&obj0)) goto fail;
24221     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24222     if (SWIG_arg_fail(1)) SWIG_fail;
24223     {
24224         PyThreadState* __tstate = wxPyBeginAllowThreads();
24225         result = (wxDC *)(arg1)->GetPrintDC();
24226
24227         wxPyEndAllowThreads(__tstate);
24228         if (PyErr_Occurred()) SWIG_fail;
24229     }
24230     {
24231         resultobj = wxPyMake_wxObject(result, 1);
24232     }
24233     return resultobj;
24234     fail:
24235     return NULL;
24236 }
24237
24238
24239 static PyObject * PrintDialog_swigregister(PyObject *, PyObject *args) {
24240     PyObject *obj;
24241     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24242     SWIG_TypeClientData(SWIGTYPE_p_wxPrintDialog, obj);
24243     Py_INCREF(obj);
24244     return Py_BuildValue((char *)"");
24245 }
24246 static PyObject *_wrap_new_Printer(PyObject *, PyObject *args, PyObject *kwargs) {
24247     PyObject *resultobj;
24248     wxPrintDialogData *arg1 = (wxPrintDialogData *) NULL ;
24249     wxPrinter *result;
24250     PyObject * obj0 = 0 ;
24251     char *kwnames[] = {
24252         (char *) "data", NULL
24253     };
24254
24255     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Printer",kwnames,&obj0)) goto fail;
24256     if (obj0) {
24257         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24258         if (SWIG_arg_fail(1)) SWIG_fail;
24259     }
24260     {
24261         if (!wxPyCheckForApp()) SWIG_fail;
24262         PyThreadState* __tstate = wxPyBeginAllowThreads();
24263         result = (wxPrinter *)new wxPrinter(arg1);
24264
24265         wxPyEndAllowThreads(__tstate);
24266         if (PyErr_Occurred()) SWIG_fail;
24267     }
24268     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinter, 1);
24269     return resultobj;
24270     fail:
24271     return NULL;
24272 }
24273
24274
24275 static PyObject *_wrap_delete_Printer(PyObject *, PyObject *args, PyObject *kwargs) {
24276     PyObject *resultobj;
24277     wxPrinter *arg1 = (wxPrinter *) 0 ;
24278     PyObject * obj0 = 0 ;
24279     char *kwnames[] = {
24280         (char *) "self", NULL
24281     };
24282
24283     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Printer",kwnames,&obj0)) goto fail;
24284     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24285     if (SWIG_arg_fail(1)) SWIG_fail;
24286     {
24287         PyThreadState* __tstate = wxPyBeginAllowThreads();
24288         delete arg1;
24289
24290         wxPyEndAllowThreads(__tstate);
24291         if (PyErr_Occurred()) SWIG_fail;
24292     }
24293     Py_INCREF(Py_None); resultobj = Py_None;
24294     return resultobj;
24295     fail:
24296     return NULL;
24297 }
24298
24299
24300 static PyObject *_wrap_Printer_CreateAbortWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24301     PyObject *resultobj;
24302     wxPrinter *arg1 = (wxPrinter *) 0 ;
24303     wxWindow *arg2 = (wxWindow *) 0 ;
24304     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24305     wxWindow *result;
24306     PyObject * obj0 = 0 ;
24307     PyObject * obj1 = 0 ;
24308     PyObject * obj2 = 0 ;
24309     char *kwnames[] = {
24310         (char *) "self",(char *) "parent",(char *) "printout", NULL
24311     };
24312
24313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printer_CreateAbortWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
24314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24315     if (SWIG_arg_fail(1)) SWIG_fail;
24316     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24317     if (SWIG_arg_fail(2)) SWIG_fail;
24318     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24319     if (SWIG_arg_fail(3)) SWIG_fail;
24320     {
24321         PyThreadState* __tstate = wxPyBeginAllowThreads();
24322         result = (wxWindow *)(arg1)->CreateAbortWindow(arg2,arg3);
24323
24324         wxPyEndAllowThreads(__tstate);
24325         if (PyErr_Occurred()) SWIG_fail;
24326     }
24327     {
24328         resultobj = wxPyMake_wxObject(result, 0);
24329     }
24330     return resultobj;
24331     fail:
24332     return NULL;
24333 }
24334
24335
24336 static PyObject *_wrap_Printer_ReportError(PyObject *, PyObject *args, PyObject *kwargs) {
24337     PyObject *resultobj;
24338     wxPrinter *arg1 = (wxPrinter *) 0 ;
24339     wxWindow *arg2 = (wxWindow *) 0 ;
24340     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24341     wxString *arg4 = 0 ;
24342     bool temp4 = false ;
24343     PyObject * obj0 = 0 ;
24344     PyObject * obj1 = 0 ;
24345     PyObject * obj2 = 0 ;
24346     PyObject * obj3 = 0 ;
24347     char *kwnames[] = {
24348         (char *) "self",(char *) "parent",(char *) "printout",(char *) "message", NULL
24349     };
24350
24351     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Printer_ReportError",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24352     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24353     if (SWIG_arg_fail(1)) SWIG_fail;
24354     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24355     if (SWIG_arg_fail(2)) SWIG_fail;
24356     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24357     if (SWIG_arg_fail(3)) SWIG_fail;
24358     {
24359         arg4 = wxString_in_helper(obj3);
24360         if (arg4 == NULL) SWIG_fail;
24361         temp4 = true;
24362     }
24363     {
24364         PyThreadState* __tstate = wxPyBeginAllowThreads();
24365         (arg1)->ReportError(arg2,arg3,(wxString const &)*arg4);
24366
24367         wxPyEndAllowThreads(__tstate);
24368         if (PyErr_Occurred()) SWIG_fail;
24369     }
24370     Py_INCREF(Py_None); resultobj = Py_None;
24371     {
24372         if (temp4)
24373         delete arg4;
24374     }
24375     return resultobj;
24376     fail:
24377     {
24378         if (temp4)
24379         delete arg4;
24380     }
24381     return NULL;
24382 }
24383
24384
24385 static PyObject *_wrap_Printer_Setup(PyObject *, PyObject *args, PyObject *kwargs) {
24386     PyObject *resultobj;
24387     wxPrinter *arg1 = (wxPrinter *) 0 ;
24388     wxWindow *arg2 = (wxWindow *) 0 ;
24389     bool result;
24390     PyObject * obj0 = 0 ;
24391     PyObject * obj1 = 0 ;
24392     char *kwnames[] = {
24393         (char *) "self",(char *) "parent", NULL
24394     };
24395
24396     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printer_Setup",kwnames,&obj0,&obj1)) goto fail;
24397     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24398     if (SWIG_arg_fail(1)) SWIG_fail;
24399     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24400     if (SWIG_arg_fail(2)) SWIG_fail;
24401     {
24402         PyThreadState* __tstate = wxPyBeginAllowThreads();
24403         result = (bool)(arg1)->Setup(arg2);
24404
24405         wxPyEndAllowThreads(__tstate);
24406         if (PyErr_Occurred()) SWIG_fail;
24407     }
24408     {
24409         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24410     }
24411     return resultobj;
24412     fail:
24413     return NULL;
24414 }
24415
24416
24417 static PyObject *_wrap_Printer_Print(PyObject *, PyObject *args, PyObject *kwargs) {
24418     PyObject *resultobj;
24419     wxPrinter *arg1 = (wxPrinter *) 0 ;
24420     wxWindow *arg2 = (wxWindow *) 0 ;
24421     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24422     bool arg4 = (bool) true ;
24423     bool result;
24424     PyObject * obj0 = 0 ;
24425     PyObject * obj1 = 0 ;
24426     PyObject * obj2 = 0 ;
24427     PyObject * obj3 = 0 ;
24428     char *kwnames[] = {
24429         (char *) "self",(char *) "parent",(char *) "printout",(char *) "prompt", NULL
24430     };
24431
24432     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Printer_Print",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24433     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24434     if (SWIG_arg_fail(1)) SWIG_fail;
24435     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24436     if (SWIG_arg_fail(2)) SWIG_fail;
24437     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24438     if (SWIG_arg_fail(3)) SWIG_fail;
24439     if (obj3) {
24440         {
24441             arg4 = (bool)(SWIG_As_bool(obj3));
24442             if (SWIG_arg_fail(4)) SWIG_fail;
24443         }
24444     }
24445     {
24446         PyThreadState* __tstate = wxPyBeginAllowThreads();
24447         result = (bool)(arg1)->Print(arg2,arg3,arg4);
24448
24449         wxPyEndAllowThreads(__tstate);
24450         if (PyErr_Occurred()) SWIG_fail;
24451     }
24452     {
24453         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24454     }
24455     return resultobj;
24456     fail:
24457     return NULL;
24458 }
24459
24460
24461 static PyObject *_wrap_Printer_PrintDialog(PyObject *, PyObject *args, PyObject *kwargs) {
24462     PyObject *resultobj;
24463     wxPrinter *arg1 = (wxPrinter *) 0 ;
24464     wxWindow *arg2 = (wxWindow *) 0 ;
24465     wxDC *result;
24466     PyObject * obj0 = 0 ;
24467     PyObject * obj1 = 0 ;
24468     char *kwnames[] = {
24469         (char *) "self",(char *) "parent", NULL
24470     };
24471
24472     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printer_PrintDialog",kwnames,&obj0,&obj1)) goto fail;
24473     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24474     if (SWIG_arg_fail(1)) SWIG_fail;
24475     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24476     if (SWIG_arg_fail(2)) SWIG_fail;
24477     {
24478         PyThreadState* __tstate = wxPyBeginAllowThreads();
24479         result = (wxDC *)(arg1)->PrintDialog(arg2);
24480
24481         wxPyEndAllowThreads(__tstate);
24482         if (PyErr_Occurred()) SWIG_fail;
24483     }
24484     {
24485         resultobj = wxPyMake_wxObject(result, 0);
24486     }
24487     return resultobj;
24488     fail:
24489     return NULL;
24490 }
24491
24492
24493 static PyObject *_wrap_Printer_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
24494     PyObject *resultobj;
24495     wxPrinter *arg1 = (wxPrinter *) 0 ;
24496     wxPrintDialogData *result;
24497     PyObject * obj0 = 0 ;
24498     char *kwnames[] = {
24499         (char *) "self", NULL
24500     };
24501
24502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printer_GetPrintDialogData",kwnames,&obj0)) goto fail;
24503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24504     if (SWIG_arg_fail(1)) SWIG_fail;
24505     {
24506         PyThreadState* __tstate = wxPyBeginAllowThreads();
24507         {
24508             wxPrintDialogData &_result_ref = ((wxPrinter const *)arg1)->GetPrintDialogData();
24509             result = (wxPrintDialogData *) &_result_ref;
24510         }
24511
24512         wxPyEndAllowThreads(__tstate);
24513         if (PyErr_Occurred()) SWIG_fail;
24514     }
24515     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
24516     return resultobj;
24517     fail:
24518     return NULL;
24519 }
24520
24521
24522 static PyObject *_wrap_Printer_GetAbort(PyObject *, PyObject *args, PyObject *kwargs) {
24523     PyObject *resultobj;
24524     wxPrinter *arg1 = (wxPrinter *) 0 ;
24525     bool result;
24526     PyObject * obj0 = 0 ;
24527     char *kwnames[] = {
24528         (char *) "self", NULL
24529     };
24530
24531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printer_GetAbort",kwnames,&obj0)) goto fail;
24532     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24533     if (SWIG_arg_fail(1)) SWIG_fail;
24534     {
24535         PyThreadState* __tstate = wxPyBeginAllowThreads();
24536         result = (bool)(arg1)->GetAbort();
24537
24538         wxPyEndAllowThreads(__tstate);
24539         if (PyErr_Occurred()) SWIG_fail;
24540     }
24541     {
24542         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24543     }
24544     return resultobj;
24545     fail:
24546     return NULL;
24547 }
24548
24549
24550 static PyObject *_wrap_Printer_GetLastError(PyObject *, PyObject *args, PyObject *kwargs) {
24551     PyObject *resultobj;
24552     wxPrinterError result;
24553     char *kwnames[] = {
24554         NULL
24555     };
24556
24557     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Printer_GetLastError",kwnames)) goto fail;
24558     {
24559         PyThreadState* __tstate = wxPyBeginAllowThreads();
24560         result = (wxPrinterError)wxPrinter::GetLastError();
24561
24562         wxPyEndAllowThreads(__tstate);
24563         if (PyErr_Occurred()) SWIG_fail;
24564     }
24565     resultobj = SWIG_From_int((result));
24566     return resultobj;
24567     fail:
24568     return NULL;
24569 }
24570
24571
24572 static PyObject * Printer_swigregister(PyObject *, PyObject *args) {
24573     PyObject *obj;
24574     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24575     SWIG_TypeClientData(SWIGTYPE_p_wxPrinter, obj);
24576     Py_INCREF(obj);
24577     return Py_BuildValue((char *)"");
24578 }
24579 static PyObject *_wrap_new_Printout(PyObject *, PyObject *args, PyObject *kwargs) {
24580     PyObject *resultobj;
24581     wxString const &arg1_defvalue = wxPyPrintoutTitleStr ;
24582     wxString *arg1 = (wxString *) &arg1_defvalue ;
24583     wxPyPrintout *result;
24584     bool temp1 = false ;
24585     PyObject * obj0 = 0 ;
24586     char *kwnames[] = {
24587         (char *) "title", NULL
24588     };
24589
24590     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Printout",kwnames,&obj0)) goto fail;
24591     if (obj0) {
24592         {
24593             arg1 = wxString_in_helper(obj0);
24594             if (arg1 == NULL) SWIG_fail;
24595             temp1 = true;
24596         }
24597     }
24598     {
24599         if (!wxPyCheckForApp()) SWIG_fail;
24600         PyThreadState* __tstate = wxPyBeginAllowThreads();
24601         result = (wxPyPrintout *)new wxPyPrintout((wxString const &)*arg1);
24602
24603         wxPyEndAllowThreads(__tstate);
24604         if (PyErr_Occurred()) SWIG_fail;
24605     }
24606     {
24607         resultobj = wxPyMake_wxObject(result, 1);
24608     }
24609     {
24610         if (temp1)
24611         delete arg1;
24612     }
24613     return resultobj;
24614     fail:
24615     {
24616         if (temp1)
24617         delete arg1;
24618     }
24619     return NULL;
24620 }
24621
24622
24623 static PyObject *_wrap_Printout__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
24624     PyObject *resultobj;
24625     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24626     PyObject *arg2 = (PyObject *) 0 ;
24627     PyObject *arg3 = (PyObject *) 0 ;
24628     PyObject * obj0 = 0 ;
24629     PyObject * obj1 = 0 ;
24630     PyObject * obj2 = 0 ;
24631     char *kwnames[] = {
24632         (char *) "self",(char *) "self",(char *) "_class", NULL
24633     };
24634
24635     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
24636     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24637     if (SWIG_arg_fail(1)) SWIG_fail;
24638     arg2 = obj1;
24639     arg3 = obj2;
24640     {
24641         PyThreadState* __tstate = wxPyBeginAllowThreads();
24642         (arg1)->_setCallbackInfo(arg2,arg3);
24643
24644         wxPyEndAllowThreads(__tstate);
24645         if (PyErr_Occurred()) SWIG_fail;
24646     }
24647     Py_INCREF(Py_None); resultobj = Py_None;
24648     return resultobj;
24649     fail:
24650     return NULL;
24651 }
24652
24653
24654 static PyObject *_wrap_Printout_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24655     PyObject *resultobj;
24656     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24657     wxString result;
24658     PyObject * obj0 = 0 ;
24659     char *kwnames[] = {
24660         (char *) "self", NULL
24661     };
24662
24663     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetTitle",kwnames,&obj0)) goto fail;
24664     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24665     if (SWIG_arg_fail(1)) SWIG_fail;
24666     {
24667         PyThreadState* __tstate = wxPyBeginAllowThreads();
24668         result = ((wxPyPrintout const *)arg1)->GetTitle();
24669
24670         wxPyEndAllowThreads(__tstate);
24671         if (PyErr_Occurred()) SWIG_fail;
24672     }
24673     {
24674 #if wxUSE_UNICODE
24675         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24676 #else
24677         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24678 #endif
24679     }
24680     return resultobj;
24681     fail:
24682     return NULL;
24683 }
24684
24685
24686 static PyObject *_wrap_Printout_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
24687     PyObject *resultobj;
24688     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24689     wxDC *result;
24690     PyObject * obj0 = 0 ;
24691     char *kwnames[] = {
24692         (char *) "self", NULL
24693     };
24694
24695     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetDC",kwnames,&obj0)) goto fail;
24696     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24697     if (SWIG_arg_fail(1)) SWIG_fail;
24698     {
24699         PyThreadState* __tstate = wxPyBeginAllowThreads();
24700         result = (wxDC *)(arg1)->GetDC();
24701
24702         wxPyEndAllowThreads(__tstate);
24703         if (PyErr_Occurred()) SWIG_fail;
24704     }
24705     {
24706         resultobj = wxPyMake_wxObject(result, 0);
24707     }
24708     return resultobj;
24709     fail:
24710     return NULL;
24711 }
24712
24713
24714 static PyObject *_wrap_Printout_SetDC(PyObject *, PyObject *args, PyObject *kwargs) {
24715     PyObject *resultobj;
24716     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24717     wxDC *arg2 = (wxDC *) 0 ;
24718     PyObject * obj0 = 0 ;
24719     PyObject * obj1 = 0 ;
24720     char *kwnames[] = {
24721         (char *) "self",(char *) "dc", NULL
24722     };
24723
24724     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetDC",kwnames,&obj0,&obj1)) goto fail;
24725     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24726     if (SWIG_arg_fail(1)) SWIG_fail;
24727     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
24728     if (SWIG_arg_fail(2)) SWIG_fail;
24729     {
24730         PyThreadState* __tstate = wxPyBeginAllowThreads();
24731         (arg1)->SetDC(arg2);
24732
24733         wxPyEndAllowThreads(__tstate);
24734         if (PyErr_Occurred()) SWIG_fail;
24735     }
24736     Py_INCREF(Py_None); resultobj = Py_None;
24737     return resultobj;
24738     fail:
24739     return NULL;
24740 }
24741
24742
24743 static PyObject *_wrap_Printout_SetPageSizePixels(PyObject *, PyObject *args, PyObject *kwargs) {
24744     PyObject *resultobj;
24745     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24746     int arg2 ;
24747     int arg3 ;
24748     PyObject * obj0 = 0 ;
24749     PyObject * obj1 = 0 ;
24750     PyObject * obj2 = 0 ;
24751     char *kwnames[] = {
24752         (char *) "self",(char *) "w",(char *) "h", NULL
24753     };
24754
24755     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPageSizePixels",kwnames,&obj0,&obj1,&obj2)) goto fail;
24756     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24757     if (SWIG_arg_fail(1)) SWIG_fail;
24758     {
24759         arg2 = (int)(SWIG_As_int(obj1));
24760         if (SWIG_arg_fail(2)) SWIG_fail;
24761     }
24762     {
24763         arg3 = (int)(SWIG_As_int(obj2));
24764         if (SWIG_arg_fail(3)) SWIG_fail;
24765     }
24766     {
24767         PyThreadState* __tstate = wxPyBeginAllowThreads();
24768         (arg1)->SetPageSizePixels(arg2,arg3);
24769
24770         wxPyEndAllowThreads(__tstate);
24771         if (PyErr_Occurred()) SWIG_fail;
24772     }
24773     Py_INCREF(Py_None); resultobj = Py_None;
24774     return resultobj;
24775     fail:
24776     return NULL;
24777 }
24778
24779
24780 static PyObject *_wrap_Printout_GetPageSizePixels(PyObject *, PyObject *args, PyObject *kwargs) {
24781     PyObject *resultobj;
24782     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24783     int *arg2 = (int *) 0 ;
24784     int *arg3 = (int *) 0 ;
24785     int temp2 ;
24786     int res2 = 0 ;
24787     int temp3 ;
24788     int res3 = 0 ;
24789     PyObject * obj0 = 0 ;
24790     char *kwnames[] = {
24791         (char *) "self", NULL
24792     };
24793
24794     arg2 = &temp2; res2 = SWIG_NEWOBJ;
24795     arg3 = &temp3; res3 = SWIG_NEWOBJ;
24796     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPageSizePixels",kwnames,&obj0)) goto fail;
24797     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24798     if (SWIG_arg_fail(1)) SWIG_fail;
24799     {
24800         PyThreadState* __tstate = wxPyBeginAllowThreads();
24801         (arg1)->GetPageSizePixels(arg2,arg3);
24802
24803         wxPyEndAllowThreads(__tstate);
24804         if (PyErr_Occurred()) SWIG_fail;
24805     }
24806     Py_INCREF(Py_None); resultobj = Py_None;
24807     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
24808     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
24809     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
24810     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
24811     return resultobj;
24812     fail:
24813     return NULL;
24814 }
24815
24816
24817 static PyObject *_wrap_Printout_SetPageSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
24818     PyObject *resultobj;
24819     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24820     int arg2 ;
24821     int arg3 ;
24822     PyObject * obj0 = 0 ;
24823     PyObject * obj1 = 0 ;
24824     PyObject * obj2 = 0 ;
24825     char *kwnames[] = {
24826         (char *) "self",(char *) "w",(char *) "h", NULL
24827     };
24828
24829     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPageSizeMM",kwnames,&obj0,&obj1,&obj2)) goto fail;
24830     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24831     if (SWIG_arg_fail(1)) SWIG_fail;
24832     {
24833         arg2 = (int)(SWIG_As_int(obj1));
24834         if (SWIG_arg_fail(2)) SWIG_fail;
24835     }
24836     {
24837         arg3 = (int)(SWIG_As_int(obj2));
24838         if (SWIG_arg_fail(3)) SWIG_fail;
24839     }
24840     {
24841         PyThreadState* __tstate = wxPyBeginAllowThreads();
24842         (arg1)->SetPageSizeMM(arg2,arg3);
24843
24844         wxPyEndAllowThreads(__tstate);
24845         if (PyErr_Occurred()) SWIG_fail;
24846     }
24847     Py_INCREF(Py_None); resultobj = Py_None;
24848     return resultobj;
24849     fail:
24850     return NULL;
24851 }
24852
24853
24854 static PyObject *_wrap_Printout_GetPageSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
24855     PyObject *resultobj;
24856     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24857     int *arg2 = (int *) 0 ;
24858     int *arg3 = (int *) 0 ;
24859     int temp2 ;
24860     int res2 = 0 ;
24861     int temp3 ;
24862     int res3 = 0 ;
24863     PyObject * obj0 = 0 ;
24864     char *kwnames[] = {
24865         (char *) "self", NULL
24866     };
24867
24868     arg2 = &temp2; res2 = SWIG_NEWOBJ;
24869     arg3 = &temp3; res3 = SWIG_NEWOBJ;
24870     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPageSizeMM",kwnames,&obj0)) goto fail;
24871     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24872     if (SWIG_arg_fail(1)) SWIG_fail;
24873     {
24874         PyThreadState* __tstate = wxPyBeginAllowThreads();
24875         (arg1)->GetPageSizeMM(arg2,arg3);
24876
24877         wxPyEndAllowThreads(__tstate);
24878         if (PyErr_Occurred()) SWIG_fail;
24879     }
24880     Py_INCREF(Py_None); resultobj = Py_None;
24881     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
24882     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
24883     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
24884     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
24885     return resultobj;
24886     fail:
24887     return NULL;
24888 }
24889
24890
24891 static PyObject *_wrap_Printout_SetPPIScreen(PyObject *, PyObject *args, PyObject *kwargs) {
24892     PyObject *resultobj;
24893     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24894     int arg2 ;
24895     int arg3 ;
24896     PyObject * obj0 = 0 ;
24897     PyObject * obj1 = 0 ;
24898     PyObject * obj2 = 0 ;
24899     char *kwnames[] = {
24900         (char *) "self",(char *) "x",(char *) "y", NULL
24901     };
24902
24903     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPPIScreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
24904     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24905     if (SWIG_arg_fail(1)) SWIG_fail;
24906     {
24907         arg2 = (int)(SWIG_As_int(obj1));
24908         if (SWIG_arg_fail(2)) SWIG_fail;
24909     }
24910     {
24911         arg3 = (int)(SWIG_As_int(obj2));
24912         if (SWIG_arg_fail(3)) SWIG_fail;
24913     }
24914     {
24915         PyThreadState* __tstate = wxPyBeginAllowThreads();
24916         (arg1)->SetPPIScreen(arg2,arg3);
24917
24918         wxPyEndAllowThreads(__tstate);
24919         if (PyErr_Occurred()) SWIG_fail;
24920     }
24921     Py_INCREF(Py_None); resultobj = Py_None;
24922     return resultobj;
24923     fail:
24924     return NULL;
24925 }
24926
24927
24928 static PyObject *_wrap_Printout_GetPPIScreen(PyObject *, PyObject *args, PyObject *kwargs) {
24929     PyObject *resultobj;
24930     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24931     int *arg2 = (int *) 0 ;
24932     int *arg3 = (int *) 0 ;
24933     int temp2 ;
24934     int res2 = 0 ;
24935     int temp3 ;
24936     int res3 = 0 ;
24937     PyObject * obj0 = 0 ;
24938     char *kwnames[] = {
24939         (char *) "self", NULL
24940     };
24941
24942     arg2 = &temp2; res2 = SWIG_NEWOBJ;
24943     arg3 = &temp3; res3 = SWIG_NEWOBJ;
24944     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPPIScreen",kwnames,&obj0)) goto fail;
24945     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24946     if (SWIG_arg_fail(1)) SWIG_fail;
24947     {
24948         PyThreadState* __tstate = wxPyBeginAllowThreads();
24949         (arg1)->GetPPIScreen(arg2,arg3);
24950
24951         wxPyEndAllowThreads(__tstate);
24952         if (PyErr_Occurred()) SWIG_fail;
24953     }
24954     Py_INCREF(Py_None); resultobj = Py_None;
24955     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
24956     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
24957     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
24958     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
24959     return resultobj;
24960     fail:
24961     return NULL;
24962 }
24963
24964
24965 static PyObject *_wrap_Printout_SetPPIPrinter(PyObject *, PyObject *args, PyObject *kwargs) {
24966     PyObject *resultobj;
24967     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24968     int arg2 ;
24969     int arg3 ;
24970     PyObject * obj0 = 0 ;
24971     PyObject * obj1 = 0 ;
24972     PyObject * obj2 = 0 ;
24973     char *kwnames[] = {
24974         (char *) "self",(char *) "x",(char *) "y", NULL
24975     };
24976
24977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPPIPrinter",kwnames,&obj0,&obj1,&obj2)) goto fail;
24978     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24979     if (SWIG_arg_fail(1)) SWIG_fail;
24980     {
24981         arg2 = (int)(SWIG_As_int(obj1));
24982         if (SWIG_arg_fail(2)) SWIG_fail;
24983     }
24984     {
24985         arg3 = (int)(SWIG_As_int(obj2));
24986         if (SWIG_arg_fail(3)) SWIG_fail;
24987     }
24988     {
24989         PyThreadState* __tstate = wxPyBeginAllowThreads();
24990         (arg1)->SetPPIPrinter(arg2,arg3);
24991
24992         wxPyEndAllowThreads(__tstate);
24993         if (PyErr_Occurred()) SWIG_fail;
24994     }
24995     Py_INCREF(Py_None); resultobj = Py_None;
24996     return resultobj;
24997     fail:
24998     return NULL;
24999 }
25000
25001
25002 static PyObject *_wrap_Printout_GetPPIPrinter(PyObject *, PyObject *args, PyObject *kwargs) {
25003     PyObject *resultobj;
25004     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25005     int *arg2 = (int *) 0 ;
25006     int *arg3 = (int *) 0 ;
25007     int temp2 ;
25008     int res2 = 0 ;
25009     int temp3 ;
25010     int res3 = 0 ;
25011     PyObject * obj0 = 0 ;
25012     char *kwnames[] = {
25013         (char *) "self", NULL
25014     };
25015
25016     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25017     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25018     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPPIPrinter",kwnames,&obj0)) goto fail;
25019     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25020     if (SWIG_arg_fail(1)) SWIG_fail;
25021     {
25022         PyThreadState* __tstate = wxPyBeginAllowThreads();
25023         (arg1)->GetPPIPrinter(arg2,arg3);
25024
25025         wxPyEndAllowThreads(__tstate);
25026         if (PyErr_Occurred()) SWIG_fail;
25027     }
25028     Py_INCREF(Py_None); resultobj = Py_None;
25029     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25030     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25031     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25032     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25033     return resultobj;
25034     fail:
25035     return NULL;
25036 }
25037
25038
25039 static PyObject *_wrap_Printout_IsPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25040     PyObject *resultobj;
25041     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25042     bool result;
25043     PyObject * obj0 = 0 ;
25044     char *kwnames[] = {
25045         (char *) "self", NULL
25046     };
25047
25048     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_IsPreview",kwnames,&obj0)) goto fail;
25049     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25050     if (SWIG_arg_fail(1)) SWIG_fail;
25051     {
25052         PyThreadState* __tstate = wxPyBeginAllowThreads();
25053         result = (bool)(arg1)->IsPreview();
25054
25055         wxPyEndAllowThreads(__tstate);
25056         if (PyErr_Occurred()) SWIG_fail;
25057     }
25058     {
25059         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25060     }
25061     return resultobj;
25062     fail:
25063     return NULL;
25064 }
25065
25066
25067 static PyObject *_wrap_Printout_SetIsPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25068     PyObject *resultobj;
25069     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25070     bool arg2 ;
25071     PyObject * obj0 = 0 ;
25072     PyObject * obj1 = 0 ;
25073     char *kwnames[] = {
25074         (char *) "self",(char *) "p", NULL
25075     };
25076
25077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetIsPreview",kwnames,&obj0,&obj1)) goto fail;
25078     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25079     if (SWIG_arg_fail(1)) SWIG_fail;
25080     {
25081         arg2 = (bool)(SWIG_As_bool(obj1));
25082         if (SWIG_arg_fail(2)) SWIG_fail;
25083     }
25084     {
25085         PyThreadState* __tstate = wxPyBeginAllowThreads();
25086         (arg1)->SetIsPreview(arg2);
25087
25088         wxPyEndAllowThreads(__tstate);
25089         if (PyErr_Occurred()) SWIG_fail;
25090     }
25091     Py_INCREF(Py_None); resultobj = Py_None;
25092     return resultobj;
25093     fail:
25094     return NULL;
25095 }
25096
25097
25098 static PyObject *_wrap_Printout_base_OnBeginDocument(PyObject *, PyObject *args, PyObject *kwargs) {
25099     PyObject *resultobj;
25100     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25101     int arg2 ;
25102     int arg3 ;
25103     bool result;
25104     PyObject * obj0 = 0 ;
25105     PyObject * obj1 = 0 ;
25106     PyObject * obj2 = 0 ;
25107     char *kwnames[] = {
25108         (char *) "self",(char *) "startPage",(char *) "endPage", NULL
25109     };
25110
25111     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_base_OnBeginDocument",kwnames,&obj0,&obj1,&obj2)) goto fail;
25112     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25113     if (SWIG_arg_fail(1)) SWIG_fail;
25114     {
25115         arg2 = (int)(SWIG_As_int(obj1));
25116         if (SWIG_arg_fail(2)) SWIG_fail;
25117     }
25118     {
25119         arg3 = (int)(SWIG_As_int(obj2));
25120         if (SWIG_arg_fail(3)) SWIG_fail;
25121     }
25122     {
25123         PyThreadState* __tstate = wxPyBeginAllowThreads();
25124         result = (bool)(arg1)->base_OnBeginDocument(arg2,arg3);
25125
25126         wxPyEndAllowThreads(__tstate);
25127         if (PyErr_Occurred()) SWIG_fail;
25128     }
25129     {
25130         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25131     }
25132     return resultobj;
25133     fail:
25134     return NULL;
25135 }
25136
25137
25138 static PyObject *_wrap_Printout_base_OnEndDocument(PyObject *, PyObject *args, PyObject *kwargs) {
25139     PyObject *resultobj;
25140     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25141     PyObject * obj0 = 0 ;
25142     char *kwnames[] = {
25143         (char *) "self", NULL
25144     };
25145
25146     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnEndDocument",kwnames,&obj0)) goto fail;
25147     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25148     if (SWIG_arg_fail(1)) SWIG_fail;
25149     {
25150         PyThreadState* __tstate = wxPyBeginAllowThreads();
25151         (arg1)->base_OnEndDocument();
25152
25153         wxPyEndAllowThreads(__tstate);
25154         if (PyErr_Occurred()) SWIG_fail;
25155     }
25156     Py_INCREF(Py_None); resultobj = Py_None;
25157     return resultobj;
25158     fail:
25159     return NULL;
25160 }
25161
25162
25163 static PyObject *_wrap_Printout_base_OnBeginPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25164     PyObject *resultobj;
25165     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25166     PyObject * obj0 = 0 ;
25167     char *kwnames[] = {
25168         (char *) "self", NULL
25169     };
25170
25171     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnBeginPrinting",kwnames,&obj0)) goto fail;
25172     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25173     if (SWIG_arg_fail(1)) SWIG_fail;
25174     {
25175         PyThreadState* __tstate = wxPyBeginAllowThreads();
25176         (arg1)->base_OnBeginPrinting();
25177
25178         wxPyEndAllowThreads(__tstate);
25179         if (PyErr_Occurred()) SWIG_fail;
25180     }
25181     Py_INCREF(Py_None); resultobj = Py_None;
25182     return resultobj;
25183     fail:
25184     return NULL;
25185 }
25186
25187
25188 static PyObject *_wrap_Printout_base_OnEndPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25189     PyObject *resultobj;
25190     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25191     PyObject * obj0 = 0 ;
25192     char *kwnames[] = {
25193         (char *) "self", NULL
25194     };
25195
25196     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnEndPrinting",kwnames,&obj0)) goto fail;
25197     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25198     if (SWIG_arg_fail(1)) SWIG_fail;
25199     {
25200         PyThreadState* __tstate = wxPyBeginAllowThreads();
25201         (arg1)->base_OnEndPrinting();
25202
25203         wxPyEndAllowThreads(__tstate);
25204         if (PyErr_Occurred()) SWIG_fail;
25205     }
25206     Py_INCREF(Py_None); resultobj = Py_None;
25207     return resultobj;
25208     fail:
25209     return NULL;
25210 }
25211
25212
25213 static PyObject *_wrap_Printout_base_OnPreparePrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25214     PyObject *resultobj;
25215     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25216     PyObject * obj0 = 0 ;
25217     char *kwnames[] = {
25218         (char *) "self", NULL
25219     };
25220
25221     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnPreparePrinting",kwnames,&obj0)) goto fail;
25222     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25223     if (SWIG_arg_fail(1)) SWIG_fail;
25224     {
25225         PyThreadState* __tstate = wxPyBeginAllowThreads();
25226         (arg1)->base_OnPreparePrinting();
25227
25228         wxPyEndAllowThreads(__tstate);
25229         if (PyErr_Occurred()) SWIG_fail;
25230     }
25231     Py_INCREF(Py_None); resultobj = Py_None;
25232     return resultobj;
25233     fail:
25234     return NULL;
25235 }
25236
25237
25238 static PyObject *_wrap_Printout_base_HasPage(PyObject *, PyObject *args, PyObject *kwargs) {
25239     PyObject *resultobj;
25240     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25241     int arg2 ;
25242     bool result;
25243     PyObject * obj0 = 0 ;
25244     PyObject * obj1 = 0 ;
25245     char *kwnames[] = {
25246         (char *) "self",(char *) "page", NULL
25247     };
25248
25249     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_base_HasPage",kwnames,&obj0,&obj1)) goto fail;
25250     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25251     if (SWIG_arg_fail(1)) SWIG_fail;
25252     {
25253         arg2 = (int)(SWIG_As_int(obj1));
25254         if (SWIG_arg_fail(2)) SWIG_fail;
25255     }
25256     {
25257         PyThreadState* __tstate = wxPyBeginAllowThreads();
25258         result = (bool)(arg1)->base_HasPage(arg2);
25259
25260         wxPyEndAllowThreads(__tstate);
25261         if (PyErr_Occurred()) SWIG_fail;
25262     }
25263     {
25264         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25265     }
25266     return resultobj;
25267     fail:
25268     return NULL;
25269 }
25270
25271
25272 static PyObject *_wrap_Printout_base_GetPageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
25273     PyObject *resultobj;
25274     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25275     int *arg2 = (int *) 0 ;
25276     int *arg3 = (int *) 0 ;
25277     int *arg4 = (int *) 0 ;
25278     int *arg5 = (int *) 0 ;
25279     int temp2 ;
25280     int res2 = 0 ;
25281     int temp3 ;
25282     int res3 = 0 ;
25283     int temp4 ;
25284     int res4 = 0 ;
25285     int temp5 ;
25286     int res5 = 0 ;
25287     PyObject * obj0 = 0 ;
25288     char *kwnames[] = {
25289         (char *) "self", NULL
25290     };
25291
25292     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25293     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25294     arg4 = &temp4; res4 = SWIG_NEWOBJ;
25295     arg5 = &temp5; res5 = SWIG_NEWOBJ;
25296     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_GetPageInfo",kwnames,&obj0)) goto fail;
25297     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25298     if (SWIG_arg_fail(1)) SWIG_fail;
25299     {
25300         PyThreadState* __tstate = wxPyBeginAllowThreads();
25301         (arg1)->base_GetPageInfo(arg2,arg3,arg4,arg5);
25302
25303         wxPyEndAllowThreads(__tstate);
25304         if (PyErr_Occurred()) SWIG_fail;
25305     }
25306     Py_INCREF(Py_None); resultobj = Py_None;
25307     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25308     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25309     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25310     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25311     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
25312     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
25313     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
25314     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
25315     return resultobj;
25316     fail:
25317     return NULL;
25318 }
25319
25320
25321 static PyObject * Printout_swigregister(PyObject *, PyObject *args) {
25322     PyObject *obj;
25323     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25324     SWIG_TypeClientData(SWIGTYPE_p_wxPyPrintout, obj);
25325     Py_INCREF(obj);
25326     return Py_BuildValue((char *)"");
25327 }
25328 static PyObject *_wrap_new_PreviewCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
25329     PyObject *resultobj;
25330     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25331     wxWindow *arg2 = (wxWindow *) 0 ;
25332     wxPoint const &arg3_defvalue = wxDefaultPosition ;
25333     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25334     wxSize const &arg4_defvalue = wxDefaultSize ;
25335     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25336     long arg5 = (long) 0 ;
25337     wxString const &arg6_defvalue = wxPyPreviewCanvasNameStr ;
25338     wxString *arg6 = (wxString *) &arg6_defvalue ;
25339     wxPreviewCanvas *result;
25340     wxPoint temp3 ;
25341     wxSize temp4 ;
25342     bool temp6 = false ;
25343     PyObject * obj0 = 0 ;
25344     PyObject * obj1 = 0 ;
25345     PyObject * obj2 = 0 ;
25346     PyObject * obj3 = 0 ;
25347     PyObject * obj4 = 0 ;
25348     PyObject * obj5 = 0 ;
25349     char *kwnames[] = {
25350         (char *) "preview",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25351     };
25352
25353     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_PreviewCanvas",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25354     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25355     if (SWIG_arg_fail(1)) SWIG_fail;
25356     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25357     if (SWIG_arg_fail(2)) SWIG_fail;
25358     if (obj2) {
25359         {
25360             arg3 = &temp3;
25361             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25362         }
25363     }
25364     if (obj3) {
25365         {
25366             arg4 = &temp4;
25367             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25368         }
25369     }
25370     if (obj4) {
25371         {
25372             arg5 = (long)(SWIG_As_long(obj4));
25373             if (SWIG_arg_fail(5)) SWIG_fail;
25374         }
25375     }
25376     if (obj5) {
25377         {
25378             arg6 = wxString_in_helper(obj5);
25379             if (arg6 == NULL) SWIG_fail;
25380             temp6 = true;
25381         }
25382     }
25383     {
25384         if (!wxPyCheckForApp()) SWIG_fail;
25385         PyThreadState* __tstate = wxPyBeginAllowThreads();
25386         result = (wxPreviewCanvas *)new wxPreviewCanvas(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25387
25388         wxPyEndAllowThreads(__tstate);
25389         if (PyErr_Occurred()) SWIG_fail;
25390     }
25391     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewCanvas, 1);
25392     {
25393         if (temp6)
25394         delete arg6;
25395     }
25396     return resultobj;
25397     fail:
25398     {
25399         if (temp6)
25400         delete arg6;
25401     }
25402     return NULL;
25403 }
25404
25405
25406 static PyObject * PreviewCanvas_swigregister(PyObject *, PyObject *args) {
25407     PyObject *obj;
25408     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25409     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewCanvas, obj);
25410     Py_INCREF(obj);
25411     return Py_BuildValue((char *)"");
25412 }
25413 static PyObject *_wrap_new_PreviewFrame(PyObject *, PyObject *args, PyObject *kwargs) {
25414     PyObject *resultobj;
25415     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25416     wxFrame *arg2 = (wxFrame *) 0 ;
25417     wxString *arg3 = 0 ;
25418     wxPoint const &arg4_defvalue = wxDefaultPosition ;
25419     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25420     wxSize const &arg5_defvalue = wxDefaultSize ;
25421     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25422     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
25423     wxString const &arg7_defvalue = wxPyFrameNameStr ;
25424     wxString *arg7 = (wxString *) &arg7_defvalue ;
25425     wxPreviewFrame *result;
25426     bool temp3 = false ;
25427     wxPoint temp4 ;
25428     wxSize temp5 ;
25429     bool temp7 = false ;
25430     PyObject * obj0 = 0 ;
25431     PyObject * obj1 = 0 ;
25432     PyObject * obj2 = 0 ;
25433     PyObject * obj3 = 0 ;
25434     PyObject * obj4 = 0 ;
25435     PyObject * obj5 = 0 ;
25436     PyObject * obj6 = 0 ;
25437     char *kwnames[] = {
25438         (char *) "preview",(char *) "parent",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25439     };
25440
25441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PreviewFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25443     if (SWIG_arg_fail(1)) SWIG_fail;
25444     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
25445     if (SWIG_arg_fail(2)) SWIG_fail;
25446     {
25447         arg3 = wxString_in_helper(obj2);
25448         if (arg3 == NULL) SWIG_fail;
25449         temp3 = true;
25450     }
25451     if (obj3) {
25452         {
25453             arg4 = &temp4;
25454             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25455         }
25456     }
25457     if (obj4) {
25458         {
25459             arg5 = &temp5;
25460             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25461         }
25462     }
25463     if (obj5) {
25464         {
25465             arg6 = (long)(SWIG_As_long(obj5));
25466             if (SWIG_arg_fail(6)) SWIG_fail;
25467         }
25468     }
25469     if (obj6) {
25470         {
25471             arg7 = wxString_in_helper(obj6);
25472             if (arg7 == NULL) SWIG_fail;
25473             temp7 = true;
25474         }
25475     }
25476     {
25477         if (!wxPyCheckForApp()) SWIG_fail;
25478         PyThreadState* __tstate = wxPyBeginAllowThreads();
25479         result = (wxPreviewFrame *)new wxPreviewFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25480
25481         wxPyEndAllowThreads(__tstate);
25482         if (PyErr_Occurred()) SWIG_fail;
25483     }
25484     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewFrame, 1);
25485     {
25486         if (temp3)
25487         delete arg3;
25488     }
25489     {
25490         if (temp7)
25491         delete arg7;
25492     }
25493     return resultobj;
25494     fail:
25495     {
25496         if (temp3)
25497         delete arg3;
25498     }
25499     {
25500         if (temp7)
25501         delete arg7;
25502     }
25503     return NULL;
25504 }
25505
25506
25507 static PyObject *_wrap_PreviewFrame_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
25508     PyObject *resultobj;
25509     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25510     PyObject * obj0 = 0 ;
25511     char *kwnames[] = {
25512         (char *) "self", NULL
25513     };
25514
25515     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_Initialize",kwnames,&obj0)) goto fail;
25516     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25517     if (SWIG_arg_fail(1)) SWIG_fail;
25518     {
25519         PyThreadState* __tstate = wxPyBeginAllowThreads();
25520         (arg1)->Initialize();
25521
25522         wxPyEndAllowThreads(__tstate);
25523         if (PyErr_Occurred()) SWIG_fail;
25524     }
25525     Py_INCREF(Py_None); resultobj = Py_None;
25526     return resultobj;
25527     fail:
25528     return NULL;
25529 }
25530
25531
25532 static PyObject *_wrap_PreviewFrame_CreateControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25533     PyObject *resultobj;
25534     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25535     PyObject * obj0 = 0 ;
25536     char *kwnames[] = {
25537         (char *) "self", NULL
25538     };
25539
25540     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_CreateControlBar",kwnames,&obj0)) goto fail;
25541     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25542     if (SWIG_arg_fail(1)) SWIG_fail;
25543     {
25544         PyThreadState* __tstate = wxPyBeginAllowThreads();
25545         (arg1)->CreateControlBar();
25546
25547         wxPyEndAllowThreads(__tstate);
25548         if (PyErr_Occurred()) SWIG_fail;
25549     }
25550     Py_INCREF(Py_None); resultobj = Py_None;
25551     return resultobj;
25552     fail:
25553     return NULL;
25554 }
25555
25556
25557 static PyObject *_wrap_PreviewFrame_CreateCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
25558     PyObject *resultobj;
25559     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25560     PyObject * obj0 = 0 ;
25561     char *kwnames[] = {
25562         (char *) "self", NULL
25563     };
25564
25565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_CreateCanvas",kwnames,&obj0)) goto fail;
25566     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25567     if (SWIG_arg_fail(1)) SWIG_fail;
25568     {
25569         PyThreadState* __tstate = wxPyBeginAllowThreads();
25570         (arg1)->CreateCanvas();
25571
25572         wxPyEndAllowThreads(__tstate);
25573         if (PyErr_Occurred()) SWIG_fail;
25574     }
25575     Py_INCREF(Py_None); resultobj = Py_None;
25576     return resultobj;
25577     fail:
25578     return NULL;
25579 }
25580
25581
25582 static PyObject *_wrap_PreviewFrame_GetControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25583     PyObject *resultobj;
25584     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25585     wxPreviewControlBar *result;
25586     PyObject * obj0 = 0 ;
25587     char *kwnames[] = {
25588         (char *) "self", NULL
25589     };
25590
25591     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_GetControlBar",kwnames,&obj0)) goto fail;
25592     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25593     if (SWIG_arg_fail(1)) SWIG_fail;
25594     {
25595         PyThreadState* __tstate = wxPyBeginAllowThreads();
25596         result = (wxPreviewControlBar *)((wxPreviewFrame const *)arg1)->GetControlBar();
25597
25598         wxPyEndAllowThreads(__tstate);
25599         if (PyErr_Occurred()) SWIG_fail;
25600     }
25601     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewControlBar, 0);
25602     return resultobj;
25603     fail:
25604     return NULL;
25605 }
25606
25607
25608 static PyObject * PreviewFrame_swigregister(PyObject *, PyObject *args) {
25609     PyObject *obj;
25610     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25611     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewFrame, obj);
25612     Py_INCREF(obj);
25613     return Py_BuildValue((char *)"");
25614 }
25615 static PyObject *_wrap_new_PreviewControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25616     PyObject *resultobj;
25617     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25618     long arg2 ;
25619     wxWindow *arg3 = (wxWindow *) 0 ;
25620     wxPoint const &arg4_defvalue = wxDefaultPosition ;
25621     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25622     wxSize const &arg5_defvalue = wxDefaultSize ;
25623     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25624     long arg6 = (long) wxTAB_TRAVERSAL ;
25625     wxString const &arg7_defvalue = wxPyPanelNameStr ;
25626     wxString *arg7 = (wxString *) &arg7_defvalue ;
25627     wxPreviewControlBar *result;
25628     wxPoint temp4 ;
25629     wxSize temp5 ;
25630     bool temp7 = false ;
25631     PyObject * obj0 = 0 ;
25632     PyObject * obj1 = 0 ;
25633     PyObject * obj2 = 0 ;
25634     PyObject * obj3 = 0 ;
25635     PyObject * obj4 = 0 ;
25636     PyObject * obj5 = 0 ;
25637     PyObject * obj6 = 0 ;
25638     char *kwnames[] = {
25639         (char *) "preview",(char *) "buttons",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25640     };
25641
25642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PreviewControlBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25643     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25644     if (SWIG_arg_fail(1)) SWIG_fail;
25645     {
25646         arg2 = (long)(SWIG_As_long(obj1));
25647         if (SWIG_arg_fail(2)) SWIG_fail;
25648     }
25649     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25650     if (SWIG_arg_fail(3)) SWIG_fail;
25651     if (obj3) {
25652         {
25653             arg4 = &temp4;
25654             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25655         }
25656     }
25657     if (obj4) {
25658         {
25659             arg5 = &temp5;
25660             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25661         }
25662     }
25663     if (obj5) {
25664         {
25665             arg6 = (long)(SWIG_As_long(obj5));
25666             if (SWIG_arg_fail(6)) SWIG_fail;
25667         }
25668     }
25669     if (obj6) {
25670         {
25671             arg7 = wxString_in_helper(obj6);
25672             if (arg7 == NULL) SWIG_fail;
25673             temp7 = true;
25674         }
25675     }
25676     {
25677         if (!wxPyCheckForApp()) SWIG_fail;
25678         PyThreadState* __tstate = wxPyBeginAllowThreads();
25679         result = (wxPreviewControlBar *)new wxPreviewControlBar(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25680
25681         wxPyEndAllowThreads(__tstate);
25682         if (PyErr_Occurred()) SWIG_fail;
25683     }
25684     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewControlBar, 1);
25685     {
25686         if (temp7)
25687         delete arg7;
25688     }
25689     return resultobj;
25690     fail:
25691     {
25692         if (temp7)
25693         delete arg7;
25694     }
25695     return NULL;
25696 }
25697
25698
25699 static PyObject *_wrap_PreviewControlBar_GetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
25700     PyObject *resultobj;
25701     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25702     int result;
25703     PyObject * obj0 = 0 ;
25704     char *kwnames[] = {
25705         (char *) "self", NULL
25706     };
25707
25708     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_GetZoomControl",kwnames,&obj0)) goto fail;
25709     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25710     if (SWIG_arg_fail(1)) SWIG_fail;
25711     {
25712         PyThreadState* __tstate = wxPyBeginAllowThreads();
25713         result = (int)(arg1)->GetZoomControl();
25714
25715         wxPyEndAllowThreads(__tstate);
25716         if (PyErr_Occurred()) SWIG_fail;
25717     }
25718     {
25719         resultobj = SWIG_From_int((int)(result));
25720     }
25721     return resultobj;
25722     fail:
25723     return NULL;
25724 }
25725
25726
25727 static PyObject *_wrap_PreviewControlBar_SetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
25728     PyObject *resultobj;
25729     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25730     int arg2 ;
25731     PyObject * obj0 = 0 ;
25732     PyObject * obj1 = 0 ;
25733     char *kwnames[] = {
25734         (char *) "self",(char *) "zoom", NULL
25735     };
25736
25737     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PreviewControlBar_SetZoomControl",kwnames,&obj0,&obj1)) goto fail;
25738     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25739     if (SWIG_arg_fail(1)) SWIG_fail;
25740     {
25741         arg2 = (int)(SWIG_As_int(obj1));
25742         if (SWIG_arg_fail(2)) SWIG_fail;
25743     }
25744     {
25745         PyThreadState* __tstate = wxPyBeginAllowThreads();
25746         (arg1)->SetZoomControl(arg2);
25747
25748         wxPyEndAllowThreads(__tstate);
25749         if (PyErr_Occurred()) SWIG_fail;
25750     }
25751     Py_INCREF(Py_None); resultobj = Py_None;
25752     return resultobj;
25753     fail:
25754     return NULL;
25755 }
25756
25757
25758 static PyObject *_wrap_PreviewControlBar_GetPrintPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25759     PyObject *resultobj;
25760     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25761     wxPrintPreview *result;
25762     PyObject * obj0 = 0 ;
25763     char *kwnames[] = {
25764         (char *) "self", NULL
25765     };
25766
25767     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_GetPrintPreview",kwnames,&obj0)) goto fail;
25768     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25769     if (SWIG_arg_fail(1)) SWIG_fail;
25770     {
25771         PyThreadState* __tstate = wxPyBeginAllowThreads();
25772         result = (wxPrintPreview *)(arg1)->GetPrintPreview();
25773
25774         wxPyEndAllowThreads(__tstate);
25775         if (PyErr_Occurred()) SWIG_fail;
25776     }
25777     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 0);
25778     return resultobj;
25779     fail:
25780     return NULL;
25781 }
25782
25783
25784 static PyObject *_wrap_PreviewControlBar_OnNext(PyObject *, PyObject *args, PyObject *kwargs) {
25785     PyObject *resultobj;
25786     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25787     PyObject * obj0 = 0 ;
25788     char *kwnames[] = {
25789         (char *) "self", NULL
25790     };
25791
25792     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnNext",kwnames,&obj0)) goto fail;
25793     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25794     if (SWIG_arg_fail(1)) SWIG_fail;
25795     {
25796         PyThreadState* __tstate = wxPyBeginAllowThreads();
25797         (arg1)->OnNext();
25798
25799         wxPyEndAllowThreads(__tstate);
25800         if (PyErr_Occurred()) SWIG_fail;
25801     }
25802     Py_INCREF(Py_None); resultobj = Py_None;
25803     return resultobj;
25804     fail:
25805     return NULL;
25806 }
25807
25808
25809 static PyObject *_wrap_PreviewControlBar_OnPrevious(PyObject *, PyObject *args, PyObject *kwargs) {
25810     PyObject *resultobj;
25811     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25812     PyObject * obj0 = 0 ;
25813     char *kwnames[] = {
25814         (char *) "self", NULL
25815     };
25816
25817     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnPrevious",kwnames,&obj0)) goto fail;
25818     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25819     if (SWIG_arg_fail(1)) SWIG_fail;
25820     {
25821         PyThreadState* __tstate = wxPyBeginAllowThreads();
25822         (arg1)->OnPrevious();
25823
25824         wxPyEndAllowThreads(__tstate);
25825         if (PyErr_Occurred()) SWIG_fail;
25826     }
25827     Py_INCREF(Py_None); resultobj = Py_None;
25828     return resultobj;
25829     fail:
25830     return NULL;
25831 }
25832
25833
25834 static PyObject *_wrap_PreviewControlBar_OnFirst(PyObject *, PyObject *args, PyObject *kwargs) {
25835     PyObject *resultobj;
25836     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25837     PyObject * obj0 = 0 ;
25838     char *kwnames[] = {
25839         (char *) "self", NULL
25840     };
25841
25842     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnFirst",kwnames,&obj0)) goto fail;
25843     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25844     if (SWIG_arg_fail(1)) SWIG_fail;
25845     {
25846         PyThreadState* __tstate = wxPyBeginAllowThreads();
25847         (arg1)->OnFirst();
25848
25849         wxPyEndAllowThreads(__tstate);
25850         if (PyErr_Occurred()) SWIG_fail;
25851     }
25852     Py_INCREF(Py_None); resultobj = Py_None;
25853     return resultobj;
25854     fail:
25855     return NULL;
25856 }
25857
25858
25859 static PyObject *_wrap_PreviewControlBar_OnLast(PyObject *, PyObject *args, PyObject *kwargs) {
25860     PyObject *resultobj;
25861     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25862     PyObject * obj0 = 0 ;
25863     char *kwnames[] = {
25864         (char *) "self", NULL
25865     };
25866
25867     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnLast",kwnames,&obj0)) goto fail;
25868     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25869     if (SWIG_arg_fail(1)) SWIG_fail;
25870     {
25871         PyThreadState* __tstate = wxPyBeginAllowThreads();
25872         (arg1)->OnLast();
25873
25874         wxPyEndAllowThreads(__tstate);
25875         if (PyErr_Occurred()) SWIG_fail;
25876     }
25877     Py_INCREF(Py_None); resultobj = Py_None;
25878     return resultobj;
25879     fail:
25880     return NULL;
25881 }
25882
25883
25884 static PyObject *_wrap_PreviewControlBar_OnGoto(PyObject *, PyObject *args, PyObject *kwargs) {
25885     PyObject *resultobj;
25886     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25887     PyObject * obj0 = 0 ;
25888     char *kwnames[] = {
25889         (char *) "self", NULL
25890     };
25891
25892     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnGoto",kwnames,&obj0)) goto fail;
25893     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25894     if (SWIG_arg_fail(1)) SWIG_fail;
25895     {
25896         PyThreadState* __tstate = wxPyBeginAllowThreads();
25897         (arg1)->OnGoto();
25898
25899         wxPyEndAllowThreads(__tstate);
25900         if (PyErr_Occurred()) SWIG_fail;
25901     }
25902     Py_INCREF(Py_None); resultobj = Py_None;
25903     return resultobj;
25904     fail:
25905     return NULL;
25906 }
25907
25908
25909 static PyObject * PreviewControlBar_swigregister(PyObject *, PyObject *args) {
25910     PyObject *obj;
25911     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25912     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewControlBar, obj);
25913     Py_INCREF(obj);
25914     return Py_BuildValue((char *)"");
25915 }
25916 static PyObject *_wrap_new_PrintPreview__SWIG_0(PyObject *, PyObject *args) {
25917     PyObject *resultobj;
25918     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25919     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
25920     wxPrintDialogData *arg3 = (wxPrintDialogData *) NULL ;
25921     wxPrintPreview *result;
25922     PyObject * obj0 = 0 ;
25923     PyObject * obj1 = 0 ;
25924     PyObject * obj2 = 0 ;
25925
25926     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_PrintPreview",&obj0,&obj1,&obj2)) goto fail;
25927     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25928     if (SWIG_arg_fail(1)) SWIG_fail;
25929     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25930     if (SWIG_arg_fail(2)) SWIG_fail;
25931     if (obj2) {
25932         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
25933         if (SWIG_arg_fail(3)) SWIG_fail;
25934     }
25935     {
25936         if (!wxPyCheckForApp()) SWIG_fail;
25937         PyThreadState* __tstate = wxPyBeginAllowThreads();
25938         result = (wxPrintPreview *)new wxPrintPreview(arg1,arg2,arg3);
25939
25940         wxPyEndAllowThreads(__tstate);
25941         if (PyErr_Occurred()) SWIG_fail;
25942     }
25943     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 1);
25944     return resultobj;
25945     fail:
25946     return NULL;
25947 }
25948
25949
25950 static PyObject *_wrap_new_PrintPreview__SWIG_1(PyObject *, PyObject *args) {
25951     PyObject *resultobj;
25952     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25953     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
25954     wxPrintData *arg3 = (wxPrintData *) 0 ;
25955     wxPrintPreview *result;
25956     PyObject * obj0 = 0 ;
25957     PyObject * obj1 = 0 ;
25958     PyObject * obj2 = 0 ;
25959
25960     if(!PyArg_ParseTuple(args,(char *)"OOO:new_PrintPreview",&obj0,&obj1,&obj2)) goto fail;
25961     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25962     if (SWIG_arg_fail(1)) SWIG_fail;
25963     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25964     if (SWIG_arg_fail(2)) SWIG_fail;
25965     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
25966     if (SWIG_arg_fail(3)) SWIG_fail;
25967     {
25968         if (!wxPyCheckForApp()) SWIG_fail;
25969         PyThreadState* __tstate = wxPyBeginAllowThreads();
25970         result = (wxPrintPreview *)new wxPrintPreview(arg1,arg2,arg3);
25971
25972         wxPyEndAllowThreads(__tstate);
25973         if (PyErr_Occurred()) SWIG_fail;
25974     }
25975     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 1);
25976     return resultobj;
25977     fail:
25978     return NULL;
25979 }
25980
25981
25982 static PyObject *_wrap_new_PrintPreview(PyObject *self, PyObject *args) {
25983     int argc;
25984     PyObject *argv[4];
25985     int ii;
25986
25987     argc = PyObject_Length(args);
25988     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
25989         argv[ii] = PyTuple_GetItem(args,ii);
25990     }
25991     if ((argc >= 2) && (argc <= 3)) {
25992         int _v;
25993         {
25994             void *ptr;
25995             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
25996                 _v = 0;
25997                 PyErr_Clear();
25998             } else {
25999                 _v = 1;
26000             }
26001         }
26002         if (_v) {
26003             {
26004                 void *ptr;
26005                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26006                     _v = 0;
26007                     PyErr_Clear();
26008                 } else {
26009                     _v = 1;
26010                 }
26011             }
26012             if (_v) {
26013                 if (argc <= 2) {
26014                     return _wrap_new_PrintPreview__SWIG_0(self,args);
26015                 }
26016                 {
26017                     void *ptr;
26018                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
26019                         _v = 0;
26020                         PyErr_Clear();
26021                     } else {
26022                         _v = 1;
26023                     }
26024                 }
26025                 if (_v) {
26026                     return _wrap_new_PrintPreview__SWIG_0(self,args);
26027                 }
26028             }
26029         }
26030     }
26031     if (argc == 3) {
26032         int _v;
26033         {
26034             void *ptr;
26035             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26036                 _v = 0;
26037                 PyErr_Clear();
26038             } else {
26039                 _v = 1;
26040             }
26041         }
26042         if (_v) {
26043             {
26044                 void *ptr;
26045                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26046                     _v = 0;
26047                     PyErr_Clear();
26048                 } else {
26049                     _v = 1;
26050                 }
26051             }
26052             if (_v) {
26053                 {
26054                     void *ptr;
26055                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
26056                         _v = 0;
26057                         PyErr_Clear();
26058                     } else {
26059                         _v = 1;
26060                     }
26061                 }
26062                 if (_v) {
26063                     return _wrap_new_PrintPreview__SWIG_1(self,args);
26064                 }
26065             }
26066         }
26067     }
26068
26069     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintPreview'");
26070     return NULL;
26071 }
26072
26073
26074 static PyObject *_wrap_PrintPreview_SetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26075     PyObject *resultobj;
26076     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26077     int arg2 ;
26078     bool result;
26079     PyObject * obj0 = 0 ;
26080     PyObject * obj1 = 0 ;
26081     char *kwnames[] = {
26082         (char *) "self",(char *) "pageNum", NULL
26083     };
26084
26085     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetCurrentPage",kwnames,&obj0,&obj1)) goto fail;
26086     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26087     if (SWIG_arg_fail(1)) SWIG_fail;
26088     {
26089         arg2 = (int)(SWIG_As_int(obj1));
26090         if (SWIG_arg_fail(2)) SWIG_fail;
26091     }
26092     {
26093         PyThreadState* __tstate = wxPyBeginAllowThreads();
26094         result = (bool)(arg1)->SetCurrentPage(arg2);
26095
26096         wxPyEndAllowThreads(__tstate);
26097         if (PyErr_Occurred()) SWIG_fail;
26098     }
26099     {
26100         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26101     }
26102     return resultobj;
26103     fail:
26104     return NULL;
26105 }
26106
26107
26108 static PyObject *_wrap_PrintPreview_GetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26109     PyObject *resultobj;
26110     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26111     int result;
26112     PyObject * obj0 = 0 ;
26113     char *kwnames[] = {
26114         (char *) "self", NULL
26115     };
26116
26117     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetCurrentPage",kwnames,&obj0)) goto fail;
26118     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26119     if (SWIG_arg_fail(1)) SWIG_fail;
26120     {
26121         PyThreadState* __tstate = wxPyBeginAllowThreads();
26122         result = (int)(arg1)->GetCurrentPage();
26123
26124         wxPyEndAllowThreads(__tstate);
26125         if (PyErr_Occurred()) SWIG_fail;
26126     }
26127     {
26128         resultobj = SWIG_From_int((int)(result));
26129     }
26130     return resultobj;
26131     fail:
26132     return NULL;
26133 }
26134
26135
26136 static PyObject *_wrap_PrintPreview_SetPrintout(PyObject *, PyObject *args, PyObject *kwargs) {
26137     PyObject *resultobj;
26138     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26139     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26140     PyObject * obj0 = 0 ;
26141     PyObject * obj1 = 0 ;
26142     char *kwnames[] = {
26143         (char *) "self",(char *) "printout", NULL
26144     };
26145
26146     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetPrintout",kwnames,&obj0,&obj1)) goto fail;
26147     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26148     if (SWIG_arg_fail(1)) SWIG_fail;
26149     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26150     if (SWIG_arg_fail(2)) SWIG_fail;
26151     {
26152         PyThreadState* __tstate = wxPyBeginAllowThreads();
26153         (arg1)->SetPrintout(arg2);
26154
26155         wxPyEndAllowThreads(__tstate);
26156         if (PyErr_Occurred()) SWIG_fail;
26157     }
26158     Py_INCREF(Py_None); resultobj = Py_None;
26159     return resultobj;
26160     fail:
26161     return NULL;
26162 }
26163
26164
26165 static PyObject *_wrap_PrintPreview_GetPrintout(PyObject *, PyObject *args, PyObject *kwargs) {
26166     PyObject *resultobj;
26167     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26168     wxPyPrintout *result;
26169     PyObject * obj0 = 0 ;
26170     char *kwnames[] = {
26171         (char *) "self", NULL
26172     };
26173
26174     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintout",kwnames,&obj0)) goto fail;
26175     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26176     if (SWIG_arg_fail(1)) SWIG_fail;
26177     {
26178         PyThreadState* __tstate = wxPyBeginAllowThreads();
26179         result = (wxPyPrintout *)(arg1)->GetPrintout();
26180
26181         wxPyEndAllowThreads(__tstate);
26182         if (PyErr_Occurred()) SWIG_fail;
26183     }
26184     {
26185         resultobj = wxPyMake_wxObject(result, 0);
26186     }
26187     return resultobj;
26188     fail:
26189     return NULL;
26190 }
26191
26192
26193 static PyObject *_wrap_PrintPreview_GetPrintoutForPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
26194     PyObject *resultobj;
26195     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26196     wxPyPrintout *result;
26197     PyObject * obj0 = 0 ;
26198     char *kwnames[] = {
26199         (char *) "self", NULL
26200     };
26201
26202     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintoutForPrinting",kwnames,&obj0)) goto fail;
26203     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26204     if (SWIG_arg_fail(1)) SWIG_fail;
26205     {
26206         PyThreadState* __tstate = wxPyBeginAllowThreads();
26207         result = (wxPyPrintout *)(arg1)->GetPrintoutForPrinting();
26208
26209         wxPyEndAllowThreads(__tstate);
26210         if (PyErr_Occurred()) SWIG_fail;
26211     }
26212     {
26213         resultobj = wxPyMake_wxObject(result, 0);
26214     }
26215     return resultobj;
26216     fail:
26217     return NULL;
26218 }
26219
26220
26221 static PyObject *_wrap_PrintPreview_SetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
26222     PyObject *resultobj;
26223     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26224     wxFrame *arg2 = (wxFrame *) 0 ;
26225     PyObject * obj0 = 0 ;
26226     PyObject * obj1 = 0 ;
26227     char *kwnames[] = {
26228         (char *) "self",(char *) "frame", NULL
26229     };
26230
26231     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetFrame",kwnames,&obj0,&obj1)) goto fail;
26232     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26233     if (SWIG_arg_fail(1)) SWIG_fail;
26234     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
26235     if (SWIG_arg_fail(2)) SWIG_fail;
26236     {
26237         PyThreadState* __tstate = wxPyBeginAllowThreads();
26238         (arg1)->SetFrame(arg2);
26239
26240         wxPyEndAllowThreads(__tstate);
26241         if (PyErr_Occurred()) SWIG_fail;
26242     }
26243     Py_INCREF(Py_None); resultobj = Py_None;
26244     return resultobj;
26245     fail:
26246     return NULL;
26247 }
26248
26249
26250 static PyObject *_wrap_PrintPreview_SetCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
26251     PyObject *resultobj;
26252     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26253     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26254     PyObject * obj0 = 0 ;
26255     PyObject * obj1 = 0 ;
26256     char *kwnames[] = {
26257         (char *) "self",(char *) "canvas", NULL
26258     };
26259
26260     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetCanvas",kwnames,&obj0,&obj1)) goto fail;
26261     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26262     if (SWIG_arg_fail(1)) SWIG_fail;
26263     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26264     if (SWIG_arg_fail(2)) SWIG_fail;
26265     {
26266         PyThreadState* __tstate = wxPyBeginAllowThreads();
26267         (arg1)->SetCanvas(arg2);
26268
26269         wxPyEndAllowThreads(__tstate);
26270         if (PyErr_Occurred()) SWIG_fail;
26271     }
26272     Py_INCREF(Py_None); resultobj = Py_None;
26273     return resultobj;
26274     fail:
26275     return NULL;
26276 }
26277
26278
26279 static PyObject *_wrap_PrintPreview_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
26280     PyObject *resultobj;
26281     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26282     wxFrame *result;
26283     PyObject * obj0 = 0 ;
26284     char *kwnames[] = {
26285         (char *) "self", NULL
26286     };
26287
26288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetFrame",kwnames,&obj0)) goto fail;
26289     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26290     if (SWIG_arg_fail(1)) SWIG_fail;
26291     {
26292         PyThreadState* __tstate = wxPyBeginAllowThreads();
26293         result = (wxFrame *)(arg1)->GetFrame();
26294
26295         wxPyEndAllowThreads(__tstate);
26296         if (PyErr_Occurred()) SWIG_fail;
26297     }
26298     {
26299         resultobj = wxPyMake_wxObject(result, 0);
26300     }
26301     return resultobj;
26302     fail:
26303     return NULL;
26304 }
26305
26306
26307 static PyObject *_wrap_PrintPreview_GetCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
26308     PyObject *resultobj;
26309     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26310     wxPreviewCanvas *result;
26311     PyObject * obj0 = 0 ;
26312     char *kwnames[] = {
26313         (char *) "self", NULL
26314     };
26315
26316     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetCanvas",kwnames,&obj0)) goto fail;
26317     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26318     if (SWIG_arg_fail(1)) SWIG_fail;
26319     {
26320         PyThreadState* __tstate = wxPyBeginAllowThreads();
26321         result = (wxPreviewCanvas *)(arg1)->GetCanvas();
26322
26323         wxPyEndAllowThreads(__tstate);
26324         if (PyErr_Occurred()) SWIG_fail;
26325     }
26326     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewCanvas, 0);
26327     return resultobj;
26328     fail:
26329     return NULL;
26330 }
26331
26332
26333 static PyObject *_wrap_PrintPreview_PaintPage(PyObject *, PyObject *args, PyObject *kwargs) {
26334     PyObject *resultobj;
26335     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26336     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26337     wxDC *arg3 = 0 ;
26338     bool result;
26339     PyObject * obj0 = 0 ;
26340     PyObject * obj1 = 0 ;
26341     PyObject * obj2 = 0 ;
26342     char *kwnames[] = {
26343         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26344     };
26345
26346     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintPreview_PaintPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26347     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26348     if (SWIG_arg_fail(1)) SWIG_fail;
26349     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26350     if (SWIG_arg_fail(2)) SWIG_fail;
26351     {
26352         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26353         if (SWIG_arg_fail(3)) SWIG_fail;
26354         if (arg3 == NULL) {
26355             SWIG_null_ref("wxDC");
26356         }
26357         if (SWIG_arg_fail(3)) SWIG_fail;
26358     }
26359     {
26360         PyThreadState* __tstate = wxPyBeginAllowThreads();
26361         result = (bool)(arg1)->PaintPage(arg2,*arg3);
26362
26363         wxPyEndAllowThreads(__tstate);
26364         if (PyErr_Occurred()) SWIG_fail;
26365     }
26366     {
26367         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26368     }
26369     return resultobj;
26370     fail:
26371     return NULL;
26372 }
26373
26374
26375 static PyObject *_wrap_PrintPreview_DrawBlankPage(PyObject *, PyObject *args, PyObject *kwargs) {
26376     PyObject *resultobj;
26377     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26378     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26379     wxDC *arg3 = 0 ;
26380     bool result;
26381     PyObject * obj0 = 0 ;
26382     PyObject * obj1 = 0 ;
26383     PyObject * obj2 = 0 ;
26384     char *kwnames[] = {
26385         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26386     };
26387
26388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintPreview_DrawBlankPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26389     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26390     if (SWIG_arg_fail(1)) SWIG_fail;
26391     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26392     if (SWIG_arg_fail(2)) SWIG_fail;
26393     {
26394         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26395         if (SWIG_arg_fail(3)) SWIG_fail;
26396         if (arg3 == NULL) {
26397             SWIG_null_ref("wxDC");
26398         }
26399         if (SWIG_arg_fail(3)) SWIG_fail;
26400     }
26401     {
26402         PyThreadState* __tstate = wxPyBeginAllowThreads();
26403         result = (bool)(arg1)->DrawBlankPage(arg2,*arg3);
26404
26405         wxPyEndAllowThreads(__tstate);
26406         if (PyErr_Occurred()) SWIG_fail;
26407     }
26408     {
26409         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26410     }
26411     return resultobj;
26412     fail:
26413     return NULL;
26414 }
26415
26416
26417 static PyObject *_wrap_PrintPreview_RenderPage(PyObject *, PyObject *args, PyObject *kwargs) {
26418     PyObject *resultobj;
26419     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26420     int arg2 ;
26421     bool result;
26422     PyObject * obj0 = 0 ;
26423     PyObject * obj1 = 0 ;
26424     char *kwnames[] = {
26425         (char *) "self",(char *) "pageNum", NULL
26426     };
26427
26428     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_RenderPage",kwnames,&obj0,&obj1)) goto fail;
26429     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26430     if (SWIG_arg_fail(1)) SWIG_fail;
26431     {
26432         arg2 = (int)(SWIG_As_int(obj1));
26433         if (SWIG_arg_fail(2)) SWIG_fail;
26434     }
26435     {
26436         PyThreadState* __tstate = wxPyBeginAllowThreads();
26437         result = (bool)(arg1)->RenderPage(arg2);
26438
26439         wxPyEndAllowThreads(__tstate);
26440         if (PyErr_Occurred()) SWIG_fail;
26441     }
26442     {
26443         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26444     }
26445     return resultobj;
26446     fail:
26447     return NULL;
26448 }
26449
26450
26451 static PyObject *_wrap_PrintPreview_AdjustScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
26452     PyObject *resultobj;
26453     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26454     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26455     PyObject * obj0 = 0 ;
26456     PyObject * obj1 = 0 ;
26457     char *kwnames[] = {
26458         (char *) "self",(char *) "canvas", NULL
26459     };
26460
26461     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_AdjustScrollbars",kwnames,&obj0,&obj1)) goto fail;
26462     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26463     if (SWIG_arg_fail(1)) SWIG_fail;
26464     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26465     if (SWIG_arg_fail(2)) SWIG_fail;
26466     {
26467         PyThreadState* __tstate = wxPyBeginAllowThreads();
26468         (arg1)->AdjustScrollbars(arg2);
26469
26470         wxPyEndAllowThreads(__tstate);
26471         if (PyErr_Occurred()) SWIG_fail;
26472     }
26473     Py_INCREF(Py_None); resultobj = Py_None;
26474     return resultobj;
26475     fail:
26476     return NULL;
26477 }
26478
26479
26480 static PyObject *_wrap_PrintPreview_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
26481     PyObject *resultobj;
26482     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26483     wxPrintDialogData *result;
26484     PyObject * obj0 = 0 ;
26485     char *kwnames[] = {
26486         (char *) "self", NULL
26487     };
26488
26489     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintDialogData",kwnames,&obj0)) goto fail;
26490     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26491     if (SWIG_arg_fail(1)) SWIG_fail;
26492     {
26493         PyThreadState* __tstate = wxPyBeginAllowThreads();
26494         {
26495             wxPrintDialogData &_result_ref = (arg1)->GetPrintDialogData();
26496             result = (wxPrintDialogData *) &_result_ref;
26497         }
26498
26499         wxPyEndAllowThreads(__tstate);
26500         if (PyErr_Occurred()) SWIG_fail;
26501     }
26502     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
26503     return resultobj;
26504     fail:
26505     return NULL;
26506 }
26507
26508
26509 static PyObject *_wrap_PrintPreview_SetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
26510     PyObject *resultobj;
26511     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26512     int arg2 ;
26513     PyObject * obj0 = 0 ;
26514     PyObject * obj1 = 0 ;
26515     char *kwnames[] = {
26516         (char *) "self",(char *) "percent", NULL
26517     };
26518
26519     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetZoom",kwnames,&obj0,&obj1)) goto fail;
26520     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26521     if (SWIG_arg_fail(1)) SWIG_fail;
26522     {
26523         arg2 = (int)(SWIG_As_int(obj1));
26524         if (SWIG_arg_fail(2)) SWIG_fail;
26525     }
26526     {
26527         PyThreadState* __tstate = wxPyBeginAllowThreads();
26528         (arg1)->SetZoom(arg2);
26529
26530         wxPyEndAllowThreads(__tstate);
26531         if (PyErr_Occurred()) SWIG_fail;
26532     }
26533     Py_INCREF(Py_None); resultobj = Py_None;
26534     return resultobj;
26535     fail:
26536     return NULL;
26537 }
26538
26539
26540 static PyObject *_wrap_PrintPreview_GetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
26541     PyObject *resultobj;
26542     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26543     int result;
26544     PyObject * obj0 = 0 ;
26545     char *kwnames[] = {
26546         (char *) "self", NULL
26547     };
26548
26549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetZoom",kwnames,&obj0)) goto fail;
26550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26551     if (SWIG_arg_fail(1)) SWIG_fail;
26552     {
26553         PyThreadState* __tstate = wxPyBeginAllowThreads();
26554         result = (int)(arg1)->GetZoom();
26555
26556         wxPyEndAllowThreads(__tstate);
26557         if (PyErr_Occurred()) SWIG_fail;
26558     }
26559     {
26560         resultobj = SWIG_From_int((int)(result));
26561     }
26562     return resultobj;
26563     fail:
26564     return NULL;
26565 }
26566
26567
26568 static PyObject *_wrap_PrintPreview_GetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
26569     PyObject *resultobj;
26570     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26571     int result;
26572     PyObject * obj0 = 0 ;
26573     char *kwnames[] = {
26574         (char *) "self", NULL
26575     };
26576
26577     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetMaxPage",kwnames,&obj0)) goto fail;
26578     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26579     if (SWIG_arg_fail(1)) SWIG_fail;
26580     {
26581         PyThreadState* __tstate = wxPyBeginAllowThreads();
26582         result = (int)(arg1)->GetMaxPage();
26583
26584         wxPyEndAllowThreads(__tstate);
26585         if (PyErr_Occurred()) SWIG_fail;
26586     }
26587     {
26588         resultobj = SWIG_From_int((int)(result));
26589     }
26590     return resultobj;
26591     fail:
26592     return NULL;
26593 }
26594
26595
26596 static PyObject *_wrap_PrintPreview_GetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
26597     PyObject *resultobj;
26598     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26599     int result;
26600     PyObject * obj0 = 0 ;
26601     char *kwnames[] = {
26602         (char *) "self", NULL
26603     };
26604
26605     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetMinPage",kwnames,&obj0)) goto fail;
26606     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26607     if (SWIG_arg_fail(1)) SWIG_fail;
26608     {
26609         PyThreadState* __tstate = wxPyBeginAllowThreads();
26610         result = (int)(arg1)->GetMinPage();
26611
26612         wxPyEndAllowThreads(__tstate);
26613         if (PyErr_Occurred()) SWIG_fail;
26614     }
26615     {
26616         resultobj = SWIG_From_int((int)(result));
26617     }
26618     return resultobj;
26619     fail:
26620     return NULL;
26621 }
26622
26623
26624 static PyObject *_wrap_PrintPreview_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
26625     PyObject *resultobj;
26626     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26627     bool result;
26628     PyObject * obj0 = 0 ;
26629     char *kwnames[] = {
26630         (char *) "self", NULL
26631     };
26632
26633     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_Ok",kwnames,&obj0)) goto fail;
26634     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26635     if (SWIG_arg_fail(1)) SWIG_fail;
26636     {
26637         PyThreadState* __tstate = wxPyBeginAllowThreads();
26638         result = (bool)(arg1)->Ok();
26639
26640         wxPyEndAllowThreads(__tstate);
26641         if (PyErr_Occurred()) SWIG_fail;
26642     }
26643     {
26644         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26645     }
26646     return resultobj;
26647     fail:
26648     return NULL;
26649 }
26650
26651
26652 static PyObject *_wrap_PrintPreview_SetOk(PyObject *, PyObject *args, PyObject *kwargs) {
26653     PyObject *resultobj;
26654     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26655     bool arg2 ;
26656     PyObject * obj0 = 0 ;
26657     PyObject * obj1 = 0 ;
26658     char *kwnames[] = {
26659         (char *) "self",(char *) "ok", NULL
26660     };
26661
26662     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetOk",kwnames,&obj0,&obj1)) goto fail;
26663     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26664     if (SWIG_arg_fail(1)) SWIG_fail;
26665     {
26666         arg2 = (bool)(SWIG_As_bool(obj1));
26667         if (SWIG_arg_fail(2)) SWIG_fail;
26668     }
26669     {
26670         PyThreadState* __tstate = wxPyBeginAllowThreads();
26671         (arg1)->SetOk(arg2);
26672
26673         wxPyEndAllowThreads(__tstate);
26674         if (PyErr_Occurred()) SWIG_fail;
26675     }
26676     Py_INCREF(Py_None); resultobj = Py_None;
26677     return resultobj;
26678     fail:
26679     return NULL;
26680 }
26681
26682
26683 static PyObject *_wrap_PrintPreview_Print(PyObject *, PyObject *args, PyObject *kwargs) {
26684     PyObject *resultobj;
26685     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26686     bool arg2 ;
26687     bool result;
26688     PyObject * obj0 = 0 ;
26689     PyObject * obj1 = 0 ;
26690     char *kwnames[] = {
26691         (char *) "self",(char *) "interactive", NULL
26692     };
26693
26694     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_Print",kwnames,&obj0,&obj1)) goto fail;
26695     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26696     if (SWIG_arg_fail(1)) SWIG_fail;
26697     {
26698         arg2 = (bool)(SWIG_As_bool(obj1));
26699         if (SWIG_arg_fail(2)) SWIG_fail;
26700     }
26701     {
26702         PyThreadState* __tstate = wxPyBeginAllowThreads();
26703         result = (bool)(arg1)->Print(arg2);
26704
26705         wxPyEndAllowThreads(__tstate);
26706         if (PyErr_Occurred()) SWIG_fail;
26707     }
26708     {
26709         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26710     }
26711     return resultobj;
26712     fail:
26713     return NULL;
26714 }
26715
26716
26717 static PyObject *_wrap_PrintPreview_DetermineScaling(PyObject *, PyObject *args, PyObject *kwargs) {
26718     PyObject *resultobj;
26719     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26720     PyObject * obj0 = 0 ;
26721     char *kwnames[] = {
26722         (char *) "self", NULL
26723     };
26724
26725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_DetermineScaling",kwnames,&obj0)) goto fail;
26726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26727     if (SWIG_arg_fail(1)) SWIG_fail;
26728     {
26729         PyThreadState* __tstate = wxPyBeginAllowThreads();
26730         (arg1)->DetermineScaling();
26731
26732         wxPyEndAllowThreads(__tstate);
26733         if (PyErr_Occurred()) SWIG_fail;
26734     }
26735     Py_INCREF(Py_None); resultobj = Py_None;
26736     return resultobj;
26737     fail:
26738     return NULL;
26739 }
26740
26741
26742 static PyObject * PrintPreview_swigregister(PyObject *, PyObject *args) {
26743     PyObject *obj;
26744     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26745     SWIG_TypeClientData(SWIGTYPE_p_wxPrintPreview, obj);
26746     Py_INCREF(obj);
26747     return Py_BuildValue((char *)"");
26748 }
26749 static PyObject *_wrap_new_PyPrintPreview__SWIG_0(PyObject *, PyObject *args) {
26750     PyObject *resultobj;
26751     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26752     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26753     wxPrintDialogData *arg3 = (wxPrintDialogData *) NULL ;
26754     wxPyPrintPreview *result;
26755     PyObject * obj0 = 0 ;
26756     PyObject * obj1 = 0 ;
26757     PyObject * obj2 = 0 ;
26758
26759     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_PyPrintPreview",&obj0,&obj1,&obj2)) goto fail;
26760     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26761     if (SWIG_arg_fail(1)) SWIG_fail;
26762     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26763     if (SWIG_arg_fail(2)) SWIG_fail;
26764     if (obj2) {
26765         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
26766         if (SWIG_arg_fail(3)) SWIG_fail;
26767     }
26768     {
26769         if (!wxPyCheckForApp()) SWIG_fail;
26770         PyThreadState* __tstate = wxPyBeginAllowThreads();
26771         result = (wxPyPrintPreview *)new wxPyPrintPreview(arg1,arg2,arg3);
26772
26773         wxPyEndAllowThreads(__tstate);
26774         if (PyErr_Occurred()) SWIG_fail;
26775     }
26776     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPrintPreview, 1);
26777     return resultobj;
26778     fail:
26779     return NULL;
26780 }
26781
26782
26783 static PyObject *_wrap_new_PyPrintPreview__SWIG_1(PyObject *, PyObject *args) {
26784     PyObject *resultobj;
26785     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26786     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26787     wxPrintData *arg3 = (wxPrintData *) 0 ;
26788     wxPyPrintPreview *result;
26789     PyObject * obj0 = 0 ;
26790     PyObject * obj1 = 0 ;
26791     PyObject * obj2 = 0 ;
26792
26793     if(!PyArg_ParseTuple(args,(char *)"OOO:new_PyPrintPreview",&obj0,&obj1,&obj2)) goto fail;
26794     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26795     if (SWIG_arg_fail(1)) SWIG_fail;
26796     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26797     if (SWIG_arg_fail(2)) SWIG_fail;
26798     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
26799     if (SWIG_arg_fail(3)) SWIG_fail;
26800     {
26801         if (!wxPyCheckForApp()) SWIG_fail;
26802         PyThreadState* __tstate = wxPyBeginAllowThreads();
26803         result = (wxPyPrintPreview *)new wxPyPrintPreview(arg1,arg2,arg3);
26804
26805         wxPyEndAllowThreads(__tstate);
26806         if (PyErr_Occurred()) SWIG_fail;
26807     }
26808     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPrintPreview, 1);
26809     return resultobj;
26810     fail:
26811     return NULL;
26812 }
26813
26814
26815 static PyObject *_wrap_new_PyPrintPreview(PyObject *self, PyObject *args) {
26816     int argc;
26817     PyObject *argv[4];
26818     int ii;
26819
26820     argc = PyObject_Length(args);
26821     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
26822         argv[ii] = PyTuple_GetItem(args,ii);
26823     }
26824     if ((argc >= 2) && (argc <= 3)) {
26825         int _v;
26826         {
26827             void *ptr;
26828             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26829                 _v = 0;
26830                 PyErr_Clear();
26831             } else {
26832                 _v = 1;
26833             }
26834         }
26835         if (_v) {
26836             {
26837                 void *ptr;
26838                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26839                     _v = 0;
26840                     PyErr_Clear();
26841                 } else {
26842                     _v = 1;
26843                 }
26844             }
26845             if (_v) {
26846                 if (argc <= 2) {
26847                     return _wrap_new_PyPrintPreview__SWIG_0(self,args);
26848                 }
26849                 {
26850                     void *ptr;
26851                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
26852                         _v = 0;
26853                         PyErr_Clear();
26854                     } else {
26855                         _v = 1;
26856                     }
26857                 }
26858                 if (_v) {
26859                     return _wrap_new_PyPrintPreview__SWIG_0(self,args);
26860                 }
26861             }
26862         }
26863     }
26864     if (argc == 3) {
26865         int _v;
26866         {
26867             void *ptr;
26868             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26869                 _v = 0;
26870                 PyErr_Clear();
26871             } else {
26872                 _v = 1;
26873             }
26874         }
26875         if (_v) {
26876             {
26877                 void *ptr;
26878                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26879                     _v = 0;
26880                     PyErr_Clear();
26881                 } else {
26882                     _v = 1;
26883                 }
26884             }
26885             if (_v) {
26886                 {
26887                     void *ptr;
26888                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
26889                         _v = 0;
26890                         PyErr_Clear();
26891                     } else {
26892                         _v = 1;
26893                     }
26894                 }
26895                 if (_v) {
26896                     return _wrap_new_PyPrintPreview__SWIG_1(self,args);
26897                 }
26898             }
26899         }
26900     }
26901
26902     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PyPrintPreview'");
26903     return NULL;
26904 }
26905
26906
26907 static PyObject *_wrap_PyPrintPreview__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
26908     PyObject *resultobj;
26909     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
26910     PyObject *arg2 = (PyObject *) 0 ;
26911     PyObject *arg3 = (PyObject *) 0 ;
26912     PyObject * obj0 = 0 ;
26913     PyObject * obj1 = 0 ;
26914     PyObject * obj2 = 0 ;
26915     char *kwnames[] = {
26916         (char *) "self",(char *) "self",(char *) "_class", NULL
26917     };
26918
26919     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
26920     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26921     if (SWIG_arg_fail(1)) SWIG_fail;
26922     arg2 = obj1;
26923     arg3 = obj2;
26924     {
26925         PyThreadState* __tstate = wxPyBeginAllowThreads();
26926         (arg1)->_setCallbackInfo(arg2,arg3);
26927
26928         wxPyEndAllowThreads(__tstate);
26929         if (PyErr_Occurred()) SWIG_fail;
26930     }
26931     Py_INCREF(Py_None); resultobj = Py_None;
26932     return resultobj;
26933     fail:
26934     return NULL;
26935 }
26936
26937
26938 static PyObject *_wrap_PyPrintPreview_base_SetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26939     PyObject *resultobj;
26940     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
26941     int arg2 ;
26942     bool result;
26943     PyObject * obj0 = 0 ;
26944     PyObject * obj1 = 0 ;
26945     char *kwnames[] = {
26946         (char *) "self",(char *) "pageNum", NULL
26947     };
26948
26949     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_SetCurrentPage",kwnames,&obj0,&obj1)) goto fail;
26950     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26951     if (SWIG_arg_fail(1)) SWIG_fail;
26952     {
26953         arg2 = (int)(SWIG_As_int(obj1));
26954         if (SWIG_arg_fail(2)) SWIG_fail;
26955     }
26956     {
26957         PyThreadState* __tstate = wxPyBeginAllowThreads();
26958         result = (bool)(arg1)->base_SetCurrentPage(arg2);
26959
26960         wxPyEndAllowThreads(__tstate);
26961         if (PyErr_Occurred()) SWIG_fail;
26962     }
26963     {
26964         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26965     }
26966     return resultobj;
26967     fail:
26968     return NULL;
26969 }
26970
26971
26972 static PyObject *_wrap_PyPrintPreview_base_PaintPage(PyObject *, PyObject *args, PyObject *kwargs) {
26973     PyObject *resultobj;
26974     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
26975     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26976     wxDC *arg3 = 0 ;
26977     bool result;
26978     PyObject * obj0 = 0 ;
26979     PyObject * obj1 = 0 ;
26980     PyObject * obj2 = 0 ;
26981     char *kwnames[] = {
26982         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26983     };
26984
26985     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview_base_PaintPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26986     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26987     if (SWIG_arg_fail(1)) SWIG_fail;
26988     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26989     if (SWIG_arg_fail(2)) SWIG_fail;
26990     {
26991         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26992         if (SWIG_arg_fail(3)) SWIG_fail;
26993         if (arg3 == NULL) {
26994             SWIG_null_ref("wxDC");
26995         }
26996         if (SWIG_arg_fail(3)) SWIG_fail;
26997     }
26998     {
26999         PyThreadState* __tstate = wxPyBeginAllowThreads();
27000         result = (bool)(arg1)->base_PaintPage(arg2,*arg3);
27001
27002         wxPyEndAllowThreads(__tstate);
27003         if (PyErr_Occurred()) SWIG_fail;
27004     }
27005     {
27006         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27007     }
27008     return resultobj;
27009     fail:
27010     return NULL;
27011 }
27012
27013
27014 static PyObject *_wrap_PyPrintPreview_base_DrawBlankPage(PyObject *, PyObject *args, PyObject *kwargs) {
27015     PyObject *resultobj;
27016     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27017     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27018     wxDC *arg3 = 0 ;
27019     bool result;
27020     PyObject * obj0 = 0 ;
27021     PyObject * obj1 = 0 ;
27022     PyObject * obj2 = 0 ;
27023     char *kwnames[] = {
27024         (char *) "self",(char *) "canvas",(char *) "dc", NULL
27025     };
27026
27027     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview_base_DrawBlankPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
27028     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27029     if (SWIG_arg_fail(1)) SWIG_fail;
27030     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27031     if (SWIG_arg_fail(2)) SWIG_fail;
27032     {
27033         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
27034         if (SWIG_arg_fail(3)) SWIG_fail;
27035         if (arg3 == NULL) {
27036             SWIG_null_ref("wxDC");
27037         }
27038         if (SWIG_arg_fail(3)) SWIG_fail;
27039     }
27040     {
27041         PyThreadState* __tstate = wxPyBeginAllowThreads();
27042         result = (bool)(arg1)->base_DrawBlankPage(arg2,*arg3);
27043
27044         wxPyEndAllowThreads(__tstate);
27045         if (PyErr_Occurred()) SWIG_fail;
27046     }
27047     {
27048         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27049     }
27050     return resultobj;
27051     fail:
27052     return NULL;
27053 }
27054
27055
27056 static PyObject *_wrap_PyPrintPreview_base_RenderPage(PyObject *, PyObject *args, PyObject *kwargs) {
27057     PyObject *resultobj;
27058     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27059     int arg2 ;
27060     bool result;
27061     PyObject * obj0 = 0 ;
27062     PyObject * obj1 = 0 ;
27063     char *kwnames[] = {
27064         (char *) "self",(char *) "pageNum", NULL
27065     };
27066
27067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_RenderPage",kwnames,&obj0,&obj1)) goto fail;
27068     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27069     if (SWIG_arg_fail(1)) SWIG_fail;
27070     {
27071         arg2 = (int)(SWIG_As_int(obj1));
27072         if (SWIG_arg_fail(2)) SWIG_fail;
27073     }
27074     {
27075         PyThreadState* __tstate = wxPyBeginAllowThreads();
27076         result = (bool)(arg1)->base_RenderPage(arg2);
27077
27078         wxPyEndAllowThreads(__tstate);
27079         if (PyErr_Occurred()) SWIG_fail;
27080     }
27081     {
27082         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27083     }
27084     return resultobj;
27085     fail:
27086     return NULL;
27087 }
27088
27089
27090 static PyObject *_wrap_PyPrintPreview_base_SetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
27091     PyObject *resultobj;
27092     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27093     int arg2 ;
27094     PyObject * obj0 = 0 ;
27095     PyObject * obj1 = 0 ;
27096     char *kwnames[] = {
27097         (char *) "self",(char *) "percent", NULL
27098     };
27099
27100     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_SetZoom",kwnames,&obj0,&obj1)) goto fail;
27101     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27102     if (SWIG_arg_fail(1)) SWIG_fail;
27103     {
27104         arg2 = (int)(SWIG_As_int(obj1));
27105         if (SWIG_arg_fail(2)) SWIG_fail;
27106     }
27107     {
27108         PyThreadState* __tstate = wxPyBeginAllowThreads();
27109         (arg1)->base_SetZoom(arg2);
27110
27111         wxPyEndAllowThreads(__tstate);
27112         if (PyErr_Occurred()) SWIG_fail;
27113     }
27114     Py_INCREF(Py_None); resultobj = Py_None;
27115     return resultobj;
27116     fail:
27117     return NULL;
27118 }
27119
27120
27121 static PyObject *_wrap_PyPrintPreview_base_Print(PyObject *, PyObject *args, PyObject *kwargs) {
27122     PyObject *resultobj;
27123     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27124     bool arg2 ;
27125     bool result;
27126     PyObject * obj0 = 0 ;
27127     PyObject * obj1 = 0 ;
27128     char *kwnames[] = {
27129         (char *) "self",(char *) "interactive", NULL
27130     };
27131
27132     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_Print",kwnames,&obj0,&obj1)) goto fail;
27133     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27134     if (SWIG_arg_fail(1)) SWIG_fail;
27135     {
27136         arg2 = (bool)(SWIG_As_bool(obj1));
27137         if (SWIG_arg_fail(2)) SWIG_fail;
27138     }
27139     {
27140         PyThreadState* __tstate = wxPyBeginAllowThreads();
27141         result = (bool)(arg1)->base_Print(arg2);
27142
27143         wxPyEndAllowThreads(__tstate);
27144         if (PyErr_Occurred()) SWIG_fail;
27145     }
27146     {
27147         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27148     }
27149     return resultobj;
27150     fail:
27151     return NULL;
27152 }
27153
27154
27155 static PyObject *_wrap_PyPrintPreview_base_DetermineScaling(PyObject *, PyObject *args, PyObject *kwargs) {
27156     PyObject *resultobj;
27157     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27158     PyObject * obj0 = 0 ;
27159     char *kwnames[] = {
27160         (char *) "self", NULL
27161     };
27162
27163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPrintPreview_base_DetermineScaling",kwnames,&obj0)) goto fail;
27164     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27165     if (SWIG_arg_fail(1)) SWIG_fail;
27166     {
27167         PyThreadState* __tstate = wxPyBeginAllowThreads();
27168         (arg1)->base_DetermineScaling();
27169
27170         wxPyEndAllowThreads(__tstate);
27171         if (PyErr_Occurred()) SWIG_fail;
27172     }
27173     Py_INCREF(Py_None); resultobj = Py_None;
27174     return resultobj;
27175     fail:
27176     return NULL;
27177 }
27178
27179
27180 static PyObject * PyPrintPreview_swigregister(PyObject *, PyObject *args) {
27181     PyObject *obj;
27182     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27183     SWIG_TypeClientData(SWIGTYPE_p_wxPyPrintPreview, obj);
27184     Py_INCREF(obj);
27185     return Py_BuildValue((char *)"");
27186 }
27187 static PyObject *_wrap_new_PyPreviewFrame(PyObject *, PyObject *args, PyObject *kwargs) {
27188     PyObject *resultobj;
27189     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
27190     wxFrame *arg2 = (wxFrame *) 0 ;
27191     wxString *arg3 = 0 ;
27192     wxPoint const &arg4_defvalue = wxDefaultPosition ;
27193     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
27194     wxSize const &arg5_defvalue = wxDefaultSize ;
27195     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
27196     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
27197     wxString const &arg7_defvalue = wxPyFrameNameStr ;
27198     wxString *arg7 = (wxString *) &arg7_defvalue ;
27199     wxPyPreviewFrame *result;
27200     bool temp3 = false ;
27201     wxPoint temp4 ;
27202     wxSize temp5 ;
27203     bool temp7 = false ;
27204     PyObject * obj0 = 0 ;
27205     PyObject * obj1 = 0 ;
27206     PyObject * obj2 = 0 ;
27207     PyObject * obj3 = 0 ;
27208     PyObject * obj4 = 0 ;
27209     PyObject * obj5 = 0 ;
27210     PyObject * obj6 = 0 ;
27211     char *kwnames[] = {
27212         (char *) "preview",(char *) "parent",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
27213     };
27214
27215     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PyPreviewFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27216     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27217     if (SWIG_arg_fail(1)) SWIG_fail;
27218     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
27219     if (SWIG_arg_fail(2)) SWIG_fail;
27220     {
27221         arg3 = wxString_in_helper(obj2);
27222         if (arg3 == NULL) SWIG_fail;
27223         temp3 = true;
27224     }
27225     if (obj3) {
27226         {
27227             arg4 = &temp4;
27228             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
27229         }
27230     }
27231     if (obj4) {
27232         {
27233             arg5 = &temp5;
27234             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
27235         }
27236     }
27237     if (obj5) {
27238         {
27239             arg6 = (long)(SWIG_As_long(obj5));
27240             if (SWIG_arg_fail(6)) SWIG_fail;
27241         }
27242     }
27243     if (obj6) {
27244         {
27245             arg7 = wxString_in_helper(obj6);
27246             if (arg7 == NULL) SWIG_fail;
27247             temp7 = true;
27248         }
27249     }
27250     {
27251         if (!wxPyCheckForApp()) SWIG_fail;
27252         PyThreadState* __tstate = wxPyBeginAllowThreads();
27253         result = (wxPyPreviewFrame *)new wxPyPreviewFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
27254
27255         wxPyEndAllowThreads(__tstate);
27256         if (PyErr_Occurred()) SWIG_fail;
27257     }
27258     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPreviewFrame, 1);
27259     {
27260         if (temp3)
27261         delete arg3;
27262     }
27263     {
27264         if (temp7)
27265         delete arg7;
27266     }
27267     return resultobj;
27268     fail:
27269     {
27270         if (temp3)
27271         delete arg3;
27272     }
27273     {
27274         if (temp7)
27275         delete arg7;
27276     }
27277     return NULL;
27278 }
27279
27280
27281 static PyObject *_wrap_PyPreviewFrame__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27282     PyObject *resultobj;
27283     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27284     PyObject *arg2 = (PyObject *) 0 ;
27285     PyObject *arg3 = (PyObject *) 0 ;
27286     PyObject * obj0 = 0 ;
27287     PyObject * obj1 = 0 ;
27288     PyObject * obj2 = 0 ;
27289     char *kwnames[] = {
27290         (char *) "self",(char *) "self",(char *) "_class", NULL
27291     };
27292
27293     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPreviewFrame__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27294     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27295     if (SWIG_arg_fail(1)) SWIG_fail;
27296     arg2 = obj1;
27297     arg3 = obj2;
27298     {
27299         PyThreadState* __tstate = wxPyBeginAllowThreads();
27300         (arg1)->_setCallbackInfo(arg2,arg3);
27301
27302         wxPyEndAllowThreads(__tstate);
27303         if (PyErr_Occurred()) SWIG_fail;
27304     }
27305     Py_INCREF(Py_None); resultobj = Py_None;
27306     return resultobj;
27307     fail:
27308     return NULL;
27309 }
27310
27311
27312 static PyObject *_wrap_PyPreviewFrame_SetPreviewCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
27313     PyObject *resultobj;
27314     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27315     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27316     PyObject * obj0 = 0 ;
27317     PyObject * obj1 = 0 ;
27318     char *kwnames[] = {
27319         (char *) "self",(char *) "canvas", NULL
27320     };
27321
27322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewFrame_SetPreviewCanvas",kwnames,&obj0,&obj1)) goto fail;
27323     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27324     if (SWIG_arg_fail(1)) SWIG_fail;
27325     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27326     if (SWIG_arg_fail(2)) SWIG_fail;
27327     {
27328         PyThreadState* __tstate = wxPyBeginAllowThreads();
27329         (arg1)->SetPreviewCanvas(arg2);
27330
27331         wxPyEndAllowThreads(__tstate);
27332         if (PyErr_Occurred()) SWIG_fail;
27333     }
27334     Py_INCREF(Py_None); resultobj = Py_None;
27335     return resultobj;
27336     fail:
27337     return NULL;
27338 }
27339
27340
27341 static PyObject *_wrap_PyPreviewFrame_SetControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27342     PyObject *resultobj;
27343     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27344     wxPreviewControlBar *arg2 = (wxPreviewControlBar *) 0 ;
27345     PyObject * obj0 = 0 ;
27346     PyObject * obj1 = 0 ;
27347     char *kwnames[] = {
27348         (char *) "self",(char *) "bar", NULL
27349     };
27350
27351     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewFrame_SetControlBar",kwnames,&obj0,&obj1)) goto fail;
27352     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27353     if (SWIG_arg_fail(1)) SWIG_fail;
27354     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27355     if (SWIG_arg_fail(2)) SWIG_fail;
27356     {
27357         PyThreadState* __tstate = wxPyBeginAllowThreads();
27358         (arg1)->SetControlBar(arg2);
27359
27360         wxPyEndAllowThreads(__tstate);
27361         if (PyErr_Occurred()) SWIG_fail;
27362     }
27363     Py_INCREF(Py_None); resultobj = Py_None;
27364     return resultobj;
27365     fail:
27366     return NULL;
27367 }
27368
27369
27370 static PyObject *_wrap_PyPreviewFrame_base_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
27371     PyObject *resultobj;
27372     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27373     PyObject * obj0 = 0 ;
27374     char *kwnames[] = {
27375         (char *) "self", NULL
27376     };
27377
27378     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_Initialize",kwnames,&obj0)) goto fail;
27379     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27380     if (SWIG_arg_fail(1)) SWIG_fail;
27381     {
27382         PyThreadState* __tstate = wxPyBeginAllowThreads();
27383         (arg1)->base_Initialize();
27384
27385         wxPyEndAllowThreads(__tstate);
27386         if (PyErr_Occurred()) SWIG_fail;
27387     }
27388     Py_INCREF(Py_None); resultobj = Py_None;
27389     return resultobj;
27390     fail:
27391     return NULL;
27392 }
27393
27394
27395 static PyObject *_wrap_PyPreviewFrame_base_CreateCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
27396     PyObject *resultobj;
27397     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27398     PyObject * obj0 = 0 ;
27399     char *kwnames[] = {
27400         (char *) "self", NULL
27401     };
27402
27403     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_CreateCanvas",kwnames,&obj0)) goto fail;
27404     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27405     if (SWIG_arg_fail(1)) SWIG_fail;
27406     {
27407         PyThreadState* __tstate = wxPyBeginAllowThreads();
27408         (arg1)->base_CreateCanvas();
27409
27410         wxPyEndAllowThreads(__tstate);
27411         if (PyErr_Occurred()) SWIG_fail;
27412     }
27413     Py_INCREF(Py_None); resultobj = Py_None;
27414     return resultobj;
27415     fail:
27416     return NULL;
27417 }
27418
27419
27420 static PyObject *_wrap_PyPreviewFrame_base_CreateControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27421     PyObject *resultobj;
27422     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27423     PyObject * obj0 = 0 ;
27424     char *kwnames[] = {
27425         (char *) "self", NULL
27426     };
27427
27428     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_CreateControlBar",kwnames,&obj0)) goto fail;
27429     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27430     if (SWIG_arg_fail(1)) SWIG_fail;
27431     {
27432         PyThreadState* __tstate = wxPyBeginAllowThreads();
27433         (arg1)->base_CreateControlBar();
27434
27435         wxPyEndAllowThreads(__tstate);
27436         if (PyErr_Occurred()) SWIG_fail;
27437     }
27438     Py_INCREF(Py_None); resultobj = Py_None;
27439     return resultobj;
27440     fail:
27441     return NULL;
27442 }
27443
27444
27445 static PyObject * PyPreviewFrame_swigregister(PyObject *, PyObject *args) {
27446     PyObject *obj;
27447     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27448     SWIG_TypeClientData(SWIGTYPE_p_wxPyPreviewFrame, obj);
27449     Py_INCREF(obj);
27450     return Py_BuildValue((char *)"");
27451 }
27452 static PyObject *_wrap_new_PyPreviewControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27453     PyObject *resultobj;
27454     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
27455     long arg2 ;
27456     wxWindow *arg3 = (wxWindow *) 0 ;
27457     wxPoint const &arg4_defvalue = wxDefaultPosition ;
27458     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
27459     wxSize const &arg5_defvalue = wxDefaultSize ;
27460     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
27461     long arg6 = (long) 0 ;
27462     wxString const &arg7_defvalue = wxPyPanelNameStr ;
27463     wxString *arg7 = (wxString *) &arg7_defvalue ;
27464     wxPyPreviewControlBar *result;
27465     wxPoint temp4 ;
27466     wxSize temp5 ;
27467     bool temp7 = false ;
27468     PyObject * obj0 = 0 ;
27469     PyObject * obj1 = 0 ;
27470     PyObject * obj2 = 0 ;
27471     PyObject * obj3 = 0 ;
27472     PyObject * obj4 = 0 ;
27473     PyObject * obj5 = 0 ;
27474     PyObject * obj6 = 0 ;
27475     char *kwnames[] = {
27476         (char *) "preview",(char *) "buttons",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
27477     };
27478
27479     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PyPreviewControlBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27480     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27481     if (SWIG_arg_fail(1)) SWIG_fail;
27482     {
27483         arg2 = (long)(SWIG_As_long(obj1));
27484         if (SWIG_arg_fail(2)) SWIG_fail;
27485     }
27486     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27487     if (SWIG_arg_fail(3)) SWIG_fail;
27488     if (obj3) {
27489         {
27490             arg4 = &temp4;
27491             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
27492         }
27493     }
27494     if (obj4) {
27495         {
27496             arg5 = &temp5;
27497             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
27498         }
27499     }
27500     if (obj5) {
27501         {
27502             arg6 = (long)(SWIG_As_long(obj5));
27503             if (SWIG_arg_fail(6)) SWIG_fail;
27504         }
27505     }
27506     if (obj6) {
27507         {
27508             arg7 = wxString_in_helper(obj6);
27509             if (arg7 == NULL) SWIG_fail;
27510             temp7 = true;
27511         }
27512     }
27513     {
27514         if (!wxPyCheckForApp()) SWIG_fail;
27515         PyThreadState* __tstate = wxPyBeginAllowThreads();
27516         result = (wxPyPreviewControlBar *)new wxPyPreviewControlBar(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
27517
27518         wxPyEndAllowThreads(__tstate);
27519         if (PyErr_Occurred()) SWIG_fail;
27520     }
27521     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPreviewControlBar, 1);
27522     {
27523         if (temp7)
27524         delete arg7;
27525     }
27526     return resultobj;
27527     fail:
27528     {
27529         if (temp7)
27530         delete arg7;
27531     }
27532     return NULL;
27533 }
27534
27535
27536 static PyObject *_wrap_PyPreviewControlBar__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27537     PyObject *resultobj;
27538     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27539     PyObject *arg2 = (PyObject *) 0 ;
27540     PyObject *arg3 = (PyObject *) 0 ;
27541     PyObject * obj0 = 0 ;
27542     PyObject * obj1 = 0 ;
27543     PyObject * obj2 = 0 ;
27544     char *kwnames[] = {
27545         (char *) "self",(char *) "self",(char *) "_class", NULL
27546     };
27547
27548     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPreviewControlBar__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27549     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27550     if (SWIG_arg_fail(1)) SWIG_fail;
27551     arg2 = obj1;
27552     arg3 = obj2;
27553     {
27554         PyThreadState* __tstate = wxPyBeginAllowThreads();
27555         (arg1)->_setCallbackInfo(arg2,arg3);
27556
27557         wxPyEndAllowThreads(__tstate);
27558         if (PyErr_Occurred()) SWIG_fail;
27559     }
27560     Py_INCREF(Py_None); resultobj = Py_None;
27561     return resultobj;
27562     fail:
27563     return NULL;
27564 }
27565
27566
27567 static PyObject *_wrap_PyPreviewControlBar_SetPrintPreview(PyObject *, PyObject *args, PyObject *kwargs) {
27568     PyObject *resultobj;
27569     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27570     wxPrintPreview *arg2 = (wxPrintPreview *) 0 ;
27571     PyObject * obj0 = 0 ;
27572     PyObject * obj1 = 0 ;
27573     char *kwnames[] = {
27574         (char *) "self",(char *) "preview", NULL
27575     };
27576
27577     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewControlBar_SetPrintPreview",kwnames,&obj0,&obj1)) goto fail;
27578     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27579     if (SWIG_arg_fail(1)) SWIG_fail;
27580     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27581     if (SWIG_arg_fail(2)) SWIG_fail;
27582     {
27583         PyThreadState* __tstate = wxPyBeginAllowThreads();
27584         (arg1)->SetPrintPreview(arg2);
27585
27586         wxPyEndAllowThreads(__tstate);
27587         if (PyErr_Occurred()) SWIG_fail;
27588     }
27589     Py_INCREF(Py_None); resultobj = Py_None;
27590     return resultobj;
27591     fail:
27592     return NULL;
27593 }
27594
27595
27596 static PyObject *_wrap_PyPreviewControlBar_base_CreateButtons(PyObject *, PyObject *args, PyObject *kwargs) {
27597     PyObject *resultobj;
27598     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27599     PyObject * obj0 = 0 ;
27600     char *kwnames[] = {
27601         (char *) "self", NULL
27602     };
27603
27604     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewControlBar_base_CreateButtons",kwnames,&obj0)) goto fail;
27605     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27606     if (SWIG_arg_fail(1)) SWIG_fail;
27607     {
27608         PyThreadState* __tstate = wxPyBeginAllowThreads();
27609         (arg1)->base_CreateButtons();
27610
27611         wxPyEndAllowThreads(__tstate);
27612         if (PyErr_Occurred()) SWIG_fail;
27613     }
27614     Py_INCREF(Py_None); resultobj = Py_None;
27615     return resultobj;
27616     fail:
27617     return NULL;
27618 }
27619
27620
27621 static PyObject *_wrap_PyPreviewControlBar_base_SetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
27622     PyObject *resultobj;
27623     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27624     int arg2 ;
27625     PyObject * obj0 = 0 ;
27626     PyObject * obj1 = 0 ;
27627     char *kwnames[] = {
27628         (char *) "self",(char *) "zoom", NULL
27629     };
27630
27631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewControlBar_base_SetZoomControl",kwnames,&obj0,&obj1)) goto fail;
27632     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27633     if (SWIG_arg_fail(1)) SWIG_fail;
27634     {
27635         arg2 = (int)(SWIG_As_int(obj1));
27636         if (SWIG_arg_fail(2)) SWIG_fail;
27637     }
27638     {
27639         PyThreadState* __tstate = wxPyBeginAllowThreads();
27640         (arg1)->base_SetZoomControl(arg2);
27641
27642         wxPyEndAllowThreads(__tstate);
27643         if (PyErr_Occurred()) SWIG_fail;
27644     }
27645     Py_INCREF(Py_None); resultobj = Py_None;
27646     return resultobj;
27647     fail:
27648     return NULL;
27649 }
27650
27651
27652 static PyObject * PyPreviewControlBar_swigregister(PyObject *, PyObject *args) {
27653     PyObject *obj;
27654     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27655     SWIG_TypeClientData(SWIGTYPE_p_wxPyPreviewControlBar, obj);
27656     Py_INCREF(obj);
27657     return Py_BuildValue((char *)"");
27658 }
27659 static PyMethodDef SwigMethods[] = {
27660          { (char *)"new_Panel", (PyCFunction) _wrap_new_Panel, METH_VARARGS | METH_KEYWORDS, NULL},
27661          { (char *)"new_PrePanel", (PyCFunction) _wrap_new_PrePanel, METH_VARARGS | METH_KEYWORDS, NULL},
27662          { (char *)"Panel_Create", (PyCFunction) _wrap_Panel_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27663          { (char *)"Panel_InitDialog", (PyCFunction) _wrap_Panel_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27664          { (char *)"Panel_SetFocus", (PyCFunction) _wrap_Panel_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
27665          { (char *)"Panel_SetFocusIgnoringChildren", (PyCFunction) _wrap_Panel_SetFocusIgnoringChildren, METH_VARARGS | METH_KEYWORDS, NULL},
27666          { (char *)"Panel_GetClassDefaultAttributes", (PyCFunction) _wrap_Panel_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27667          { (char *)"Panel_swigregister", Panel_swigregister, METH_VARARGS, NULL},
27668          { (char *)"new_ScrolledWindow", (PyCFunction) _wrap_new_ScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27669          { (char *)"new_PreScrolledWindow", (PyCFunction) _wrap_new_PreScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27670          { (char *)"ScrolledWindow_Create", (PyCFunction) _wrap_ScrolledWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27671          { (char *)"ScrolledWindow_SetScrollbars", (PyCFunction) _wrap_ScrolledWindow_SetScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
27672          { (char *)"ScrolledWindow_Scroll", (PyCFunction) _wrap_ScrolledWindow_Scroll, METH_VARARGS | METH_KEYWORDS, NULL},
27673          { (char *)"ScrolledWindow_GetScrollPageSize", (PyCFunction) _wrap_ScrolledWindow_GetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
27674          { (char *)"ScrolledWindow_SetScrollPageSize", (PyCFunction) _wrap_ScrolledWindow_SetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
27675          { (char *)"ScrolledWindow_SetScrollRate", (PyCFunction) _wrap_ScrolledWindow_SetScrollRate, METH_VARARGS | METH_KEYWORDS, NULL},
27676          { (char *)"ScrolledWindow_GetScrollPixelsPerUnit", (PyCFunction) _wrap_ScrolledWindow_GetScrollPixelsPerUnit, METH_VARARGS | METH_KEYWORDS, NULL},
27677          { (char *)"ScrolledWindow_EnableScrolling", (PyCFunction) _wrap_ScrolledWindow_EnableScrolling, METH_VARARGS | METH_KEYWORDS, NULL},
27678          { (char *)"ScrolledWindow_GetViewStart", (PyCFunction) _wrap_ScrolledWindow_GetViewStart, METH_VARARGS | METH_KEYWORDS, NULL},
27679          { (char *)"ScrolledWindow_SetScale", (PyCFunction) _wrap_ScrolledWindow_SetScale, METH_VARARGS | METH_KEYWORDS, NULL},
27680          { (char *)"ScrolledWindow_GetScaleX", (PyCFunction) _wrap_ScrolledWindow_GetScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
27681          { (char *)"ScrolledWindow_GetScaleY", (PyCFunction) _wrap_ScrolledWindow_GetScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
27682          { (char *)"ScrolledWindow_CalcScrolledPosition", _wrap_ScrolledWindow_CalcScrolledPosition, METH_VARARGS, NULL},
27683          { (char *)"ScrolledWindow_CalcUnscrolledPosition", _wrap_ScrolledWindow_CalcUnscrolledPosition, METH_VARARGS, NULL},
27684          { (char *)"ScrolledWindow_AdjustScrollbars", (PyCFunction) _wrap_ScrolledWindow_AdjustScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
27685          { (char *)"ScrolledWindow_CalcScrollInc", (PyCFunction) _wrap_ScrolledWindow_CalcScrollInc, METH_VARARGS | METH_KEYWORDS, NULL},
27686          { (char *)"ScrolledWindow_SetTargetWindow", (PyCFunction) _wrap_ScrolledWindow_SetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27687          { (char *)"ScrolledWindow_GetTargetWindow", (PyCFunction) _wrap_ScrolledWindow_GetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27688          { (char *)"ScrolledWindow_DoPrepareDC", (PyCFunction) _wrap_ScrolledWindow_DoPrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
27689          { (char *)"ScrolledWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_ScrolledWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27690          { (char *)"ScrolledWindow_swigregister", ScrolledWindow_swigregister, METH_VARARGS, NULL},
27691          { (char *)"TopLevelWindow_Maximize", (PyCFunction) _wrap_TopLevelWindow_Maximize, METH_VARARGS | METH_KEYWORDS, NULL},
27692          { (char *)"TopLevelWindow_Restore", (PyCFunction) _wrap_TopLevelWindow_Restore, METH_VARARGS | METH_KEYWORDS, NULL},
27693          { (char *)"TopLevelWindow_Iconize", (PyCFunction) _wrap_TopLevelWindow_Iconize, METH_VARARGS | METH_KEYWORDS, NULL},
27694          { (char *)"TopLevelWindow_IsMaximized", (PyCFunction) _wrap_TopLevelWindow_IsMaximized, METH_VARARGS | METH_KEYWORDS, NULL},
27695          { (char *)"TopLevelWindow_IsIconized", (PyCFunction) _wrap_TopLevelWindow_IsIconized, METH_VARARGS | METH_KEYWORDS, NULL},
27696          { (char *)"TopLevelWindow_GetIcon", (PyCFunction) _wrap_TopLevelWindow_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27697          { (char *)"TopLevelWindow_SetIcon", (PyCFunction) _wrap_TopLevelWindow_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27698          { (char *)"TopLevelWindow_SetIcons", (PyCFunction) _wrap_TopLevelWindow_SetIcons, METH_VARARGS | METH_KEYWORDS, NULL},
27699          { (char *)"TopLevelWindow_ShowFullScreen", (PyCFunction) _wrap_TopLevelWindow_ShowFullScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27700          { (char *)"TopLevelWindow_IsFullScreen", (PyCFunction) _wrap_TopLevelWindow_IsFullScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27701          { (char *)"TopLevelWindow_SetTitle", (PyCFunction) _wrap_TopLevelWindow_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
27702          { (char *)"TopLevelWindow_GetTitle", (PyCFunction) _wrap_TopLevelWindow_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
27703          { (char *)"TopLevelWindow_SetShape", (PyCFunction) _wrap_TopLevelWindow_SetShape, METH_VARARGS | METH_KEYWORDS, NULL},
27704          { (char *)"TopLevelWindow_RequestUserAttention", (PyCFunction) _wrap_TopLevelWindow_RequestUserAttention, METH_VARARGS | METH_KEYWORDS, NULL},
27705          { (char *)"TopLevelWindow_IsActive", (PyCFunction) _wrap_TopLevelWindow_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
27706          { (char *)"TopLevelWindow_MacSetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacSetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
27707          { (char *)"TopLevelWindow_MacGetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacGetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
27708          { (char *)"TopLevelWindow_swigregister", TopLevelWindow_swigregister, METH_VARARGS, NULL},
27709          { (char *)"new_Frame", (PyCFunction) _wrap_new_Frame, METH_VARARGS | METH_KEYWORDS, NULL},
27710          { (char *)"new_PreFrame", (PyCFunction) _wrap_new_PreFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27711          { (char *)"Frame_Create", (PyCFunction) _wrap_Frame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27712          { (char *)"Frame_GetClientAreaOrigin", (PyCFunction) _wrap_Frame_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
27713          { (char *)"Frame_SendSizeEvent", (PyCFunction) _wrap_Frame_SendSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27714          { (char *)"Frame_SetMenuBar", (PyCFunction) _wrap_Frame_SetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
27715          { (char *)"Frame_GetMenuBar", (PyCFunction) _wrap_Frame_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
27716          { (char *)"Frame_ProcessCommand", (PyCFunction) _wrap_Frame_ProcessCommand, METH_VARARGS | METH_KEYWORDS, NULL},
27717          { (char *)"Frame_CreateStatusBar", (PyCFunction) _wrap_Frame_CreateStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27718          { (char *)"Frame_GetStatusBar", (PyCFunction) _wrap_Frame_GetStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27719          { (char *)"Frame_SetStatusBar", (PyCFunction) _wrap_Frame_SetStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27720          { (char *)"Frame_SetStatusText", (PyCFunction) _wrap_Frame_SetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27721          { (char *)"Frame_SetStatusWidths", (PyCFunction) _wrap_Frame_SetStatusWidths, METH_VARARGS | METH_KEYWORDS, NULL},
27722          { (char *)"Frame_PushStatusText", (PyCFunction) _wrap_Frame_PushStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27723          { (char *)"Frame_PopStatusText", (PyCFunction) _wrap_Frame_PopStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27724          { (char *)"Frame_SetStatusBarPane", (PyCFunction) _wrap_Frame_SetStatusBarPane, METH_VARARGS | METH_KEYWORDS, NULL},
27725          { (char *)"Frame_GetStatusBarPane", (PyCFunction) _wrap_Frame_GetStatusBarPane, METH_VARARGS | METH_KEYWORDS, NULL},
27726          { (char *)"Frame_CreateToolBar", (PyCFunction) _wrap_Frame_CreateToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27727          { (char *)"Frame_GetToolBar", (PyCFunction) _wrap_Frame_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27728          { (char *)"Frame_SetToolBar", (PyCFunction) _wrap_Frame_SetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27729          { (char *)"Frame_DoGiveHelp", (PyCFunction) _wrap_Frame_DoGiveHelp, METH_VARARGS | METH_KEYWORDS, NULL},
27730          { (char *)"Frame_DoMenuUpdates", (PyCFunction) _wrap_Frame_DoMenuUpdates, METH_VARARGS | METH_KEYWORDS, NULL},
27731          { (char *)"Frame_GetClassDefaultAttributes", (PyCFunction) _wrap_Frame_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27732          { (char *)"Frame_swigregister", Frame_swigregister, METH_VARARGS, NULL},
27733          { (char *)"new_Dialog", (PyCFunction) _wrap_new_Dialog, METH_VARARGS | METH_KEYWORDS, NULL},
27734          { (char *)"new_PreDialog", (PyCFunction) _wrap_new_PreDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27735          { (char *)"Dialog_Create", (PyCFunction) _wrap_Dialog_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27736          { (char *)"Dialog_SetReturnCode", (PyCFunction) _wrap_Dialog_SetReturnCode, METH_VARARGS | METH_KEYWORDS, NULL},
27737          { (char *)"Dialog_GetReturnCode", (PyCFunction) _wrap_Dialog_GetReturnCode, METH_VARARGS | METH_KEYWORDS, NULL},
27738          { (char *)"Dialog_CreateTextSizer", (PyCFunction) _wrap_Dialog_CreateTextSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27739          { (char *)"Dialog_CreateButtonSizer", (PyCFunction) _wrap_Dialog_CreateButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27740          { (char *)"Dialog_CreateStdDialogButtonSizer", (PyCFunction) _wrap_Dialog_CreateStdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27741          { (char *)"Dialog_IsModal", (PyCFunction) _wrap_Dialog_IsModal, METH_VARARGS | METH_KEYWORDS, NULL},
27742          { (char *)"Dialog_ShowModal", (PyCFunction) _wrap_Dialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
27743          { (char *)"Dialog_EndModal", (PyCFunction) _wrap_Dialog_EndModal, METH_VARARGS | METH_KEYWORDS, NULL},
27744          { (char *)"Dialog_GetClassDefaultAttributes", (PyCFunction) _wrap_Dialog_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27745          { (char *)"Dialog_swigregister", Dialog_swigregister, METH_VARARGS, NULL},
27746          { (char *)"new_MiniFrame", (PyCFunction) _wrap_new_MiniFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27747          { (char *)"new_PreMiniFrame", (PyCFunction) _wrap_new_PreMiniFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27748          { (char *)"MiniFrame_Create", (PyCFunction) _wrap_MiniFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27749          { (char *)"MiniFrame_swigregister", MiniFrame_swigregister, METH_VARARGS, NULL},
27750          { (char *)"new_SplashScreenWindow", (PyCFunction) _wrap_new_SplashScreenWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27751          { (char *)"SplashScreenWindow_SetBitmap", (PyCFunction) _wrap_SplashScreenWindow_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
27752          { (char *)"SplashScreenWindow_GetBitmap", (PyCFunction) _wrap_SplashScreenWindow_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
27753          { (char *)"SplashScreenWindow_swigregister", SplashScreenWindow_swigregister, METH_VARARGS, NULL},
27754          { (char *)"new_SplashScreen", (PyCFunction) _wrap_new_SplashScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27755          { (char *)"SplashScreen_GetSplashStyle", (PyCFunction) _wrap_SplashScreen_GetSplashStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27756          { (char *)"SplashScreen_GetSplashWindow", (PyCFunction) _wrap_SplashScreen_GetSplashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27757          { (char *)"SplashScreen_GetTimeout", (PyCFunction) _wrap_SplashScreen_GetTimeout, METH_VARARGS | METH_KEYWORDS, NULL},
27758          { (char *)"SplashScreen_swigregister", SplashScreen_swigregister, METH_VARARGS, NULL},
27759          { (char *)"new_StatusBar", (PyCFunction) _wrap_new_StatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27760          { (char *)"new_PreStatusBar", (PyCFunction) _wrap_new_PreStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27761          { (char *)"StatusBar_Create", (PyCFunction) _wrap_StatusBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27762          { (char *)"StatusBar_SetFieldsCount", (PyCFunction) _wrap_StatusBar_SetFieldsCount, METH_VARARGS | METH_KEYWORDS, NULL},
27763          { (char *)"StatusBar_GetFieldsCount", (PyCFunction) _wrap_StatusBar_GetFieldsCount, METH_VARARGS | METH_KEYWORDS, NULL},
27764          { (char *)"StatusBar_SetStatusText", (PyCFunction) _wrap_StatusBar_SetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27765          { (char *)"StatusBar_GetStatusText", (PyCFunction) _wrap_StatusBar_GetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27766          { (char *)"StatusBar_PushStatusText", (PyCFunction) _wrap_StatusBar_PushStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27767          { (char *)"StatusBar_PopStatusText", (PyCFunction) _wrap_StatusBar_PopStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27768          { (char *)"StatusBar_SetStatusWidths", (PyCFunction) _wrap_StatusBar_SetStatusWidths, METH_VARARGS | METH_KEYWORDS, NULL},
27769          { (char *)"StatusBar_SetStatusStyles", (PyCFunction) _wrap_StatusBar_SetStatusStyles, METH_VARARGS | METH_KEYWORDS, NULL},
27770          { (char *)"StatusBar_GetFieldRect", (PyCFunction) _wrap_StatusBar_GetFieldRect, METH_VARARGS | METH_KEYWORDS, NULL},
27771          { (char *)"StatusBar_SetMinHeight", (PyCFunction) _wrap_StatusBar_SetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
27772          { (char *)"StatusBar_GetBorderX", (PyCFunction) _wrap_StatusBar_GetBorderX, METH_VARARGS | METH_KEYWORDS, NULL},
27773          { (char *)"StatusBar_GetBorderY", (PyCFunction) _wrap_StatusBar_GetBorderY, METH_VARARGS | METH_KEYWORDS, NULL},
27774          { (char *)"StatusBar_GetClassDefaultAttributes", (PyCFunction) _wrap_StatusBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27775          { (char *)"StatusBar_swigregister", StatusBar_swigregister, METH_VARARGS, NULL},
27776          { (char *)"new_SplitterWindow", (PyCFunction) _wrap_new_SplitterWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27777          { (char *)"new_PreSplitterWindow", (PyCFunction) _wrap_new_PreSplitterWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27778          { (char *)"SplitterWindow_Create", (PyCFunction) _wrap_SplitterWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27779          { (char *)"SplitterWindow_GetWindow1", (PyCFunction) _wrap_SplitterWindow_GetWindow1, METH_VARARGS | METH_KEYWORDS, NULL},
27780          { (char *)"SplitterWindow_GetWindow2", (PyCFunction) _wrap_SplitterWindow_GetWindow2, METH_VARARGS | METH_KEYWORDS, NULL},
27781          { (char *)"SplitterWindow_SetSplitMode", (PyCFunction) _wrap_SplitterWindow_SetSplitMode, METH_VARARGS | METH_KEYWORDS, NULL},
27782          { (char *)"SplitterWindow_GetSplitMode", (PyCFunction) _wrap_SplitterWindow_GetSplitMode, METH_VARARGS | METH_KEYWORDS, NULL},
27783          { (char *)"SplitterWindow_Initialize", (PyCFunction) _wrap_SplitterWindow_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
27784          { (char *)"SplitterWindow_SplitVertically", (PyCFunction) _wrap_SplitterWindow_SplitVertically, METH_VARARGS | METH_KEYWORDS, NULL},
27785          { (char *)"SplitterWindow_SplitHorizontally", (PyCFunction) _wrap_SplitterWindow_SplitHorizontally, METH_VARARGS | METH_KEYWORDS, NULL},
27786          { (char *)"SplitterWindow_Unsplit", (PyCFunction) _wrap_SplitterWindow_Unsplit, METH_VARARGS | METH_KEYWORDS, NULL},
27787          { (char *)"SplitterWindow_ReplaceWindow", (PyCFunction) _wrap_SplitterWindow_ReplaceWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27788          { (char *)"SplitterWindow_UpdateSize", (PyCFunction) _wrap_SplitterWindow_UpdateSize, METH_VARARGS | METH_KEYWORDS, NULL},
27789          { (char *)"SplitterWindow_IsSplit", (PyCFunction) _wrap_SplitterWindow_IsSplit, METH_VARARGS | METH_KEYWORDS, NULL},
27790          { (char *)"SplitterWindow_SetSashSize", (PyCFunction) _wrap_SplitterWindow_SetSashSize, METH_VARARGS | METH_KEYWORDS, NULL},
27791          { (char *)"SplitterWindow_SetBorderSize", (PyCFunction) _wrap_SplitterWindow_SetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27792          { (char *)"SplitterWindow_GetSashSize", (PyCFunction) _wrap_SplitterWindow_GetSashSize, METH_VARARGS | METH_KEYWORDS, NULL},
27793          { (char *)"SplitterWindow_GetBorderSize", (PyCFunction) _wrap_SplitterWindow_GetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27794          { (char *)"SplitterWindow_SetSashPosition", (PyCFunction) _wrap_SplitterWindow_SetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27795          { (char *)"SplitterWindow_GetSashPosition", (PyCFunction) _wrap_SplitterWindow_GetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27796          { (char *)"SplitterWindow_SetSashGravity", (PyCFunction) _wrap_SplitterWindow_SetSashGravity, METH_VARARGS | METH_KEYWORDS, NULL},
27797          { (char *)"SplitterWindow_GetSashGravity", (PyCFunction) _wrap_SplitterWindow_GetSashGravity, METH_VARARGS | METH_KEYWORDS, NULL},
27798          { (char *)"SplitterWindow_SetMinimumPaneSize", (PyCFunction) _wrap_SplitterWindow_SetMinimumPaneSize, METH_VARARGS | METH_KEYWORDS, NULL},
27799          { (char *)"SplitterWindow_GetMinimumPaneSize", (PyCFunction) _wrap_SplitterWindow_GetMinimumPaneSize, METH_VARARGS | METH_KEYWORDS, NULL},
27800          { (char *)"SplitterWindow_SashHitTest", (PyCFunction) _wrap_SplitterWindow_SashHitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27801          { (char *)"SplitterWindow_SizeWindows", (PyCFunction) _wrap_SplitterWindow_SizeWindows, METH_VARARGS | METH_KEYWORDS, NULL},
27802          { (char *)"SplitterWindow_SetNeedUpdating", (PyCFunction) _wrap_SplitterWindow_SetNeedUpdating, METH_VARARGS | METH_KEYWORDS, NULL},
27803          { (char *)"SplitterWindow_GetNeedUpdating", (PyCFunction) _wrap_SplitterWindow_GetNeedUpdating, METH_VARARGS | METH_KEYWORDS, NULL},
27804          { (char *)"SplitterWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_SplitterWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27805          { (char *)"SplitterWindow_swigregister", SplitterWindow_swigregister, METH_VARARGS, NULL},
27806          { (char *)"new_SplitterEvent", (PyCFunction) _wrap_new_SplitterEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27807          { (char *)"SplitterEvent_SetSashPosition", (PyCFunction) _wrap_SplitterEvent_SetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27808          { (char *)"SplitterEvent_GetSashPosition", (PyCFunction) _wrap_SplitterEvent_GetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27809          { (char *)"SplitterEvent_GetWindowBeingRemoved", (PyCFunction) _wrap_SplitterEvent_GetWindowBeingRemoved, METH_VARARGS | METH_KEYWORDS, NULL},
27810          { (char *)"SplitterEvent_GetX", (PyCFunction) _wrap_SplitterEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
27811          { (char *)"SplitterEvent_GetY", (PyCFunction) _wrap_SplitterEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
27812          { (char *)"SplitterEvent_swigregister", SplitterEvent_swigregister, METH_VARARGS, NULL},
27813          { (char *)"new_SashWindow", (PyCFunction) _wrap_new_SashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27814          { (char *)"new_PreSashWindow", (PyCFunction) _wrap_new_PreSashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27815          { (char *)"SashWindow_Create", (PyCFunction) _wrap_SashWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27816          { (char *)"SashWindow_SetSashVisible", (PyCFunction) _wrap_SashWindow_SetSashVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27817          { (char *)"SashWindow_GetSashVisible", (PyCFunction) _wrap_SashWindow_GetSashVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27818          { (char *)"SashWindow_SetSashBorder", (PyCFunction) _wrap_SashWindow_SetSashBorder, METH_VARARGS | METH_KEYWORDS, NULL},
27819          { (char *)"SashWindow_HasBorder", (PyCFunction) _wrap_SashWindow_HasBorder, METH_VARARGS | METH_KEYWORDS, NULL},
27820          { (char *)"SashWindow_GetEdgeMargin", (PyCFunction) _wrap_SashWindow_GetEdgeMargin, METH_VARARGS | METH_KEYWORDS, NULL},
27821          { (char *)"SashWindow_SetDefaultBorderSize", (PyCFunction) _wrap_SashWindow_SetDefaultBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27822          { (char *)"SashWindow_GetDefaultBorderSize", (PyCFunction) _wrap_SashWindow_GetDefaultBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27823          { (char *)"SashWindow_SetExtraBorderSize", (PyCFunction) _wrap_SashWindow_SetExtraBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27824          { (char *)"SashWindow_GetExtraBorderSize", (PyCFunction) _wrap_SashWindow_GetExtraBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27825          { (char *)"SashWindow_SetMinimumSizeX", (PyCFunction) _wrap_SashWindow_SetMinimumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27826          { (char *)"SashWindow_SetMinimumSizeY", (PyCFunction) _wrap_SashWindow_SetMinimumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27827          { (char *)"SashWindow_GetMinimumSizeX", (PyCFunction) _wrap_SashWindow_GetMinimumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27828          { (char *)"SashWindow_GetMinimumSizeY", (PyCFunction) _wrap_SashWindow_GetMinimumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27829          { (char *)"SashWindow_SetMaximumSizeX", (PyCFunction) _wrap_SashWindow_SetMaximumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27830          { (char *)"SashWindow_SetMaximumSizeY", (PyCFunction) _wrap_SashWindow_SetMaximumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27831          { (char *)"SashWindow_GetMaximumSizeX", (PyCFunction) _wrap_SashWindow_GetMaximumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27832          { (char *)"SashWindow_GetMaximumSizeY", (PyCFunction) _wrap_SashWindow_GetMaximumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27833          { (char *)"SashWindow_SashHitTest", (PyCFunction) _wrap_SashWindow_SashHitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27834          { (char *)"SashWindow_SizeWindows", (PyCFunction) _wrap_SashWindow_SizeWindows, METH_VARARGS | METH_KEYWORDS, NULL},
27835          { (char *)"SashWindow_swigregister", SashWindow_swigregister, METH_VARARGS, NULL},
27836          { (char *)"new_SashEvent", (PyCFunction) _wrap_new_SashEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27837          { (char *)"SashEvent_SetEdge", (PyCFunction) _wrap_SashEvent_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
27838          { (char *)"SashEvent_GetEdge", (PyCFunction) _wrap_SashEvent_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
27839          { (char *)"SashEvent_SetDragRect", (PyCFunction) _wrap_SashEvent_SetDragRect, METH_VARARGS | METH_KEYWORDS, NULL},
27840          { (char *)"SashEvent_GetDragRect", (PyCFunction) _wrap_SashEvent_GetDragRect, METH_VARARGS | METH_KEYWORDS, NULL},
27841          { (char *)"SashEvent_SetDragStatus", (PyCFunction) _wrap_SashEvent_SetDragStatus, METH_VARARGS | METH_KEYWORDS, NULL},
27842          { (char *)"SashEvent_GetDragStatus", (PyCFunction) _wrap_SashEvent_GetDragStatus, METH_VARARGS | METH_KEYWORDS, NULL},
27843          { (char *)"SashEvent_swigregister", SashEvent_swigregister, METH_VARARGS, NULL},
27844          { (char *)"new_QueryLayoutInfoEvent", (PyCFunction) _wrap_new_QueryLayoutInfoEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27845          { (char *)"QueryLayoutInfoEvent_SetRequestedLength", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetRequestedLength, METH_VARARGS | METH_KEYWORDS, NULL},
27846          { (char *)"QueryLayoutInfoEvent_GetRequestedLength", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetRequestedLength, METH_VARARGS | METH_KEYWORDS, NULL},
27847          { (char *)"QueryLayoutInfoEvent_SetFlags", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27848          { (char *)"QueryLayoutInfoEvent_GetFlags", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27849          { (char *)"QueryLayoutInfoEvent_SetSize", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
27850          { (char *)"QueryLayoutInfoEvent_GetSize", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
27851          { (char *)"QueryLayoutInfoEvent_SetOrientation", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27852          { (char *)"QueryLayoutInfoEvent_GetOrientation", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27853          { (char *)"QueryLayoutInfoEvent_SetAlignment", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27854          { (char *)"QueryLayoutInfoEvent_GetAlignment", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27855          { (char *)"QueryLayoutInfoEvent_swigregister", QueryLayoutInfoEvent_swigregister, METH_VARARGS, NULL},
27856          { (char *)"new_CalculateLayoutEvent", (PyCFunction) _wrap_new_CalculateLayoutEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27857          { (char *)"CalculateLayoutEvent_SetFlags", (PyCFunction) _wrap_CalculateLayoutEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27858          { (char *)"CalculateLayoutEvent_GetFlags", (PyCFunction) _wrap_CalculateLayoutEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27859          { (char *)"CalculateLayoutEvent_SetRect", (PyCFunction) _wrap_CalculateLayoutEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27860          { (char *)"CalculateLayoutEvent_GetRect", (PyCFunction) _wrap_CalculateLayoutEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27861          { (char *)"CalculateLayoutEvent_swigregister", CalculateLayoutEvent_swigregister, METH_VARARGS, NULL},
27862          { (char *)"new_SashLayoutWindow", (PyCFunction) _wrap_new_SashLayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27863          { (char *)"new_PreSashLayoutWindow", (PyCFunction) _wrap_new_PreSashLayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27864          { (char *)"SashLayoutWindow_Create", (PyCFunction) _wrap_SashLayoutWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27865          { (char *)"SashLayoutWindow_GetAlignment", (PyCFunction) _wrap_SashLayoutWindow_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27866          { (char *)"SashLayoutWindow_GetOrientation", (PyCFunction) _wrap_SashLayoutWindow_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27867          { (char *)"SashLayoutWindow_SetAlignment", (PyCFunction) _wrap_SashLayoutWindow_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27868          { (char *)"SashLayoutWindow_SetDefaultSize", (PyCFunction) _wrap_SashLayoutWindow_SetDefaultSize, METH_VARARGS | METH_KEYWORDS, NULL},
27869          { (char *)"SashLayoutWindow_SetOrientation", (PyCFunction) _wrap_SashLayoutWindow_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27870          { (char *)"SashLayoutWindow_swigregister", SashLayoutWindow_swigregister, METH_VARARGS, NULL},
27871          { (char *)"new_LayoutAlgorithm", (PyCFunction) _wrap_new_LayoutAlgorithm, METH_VARARGS | METH_KEYWORDS, NULL},
27872          { (char *)"delete_LayoutAlgorithm", (PyCFunction) _wrap_delete_LayoutAlgorithm, METH_VARARGS | METH_KEYWORDS, NULL},
27873          { (char *)"LayoutAlgorithm_LayoutMDIFrame", (PyCFunction) _wrap_LayoutAlgorithm_LayoutMDIFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27874          { (char *)"LayoutAlgorithm_LayoutFrame", (PyCFunction) _wrap_LayoutAlgorithm_LayoutFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27875          { (char *)"LayoutAlgorithm_LayoutWindow", (PyCFunction) _wrap_LayoutAlgorithm_LayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27876          { (char *)"LayoutAlgorithm_swigregister", LayoutAlgorithm_swigregister, METH_VARARGS, NULL},
27877          { (char *)"new_PopupWindow", (PyCFunction) _wrap_new_PopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27878          { (char *)"new_PrePopupWindow", (PyCFunction) _wrap_new_PrePopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27879          { (char *)"PopupWindow_Create", (PyCFunction) _wrap_PopupWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27880          { (char *)"PopupWindow_Position", (PyCFunction) _wrap_PopupWindow_Position, METH_VARARGS | METH_KEYWORDS, NULL},
27881          { (char *)"PopupWindow_swigregister", PopupWindow_swigregister, METH_VARARGS, NULL},
27882          { (char *)"new_PopupTransientWindow", (PyCFunction) _wrap_new_PopupTransientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27883          { (char *)"new_PrePopupTransientWindow", (PyCFunction) _wrap_new_PrePopupTransientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27884          { (char *)"PopupTransientWindow__setCallbackInfo", (PyCFunction) _wrap_PopupTransientWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27885          { (char *)"PopupTransientWindow_Popup", (PyCFunction) _wrap_PopupTransientWindow_Popup, METH_VARARGS | METH_KEYWORDS, NULL},
27886          { (char *)"PopupTransientWindow_Dismiss", (PyCFunction) _wrap_PopupTransientWindow_Dismiss, METH_VARARGS | METH_KEYWORDS, NULL},
27887          { (char *)"PopupTransientWindow_swigregister", PopupTransientWindow_swigregister, METH_VARARGS, NULL},
27888          { (char *)"new_TipWindow", (PyCFunction) _wrap_new_TipWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27889          { (char *)"TipWindow_SetBoundingRect", (PyCFunction) _wrap_TipWindow_SetBoundingRect, METH_VARARGS | METH_KEYWORDS, NULL},
27890          { (char *)"TipWindow_Close", (PyCFunction) _wrap_TipWindow_Close, METH_VARARGS | METH_KEYWORDS, NULL},
27891          { (char *)"TipWindow_swigregister", TipWindow_swigregister, METH_VARARGS, NULL},
27892          { (char *)"new_VScrolledWindow", (PyCFunction) _wrap_new_VScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27893          { (char *)"new_PreVScrolledWindow", (PyCFunction) _wrap_new_PreVScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27894          { (char *)"VScrolledWindow__setCallbackInfo", (PyCFunction) _wrap_VScrolledWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27895          { (char *)"VScrolledWindow_Create", (PyCFunction) _wrap_VScrolledWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27896          { (char *)"VScrolledWindow_SetLineCount", (PyCFunction) _wrap_VScrolledWindow_SetLineCount, METH_VARARGS | METH_KEYWORDS, NULL},
27897          { (char *)"VScrolledWindow_ScrollToLine", (PyCFunction) _wrap_VScrolledWindow_ScrollToLine, METH_VARARGS | METH_KEYWORDS, NULL},
27898          { (char *)"VScrolledWindow_ScrollLines", (PyCFunction) _wrap_VScrolledWindow_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
27899          { (char *)"VScrolledWindow_ScrollPages", (PyCFunction) _wrap_VScrolledWindow_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
27900          { (char *)"VScrolledWindow_RefreshLine", (PyCFunction) _wrap_VScrolledWindow_RefreshLine, METH_VARARGS | METH_KEYWORDS, NULL},
27901          { (char *)"VScrolledWindow_RefreshLines", (PyCFunction) _wrap_VScrolledWindow_RefreshLines, METH_VARARGS | METH_KEYWORDS, NULL},
27902          { (char *)"VScrolledWindow_HitTestXY", (PyCFunction) _wrap_VScrolledWindow_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
27903          { (char *)"VScrolledWindow_HitTest", (PyCFunction) _wrap_VScrolledWindow_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27904          { (char *)"VScrolledWindow_RefreshAll", (PyCFunction) _wrap_VScrolledWindow_RefreshAll, METH_VARARGS | METH_KEYWORDS, NULL},
27905          { (char *)"VScrolledWindow_GetLineCount", (PyCFunction) _wrap_VScrolledWindow_GetLineCount, METH_VARARGS | METH_KEYWORDS, NULL},
27906          { (char *)"VScrolledWindow_GetFirstVisibleLine", (PyCFunction) _wrap_VScrolledWindow_GetFirstVisibleLine, METH_VARARGS | METH_KEYWORDS, NULL},
27907          { (char *)"VScrolledWindow_GetLastVisibleLine", (PyCFunction) _wrap_VScrolledWindow_GetLastVisibleLine, METH_VARARGS | METH_KEYWORDS, NULL},
27908          { (char *)"VScrolledWindow_IsVisible", (PyCFunction) _wrap_VScrolledWindow_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27909          { (char *)"VScrolledWindow_swigregister", VScrolledWindow_swigregister, METH_VARARGS, NULL},
27910          { (char *)"new_VListBox", (PyCFunction) _wrap_new_VListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27911          { (char *)"new_PreVListBox", (PyCFunction) _wrap_new_PreVListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27912          { (char *)"VListBox__setCallbackInfo", (PyCFunction) _wrap_VListBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27913          { (char *)"VListBox_Create", (PyCFunction) _wrap_VListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27914          { (char *)"VListBox_GetItemCount", (PyCFunction) _wrap_VListBox_GetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
27915          { (char *)"VListBox_HasMultipleSelection", (PyCFunction) _wrap_VListBox_HasMultipleSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27916          { (char *)"VListBox_GetSelection", (PyCFunction) _wrap_VListBox_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27917          { (char *)"VListBox_IsCurrent", (PyCFunction) _wrap_VListBox_IsCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
27918          { (char *)"VListBox_IsSelected", (PyCFunction) _wrap_VListBox_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
27919          { (char *)"VListBox_GetSelectedCount", (PyCFunction) _wrap_VListBox_GetSelectedCount, METH_VARARGS | METH_KEYWORDS, NULL},
27920          { (char *)"VListBox_GetFirstSelected", (PyCFunction) _wrap_VListBox_GetFirstSelected, METH_VARARGS | METH_KEYWORDS, NULL},
27921          { (char *)"VListBox_GetNextSelected", (PyCFunction) _wrap_VListBox_GetNextSelected, METH_VARARGS | METH_KEYWORDS, NULL},
27922          { (char *)"VListBox_GetMargins", (PyCFunction) _wrap_VListBox_GetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
27923          { (char *)"VListBox_GetSelectionBackground", (PyCFunction) _wrap_VListBox_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
27924          { (char *)"VListBox_SetItemCount", (PyCFunction) _wrap_VListBox_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
27925          { (char *)"VListBox_Clear", (PyCFunction) _wrap_VListBox_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
27926          { (char *)"VListBox_SetSelection", (PyCFunction) _wrap_VListBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27927          { (char *)"VListBox_Select", (PyCFunction) _wrap_VListBox_Select, METH_VARARGS | METH_KEYWORDS, NULL},
27928          { (char *)"VListBox_SelectRange", (PyCFunction) _wrap_VListBox_SelectRange, METH_VARARGS | METH_KEYWORDS, NULL},
27929          { (char *)"VListBox_Toggle", (PyCFunction) _wrap_VListBox_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
27930          { (char *)"VListBox_SelectAll", (PyCFunction) _wrap_VListBox_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
27931          { (char *)"VListBox_DeselectAll", (PyCFunction) _wrap_VListBox_DeselectAll, METH_VARARGS | METH_KEYWORDS, NULL},
27932          { (char *)"VListBox_SetMargins", (PyCFunction) _wrap_VListBox_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
27933          { (char *)"VListBox_SetMarginsXY", (PyCFunction) _wrap_VListBox_SetMarginsXY, METH_VARARGS | METH_KEYWORDS, NULL},
27934          { (char *)"VListBox_SetSelectionBackground", (PyCFunction) _wrap_VListBox_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
27935          { (char *)"VListBox_swigregister", VListBox_swigregister, METH_VARARGS, NULL},
27936          { (char *)"new_HtmlListBox", (PyCFunction) _wrap_new_HtmlListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27937          { (char *)"new_PreHtmlListBox", (PyCFunction) _wrap_new_PreHtmlListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27938          { (char *)"HtmlListBox__setCallbackInfo", (PyCFunction) _wrap_HtmlListBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27939          { (char *)"HtmlListBox_Create", (PyCFunction) _wrap_HtmlListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27940          { (char *)"HtmlListBox_RefreshAll", (PyCFunction) _wrap_HtmlListBox_RefreshAll, METH_VARARGS | METH_KEYWORDS, NULL},
27941          { (char *)"HtmlListBox_SetItemCount", (PyCFunction) _wrap_HtmlListBox_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
27942          { (char *)"HtmlListBox_GetFileSystem", (PyCFunction) _wrap_HtmlListBox_GetFileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
27943          { (char *)"HtmlListBox_swigregister", HtmlListBox_swigregister, METH_VARARGS, NULL},
27944          { (char *)"new_TaskBarIcon", (PyCFunction) _wrap_new_TaskBarIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27945          { (char *)"TaskBarIcon__setCallbackInfo", (PyCFunction) _wrap_TaskBarIcon__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27946          { (char *)"TaskBarIcon_Destroy", (PyCFunction) _wrap_TaskBarIcon_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
27947          { (char *)"TaskBarIcon_IsOk", (PyCFunction) _wrap_TaskBarIcon_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
27948          { (char *)"TaskBarIcon_IsIconInstalled", (PyCFunction) _wrap_TaskBarIcon_IsIconInstalled, METH_VARARGS | METH_KEYWORDS, NULL},
27949          { (char *)"TaskBarIcon_SetIcon", (PyCFunction) _wrap_TaskBarIcon_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27950          { (char *)"TaskBarIcon_RemoveIcon", (PyCFunction) _wrap_TaskBarIcon_RemoveIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27951          { (char *)"TaskBarIcon_PopupMenu", (PyCFunction) _wrap_TaskBarIcon_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
27952          { (char *)"TaskBarIcon_swigregister", TaskBarIcon_swigregister, METH_VARARGS, NULL},
27953          { (char *)"new_TaskBarIconEvent", (PyCFunction) _wrap_new_TaskBarIconEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27954          { (char *)"TaskBarIconEvent_swigregister", TaskBarIconEvent_swigregister, METH_VARARGS, NULL},
27955          { (char *)"new_ColourData", (PyCFunction) _wrap_new_ColourData, METH_VARARGS | METH_KEYWORDS, NULL},
27956          { (char *)"delete_ColourData", (PyCFunction) _wrap_delete_ColourData, METH_VARARGS | METH_KEYWORDS, NULL},
27957          { (char *)"ColourData_GetChooseFull", (PyCFunction) _wrap_ColourData_GetChooseFull, METH_VARARGS | METH_KEYWORDS, NULL},
27958          { (char *)"ColourData_GetColour", (PyCFunction) _wrap_ColourData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
27959          { (char *)"ColourData_GetCustomColour", (PyCFunction) _wrap_ColourData_GetCustomColour, METH_VARARGS | METH_KEYWORDS, NULL},
27960          { (char *)"ColourData_SetChooseFull", (PyCFunction) _wrap_ColourData_SetChooseFull, METH_VARARGS | METH_KEYWORDS, NULL},
27961          { (char *)"ColourData_SetColour", (PyCFunction) _wrap_ColourData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
27962          { (char *)"ColourData_SetCustomColour", (PyCFunction) _wrap_ColourData_SetCustomColour, METH_VARARGS | METH_KEYWORDS, NULL},
27963          { (char *)"ColourData_swigregister", ColourData_swigregister, METH_VARARGS, NULL},
27964          { (char *)"new_ColourDialog", (PyCFunction) _wrap_new_ColourDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27965          { (char *)"ColourDialog_GetColourData", (PyCFunction) _wrap_ColourDialog_GetColourData, METH_VARARGS | METH_KEYWORDS, NULL},
27966          { (char *)"ColourDialog_swigregister", ColourDialog_swigregister, METH_VARARGS, NULL},
27967          { (char *)"new_DirDialog", (PyCFunction) _wrap_new_DirDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27968          { (char *)"DirDialog_GetPath", (PyCFunction) _wrap_DirDialog_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27969          { (char *)"DirDialog_GetMessage", (PyCFunction) _wrap_DirDialog_GetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27970          { (char *)"DirDialog_GetStyle", (PyCFunction) _wrap_DirDialog_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27971          { (char *)"DirDialog_SetMessage", (PyCFunction) _wrap_DirDialog_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27972          { (char *)"DirDialog_SetPath", (PyCFunction) _wrap_DirDialog_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27973          { (char *)"DirDialog_swigregister", DirDialog_swigregister, METH_VARARGS, NULL},
27974          { (char *)"new_FileDialog", (PyCFunction) _wrap_new_FileDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27975          { (char *)"FileDialog_SetMessage", (PyCFunction) _wrap_FileDialog_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27976          { (char *)"FileDialog_SetPath", (PyCFunction) _wrap_FileDialog_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27977          { (char *)"FileDialog_SetDirectory", (PyCFunction) _wrap_FileDialog_SetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
27978          { (char *)"FileDialog_SetFilename", (PyCFunction) _wrap_FileDialog_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
27979          { (char *)"FileDialog_SetWildcard", (PyCFunction) _wrap_FileDialog_SetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
27980          { (char *)"FileDialog_SetStyle", (PyCFunction) _wrap_FileDialog_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27981          { (char *)"FileDialog_SetFilterIndex", (PyCFunction) _wrap_FileDialog_SetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
27982          { (char *)"FileDialog_GetMessage", (PyCFunction) _wrap_FileDialog_GetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27983          { (char *)"FileDialog_GetPath", (PyCFunction) _wrap_FileDialog_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27984          { (char *)"FileDialog_GetDirectory", (PyCFunction) _wrap_FileDialog_GetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
27985          { (char *)"FileDialog_GetFilename", (PyCFunction) _wrap_FileDialog_GetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
27986          { (char *)"FileDialog_GetWildcard", (PyCFunction) _wrap_FileDialog_GetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
27987          { (char *)"FileDialog_GetStyle", (PyCFunction) _wrap_FileDialog_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27988          { (char *)"FileDialog_GetFilterIndex", (PyCFunction) _wrap_FileDialog_GetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
27989          { (char *)"FileDialog_GetFilenames", (PyCFunction) _wrap_FileDialog_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
27990          { (char *)"FileDialog_GetPaths", (PyCFunction) _wrap_FileDialog_GetPaths, METH_VARARGS | METH_KEYWORDS, NULL},
27991          { (char *)"FileDialog_swigregister", FileDialog_swigregister, METH_VARARGS, NULL},
27992          { (char *)"new_MultiChoiceDialog", (PyCFunction) _wrap_new_MultiChoiceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27993          { (char *)"MultiChoiceDialog_SetSelections", (PyCFunction) _wrap_MultiChoiceDialog_SetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
27994          { (char *)"MultiChoiceDialog_GetSelections", (PyCFunction) _wrap_MultiChoiceDialog_GetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
27995          { (char *)"MultiChoiceDialog_swigregister", MultiChoiceDialog_swigregister, METH_VARARGS, NULL},
27996          { (char *)"new_SingleChoiceDialog", (PyCFunction) _wrap_new_SingleChoiceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27997          { (char *)"SingleChoiceDialog_GetSelection", (PyCFunction) _wrap_SingleChoiceDialog_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27998          { (char *)"SingleChoiceDialog_GetStringSelection", (PyCFunction) _wrap_SingleChoiceDialog_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27999          { (char *)"SingleChoiceDialog_SetSelection", (PyCFunction) _wrap_SingleChoiceDialog_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28000          { (char *)"SingleChoiceDialog_swigregister", SingleChoiceDialog_swigregister, METH_VARARGS, NULL},
28001          { (char *)"new_TextEntryDialog", (PyCFunction) _wrap_new_TextEntryDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28002          { (char *)"TextEntryDialog_GetValue", (PyCFunction) _wrap_TextEntryDialog_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
28003          { (char *)"TextEntryDialog_SetValue", (PyCFunction) _wrap_TextEntryDialog_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
28004          { (char *)"TextEntryDialog_swigregister", TextEntryDialog_swigregister, METH_VARARGS, NULL},
28005          { (char *)"new_PasswordEntryDialog", (PyCFunction) _wrap_new_PasswordEntryDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28006          { (char *)"PasswordEntryDialog_swigregister", PasswordEntryDialog_swigregister, METH_VARARGS, NULL},
28007          { (char *)"new_FontData", (PyCFunction) _wrap_new_FontData, METH_VARARGS | METH_KEYWORDS, NULL},
28008          { (char *)"delete_FontData", (PyCFunction) _wrap_delete_FontData, METH_VARARGS | METH_KEYWORDS, NULL},
28009          { (char *)"FontData_EnableEffects", (PyCFunction) _wrap_FontData_EnableEffects, METH_VARARGS | METH_KEYWORDS, NULL},
28010          { (char *)"FontData_GetAllowSymbols", (PyCFunction) _wrap_FontData_GetAllowSymbols, METH_VARARGS | METH_KEYWORDS, NULL},
28011          { (char *)"FontData_GetColour", (PyCFunction) _wrap_FontData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28012          { (char *)"FontData_GetChosenFont", (PyCFunction) _wrap_FontData_GetChosenFont, METH_VARARGS | METH_KEYWORDS, NULL},
28013          { (char *)"FontData_GetEnableEffects", (PyCFunction) _wrap_FontData_GetEnableEffects, METH_VARARGS | METH_KEYWORDS, NULL},
28014          { (char *)"FontData_GetInitialFont", (PyCFunction) _wrap_FontData_GetInitialFont, METH_VARARGS | METH_KEYWORDS, NULL},
28015          { (char *)"FontData_GetShowHelp", (PyCFunction) _wrap_FontData_GetShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28016          { (char *)"FontData_SetAllowSymbols", (PyCFunction) _wrap_FontData_SetAllowSymbols, METH_VARARGS | METH_KEYWORDS, NULL},
28017          { (char *)"FontData_SetChosenFont", (PyCFunction) _wrap_FontData_SetChosenFont, METH_VARARGS | METH_KEYWORDS, NULL},
28018          { (char *)"FontData_SetColour", (PyCFunction) _wrap_FontData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28019          { (char *)"FontData_SetInitialFont", (PyCFunction) _wrap_FontData_SetInitialFont, METH_VARARGS | METH_KEYWORDS, NULL},
28020          { (char *)"FontData_SetRange", (PyCFunction) _wrap_FontData_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
28021          { (char *)"FontData_SetShowHelp", (PyCFunction) _wrap_FontData_SetShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28022          { (char *)"FontData_swigregister", FontData_swigregister, METH_VARARGS, NULL},
28023          { (char *)"new_FontDialog", (PyCFunction) _wrap_new_FontDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28024          { (char *)"FontDialog_GetFontData", (PyCFunction) _wrap_FontDialog_GetFontData, METH_VARARGS | METH_KEYWORDS, NULL},
28025          { (char *)"FontDialog_swigregister", FontDialog_swigregister, METH_VARARGS, NULL},
28026          { (char *)"new_MessageDialog", (PyCFunction) _wrap_new_MessageDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28027          { (char *)"MessageDialog_swigregister", MessageDialog_swigregister, METH_VARARGS, NULL},
28028          { (char *)"new_ProgressDialog", (PyCFunction) _wrap_new_ProgressDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28029          { (char *)"ProgressDialog_Update", (PyCFunction) _wrap_ProgressDialog_Update, METH_VARARGS | METH_KEYWORDS, NULL},
28030          { (char *)"ProgressDialog_Resume", (PyCFunction) _wrap_ProgressDialog_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
28031          { (char *)"ProgressDialog_swigregister", ProgressDialog_swigregister, METH_VARARGS, NULL},
28032          { (char *)"new_FindDialogEvent", (PyCFunction) _wrap_new_FindDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
28033          { (char *)"FindDialogEvent_GetFlags", (PyCFunction) _wrap_FindDialogEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28034          { (char *)"FindDialogEvent_GetFindString", (PyCFunction) _wrap_FindDialogEvent_GetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28035          { (char *)"FindDialogEvent_GetReplaceString", (PyCFunction) _wrap_FindDialogEvent_GetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28036          { (char *)"FindDialogEvent_GetDialog", (PyCFunction) _wrap_FindDialogEvent_GetDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28037          { (char *)"FindDialogEvent_SetFlags", (PyCFunction) _wrap_FindDialogEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28038          { (char *)"FindDialogEvent_SetFindString", (PyCFunction) _wrap_FindDialogEvent_SetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28039          { (char *)"FindDialogEvent_SetReplaceString", (PyCFunction) _wrap_FindDialogEvent_SetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28040          { (char *)"FindDialogEvent_swigregister", FindDialogEvent_swigregister, METH_VARARGS, NULL},
28041          { (char *)"new_FindReplaceData", (PyCFunction) _wrap_new_FindReplaceData, METH_VARARGS | METH_KEYWORDS, NULL},
28042          { (char *)"delete_FindReplaceData", (PyCFunction) _wrap_delete_FindReplaceData, METH_VARARGS | METH_KEYWORDS, NULL},
28043          { (char *)"FindReplaceData_GetFindString", (PyCFunction) _wrap_FindReplaceData_GetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28044          { (char *)"FindReplaceData_GetReplaceString", (PyCFunction) _wrap_FindReplaceData_GetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28045          { (char *)"FindReplaceData_GetFlags", (PyCFunction) _wrap_FindReplaceData_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28046          { (char *)"FindReplaceData_SetFlags", (PyCFunction) _wrap_FindReplaceData_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28047          { (char *)"FindReplaceData_SetFindString", (PyCFunction) _wrap_FindReplaceData_SetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28048          { (char *)"FindReplaceData_SetReplaceString", (PyCFunction) _wrap_FindReplaceData_SetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28049          { (char *)"FindReplaceData_swigregister", FindReplaceData_swigregister, METH_VARARGS, NULL},
28050          { (char *)"new_FindReplaceDialog", (PyCFunction) _wrap_new_FindReplaceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28051          { (char *)"new_PreFindReplaceDialog", (PyCFunction) _wrap_new_PreFindReplaceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28052          { (char *)"FindReplaceDialog_Create", (PyCFunction) _wrap_FindReplaceDialog_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28053          { (char *)"FindReplaceDialog_GetData", (PyCFunction) _wrap_FindReplaceDialog_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
28054          { (char *)"FindReplaceDialog_SetData", (PyCFunction) _wrap_FindReplaceDialog_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
28055          { (char *)"FindReplaceDialog_swigregister", FindReplaceDialog_swigregister, METH_VARARGS, NULL},
28056          { (char *)"new_MDIParentFrame", (PyCFunction) _wrap_new_MDIParentFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28057          { (char *)"new_PreMDIParentFrame", (PyCFunction) _wrap_new_PreMDIParentFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28058          { (char *)"MDIParentFrame_Create", (PyCFunction) _wrap_MDIParentFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28059          { (char *)"MDIParentFrame_ActivateNext", (PyCFunction) _wrap_MDIParentFrame_ActivateNext, METH_VARARGS | METH_KEYWORDS, NULL},
28060          { (char *)"MDIParentFrame_ActivatePrevious", (PyCFunction) _wrap_MDIParentFrame_ActivatePrevious, METH_VARARGS | METH_KEYWORDS, NULL},
28061          { (char *)"MDIParentFrame_ArrangeIcons", (PyCFunction) _wrap_MDIParentFrame_ArrangeIcons, METH_VARARGS | METH_KEYWORDS, NULL},
28062          { (char *)"MDIParentFrame_Cascade", (PyCFunction) _wrap_MDIParentFrame_Cascade, METH_VARARGS | METH_KEYWORDS, NULL},
28063          { (char *)"MDIParentFrame_GetActiveChild", (PyCFunction) _wrap_MDIParentFrame_GetActiveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28064          { (char *)"MDIParentFrame_GetClientWindow", (PyCFunction) _wrap_MDIParentFrame_GetClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28065          { (char *)"MDIParentFrame_GetToolBar", (PyCFunction) _wrap_MDIParentFrame_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
28066          { (char *)"MDIParentFrame_Tile", (PyCFunction) _wrap_MDIParentFrame_Tile, METH_VARARGS | METH_KEYWORDS, NULL},
28067          { (char *)"MDIParentFrame_swigregister", MDIParentFrame_swigregister, METH_VARARGS, NULL},
28068          { (char *)"new_MDIChildFrame", (PyCFunction) _wrap_new_MDIChildFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28069          { (char *)"new_PreMDIChildFrame", (PyCFunction) _wrap_new_PreMDIChildFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28070          { (char *)"MDIChildFrame_Create", (PyCFunction) _wrap_MDIChildFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28071          { (char *)"MDIChildFrame_Activate", (PyCFunction) _wrap_MDIChildFrame_Activate, METH_VARARGS | METH_KEYWORDS, NULL},
28072          { (char *)"MDIChildFrame_Maximize", (PyCFunction) _wrap_MDIChildFrame_Maximize, METH_VARARGS | METH_KEYWORDS, NULL},
28073          { (char *)"MDIChildFrame_Restore", (PyCFunction) _wrap_MDIChildFrame_Restore, METH_VARARGS | METH_KEYWORDS, NULL},
28074          { (char *)"MDIChildFrame_swigregister", MDIChildFrame_swigregister, METH_VARARGS, NULL},
28075          { (char *)"new_MDIClientWindow", (PyCFunction) _wrap_new_MDIClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28076          { (char *)"new_PreMDIClientWindow", (PyCFunction) _wrap_new_PreMDIClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28077          { (char *)"MDIClientWindow_Create", (PyCFunction) _wrap_MDIClientWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28078          { (char *)"MDIClientWindow_swigregister", MDIClientWindow_swigregister, METH_VARARGS, NULL},
28079          { (char *)"new_PyWindow", (PyCFunction) _wrap_new_PyWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28080          { (char *)"new_PrePyWindow", (PyCFunction) _wrap_new_PrePyWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28081          { (char *)"PyWindow__setCallbackInfo", (PyCFunction) _wrap_PyWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28082          { (char *)"PyWindow_SetBestSize", (PyCFunction) _wrap_PyWindow_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28083          { (char *)"PyWindow_base_DoMoveWindow", (PyCFunction) _wrap_PyWindow_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28084          { (char *)"PyWindow_base_DoSetSize", (PyCFunction) _wrap_PyWindow_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28085          { (char *)"PyWindow_base_DoSetClientSize", (PyCFunction) _wrap_PyWindow_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28086          { (char *)"PyWindow_base_DoSetVirtualSize", (PyCFunction) _wrap_PyWindow_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28087          { (char *)"PyWindow_base_DoGetSize", (PyCFunction) _wrap_PyWindow_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28088          { (char *)"PyWindow_base_DoGetClientSize", (PyCFunction) _wrap_PyWindow_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28089          { (char *)"PyWindow_base_DoGetPosition", (PyCFunction) _wrap_PyWindow_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28090          { (char *)"PyWindow_base_DoGetVirtualSize", (PyCFunction) _wrap_PyWindow_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28091          { (char *)"PyWindow_base_DoGetBestSize", (PyCFunction) _wrap_PyWindow_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28092          { (char *)"PyWindow_base_InitDialog", (PyCFunction) _wrap_PyWindow_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28093          { (char *)"PyWindow_base_TransferDataToWindow", (PyCFunction) _wrap_PyWindow_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28094          { (char *)"PyWindow_base_TransferDataFromWindow", (PyCFunction) _wrap_PyWindow_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28095          { (char *)"PyWindow_base_Validate", (PyCFunction) _wrap_PyWindow_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28096          { (char *)"PyWindow_base_AcceptsFocus", (PyCFunction) _wrap_PyWindow_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28097          { (char *)"PyWindow_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyWindow_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28098          { (char *)"PyWindow_base_GetMaxSize", (PyCFunction) _wrap_PyWindow_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28099          { (char *)"PyWindow_base_AddChild", (PyCFunction) _wrap_PyWindow_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28100          { (char *)"PyWindow_base_RemoveChild", (PyCFunction) _wrap_PyWindow_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28101          { (char *)"PyWindow_base_ShouldInheritColours", (PyCFunction) _wrap_PyWindow_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28102          { (char *)"PyWindow_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyWindow_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28103          { (char *)"PyWindow_base_GetDefaultAttributes", (PyCFunction) _wrap_PyWindow_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28104          { (char *)"PyWindow_swigregister", PyWindow_swigregister, METH_VARARGS, NULL},
28105          { (char *)"new_PyPanel", (PyCFunction) _wrap_new_PyPanel, METH_VARARGS | METH_KEYWORDS, NULL},
28106          { (char *)"new_PrePyPanel", (PyCFunction) _wrap_new_PrePyPanel, METH_VARARGS | METH_KEYWORDS, NULL},
28107          { (char *)"PyPanel__setCallbackInfo", (PyCFunction) _wrap_PyPanel__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28108          { (char *)"PyPanel_SetBestSize", (PyCFunction) _wrap_PyPanel_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28109          { (char *)"PyPanel_base_DoMoveWindow", (PyCFunction) _wrap_PyPanel_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28110          { (char *)"PyPanel_base_DoSetSize", (PyCFunction) _wrap_PyPanel_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28111          { (char *)"PyPanel_base_DoSetClientSize", (PyCFunction) _wrap_PyPanel_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28112          { (char *)"PyPanel_base_DoSetVirtualSize", (PyCFunction) _wrap_PyPanel_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28113          { (char *)"PyPanel_base_DoGetSize", (PyCFunction) _wrap_PyPanel_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28114          { (char *)"PyPanel_base_DoGetClientSize", (PyCFunction) _wrap_PyPanel_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28115          { (char *)"PyPanel_base_DoGetPosition", (PyCFunction) _wrap_PyPanel_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28116          { (char *)"PyPanel_base_DoGetVirtualSize", (PyCFunction) _wrap_PyPanel_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28117          { (char *)"PyPanel_base_DoGetBestSize", (PyCFunction) _wrap_PyPanel_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28118          { (char *)"PyPanel_base_InitDialog", (PyCFunction) _wrap_PyPanel_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28119          { (char *)"PyPanel_base_TransferDataToWindow", (PyCFunction) _wrap_PyPanel_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28120          { (char *)"PyPanel_base_TransferDataFromWindow", (PyCFunction) _wrap_PyPanel_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28121          { (char *)"PyPanel_base_Validate", (PyCFunction) _wrap_PyPanel_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28122          { (char *)"PyPanel_base_AcceptsFocus", (PyCFunction) _wrap_PyPanel_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28123          { (char *)"PyPanel_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyPanel_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28124          { (char *)"PyPanel_base_GetMaxSize", (PyCFunction) _wrap_PyPanel_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28125          { (char *)"PyPanel_base_AddChild", (PyCFunction) _wrap_PyPanel_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28126          { (char *)"PyPanel_base_RemoveChild", (PyCFunction) _wrap_PyPanel_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28127          { (char *)"PyPanel_base_ShouldInheritColours", (PyCFunction) _wrap_PyPanel_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28128          { (char *)"PyPanel_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyPanel_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28129          { (char *)"PyPanel_base_GetDefaultAttributes", (PyCFunction) _wrap_PyPanel_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28130          { (char *)"PyPanel_swigregister", PyPanel_swigregister, METH_VARARGS, NULL},
28131          { (char *)"new_PyScrolledWindow", (PyCFunction) _wrap_new_PyScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28132          { (char *)"new_PrePyScrolledWindow", (PyCFunction) _wrap_new_PrePyScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28133          { (char *)"PyScrolledWindow__setCallbackInfo", (PyCFunction) _wrap_PyScrolledWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28134          { (char *)"PyScrolledWindow_SetBestSize", (PyCFunction) _wrap_PyScrolledWindow_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28135          { (char *)"PyScrolledWindow_base_DoMoveWindow", (PyCFunction) _wrap_PyScrolledWindow_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28136          { (char *)"PyScrolledWindow_base_DoSetSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28137          { (char *)"PyScrolledWindow_base_DoSetClientSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28138          { (char *)"PyScrolledWindow_base_DoSetVirtualSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28139          { (char *)"PyScrolledWindow_base_DoGetSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28140          { (char *)"PyScrolledWindow_base_DoGetClientSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28141          { (char *)"PyScrolledWindow_base_DoGetPosition", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28142          { (char *)"PyScrolledWindow_base_DoGetVirtualSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28143          { (char *)"PyScrolledWindow_base_DoGetBestSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28144          { (char *)"PyScrolledWindow_base_InitDialog", (PyCFunction) _wrap_PyScrolledWindow_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28145          { (char *)"PyScrolledWindow_base_TransferDataToWindow", (PyCFunction) _wrap_PyScrolledWindow_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28146          { (char *)"PyScrolledWindow_base_TransferDataFromWindow", (PyCFunction) _wrap_PyScrolledWindow_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28147          { (char *)"PyScrolledWindow_base_Validate", (PyCFunction) _wrap_PyScrolledWindow_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28148          { (char *)"PyScrolledWindow_base_AcceptsFocus", (PyCFunction) _wrap_PyScrolledWindow_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28149          { (char *)"PyScrolledWindow_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyScrolledWindow_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28150          { (char *)"PyScrolledWindow_base_GetMaxSize", (PyCFunction) _wrap_PyScrolledWindow_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28151          { (char *)"PyScrolledWindow_base_AddChild", (PyCFunction) _wrap_PyScrolledWindow_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28152          { (char *)"PyScrolledWindow_base_RemoveChild", (PyCFunction) _wrap_PyScrolledWindow_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28153          { (char *)"PyScrolledWindow_base_ShouldInheritColours", (PyCFunction) _wrap_PyScrolledWindow_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28154          { (char *)"PyScrolledWindow_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyScrolledWindow_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28155          { (char *)"PyScrolledWindow_base_GetDefaultAttributes", (PyCFunction) _wrap_PyScrolledWindow_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28156          { (char *)"PyScrolledWindow_swigregister", PyScrolledWindow_swigregister, METH_VARARGS, NULL},
28157          { (char *)"new_PrintData", _wrap_new_PrintData, METH_VARARGS, NULL},
28158          { (char *)"delete_PrintData", (PyCFunction) _wrap_delete_PrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28159          { (char *)"PrintData_GetNoCopies", (PyCFunction) _wrap_PrintData_GetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28160          { (char *)"PrintData_GetCollate", (PyCFunction) _wrap_PrintData_GetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28161          { (char *)"PrintData_GetOrientation", (PyCFunction) _wrap_PrintData_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28162          { (char *)"PrintData_Ok", (PyCFunction) _wrap_PrintData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28163          { (char *)"PrintData_GetPrinterName", (PyCFunction) _wrap_PrintData_GetPrinterName, METH_VARARGS | METH_KEYWORDS, NULL},
28164          { (char *)"PrintData_GetColour", (PyCFunction) _wrap_PrintData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28165          { (char *)"PrintData_GetDuplex", (PyCFunction) _wrap_PrintData_GetDuplex, METH_VARARGS | METH_KEYWORDS, NULL},
28166          { (char *)"PrintData_GetPaperId", (PyCFunction) _wrap_PrintData_GetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28167          { (char *)"PrintData_GetPaperSize", (PyCFunction) _wrap_PrintData_GetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28168          { (char *)"PrintData_GetQuality", (PyCFunction) _wrap_PrintData_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
28169          { (char *)"PrintData_GetBin", (PyCFunction) _wrap_PrintData_GetBin, METH_VARARGS | METH_KEYWORDS, NULL},
28170          { (char *)"PrintData_GetPrintMode", (PyCFunction) _wrap_PrintData_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
28171          { (char *)"PrintData_SetNoCopies", (PyCFunction) _wrap_PrintData_SetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28172          { (char *)"PrintData_SetCollate", (PyCFunction) _wrap_PrintData_SetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28173          { (char *)"PrintData_SetOrientation", (PyCFunction) _wrap_PrintData_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28174          { (char *)"PrintData_SetPrinterName", (PyCFunction) _wrap_PrintData_SetPrinterName, METH_VARARGS | METH_KEYWORDS, NULL},
28175          { (char *)"PrintData_SetColour", (PyCFunction) _wrap_PrintData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28176          { (char *)"PrintData_SetDuplex", (PyCFunction) _wrap_PrintData_SetDuplex, METH_VARARGS | METH_KEYWORDS, NULL},
28177          { (char *)"PrintData_SetPaperId", (PyCFunction) _wrap_PrintData_SetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28178          { (char *)"PrintData_SetPaperSize", (PyCFunction) _wrap_PrintData_SetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28179          { (char *)"PrintData_SetQuality", (PyCFunction) _wrap_PrintData_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
28180          { (char *)"PrintData_SetBin", (PyCFunction) _wrap_PrintData_SetBin, METH_VARARGS | METH_KEYWORDS, NULL},
28181          { (char *)"PrintData_SetPrintMode", (PyCFunction) _wrap_PrintData_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
28182          { (char *)"PrintData_GetFilename", (PyCFunction) _wrap_PrintData_GetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28183          { (char *)"PrintData_SetFilename", (PyCFunction) _wrap_PrintData_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28184          { (char *)"PrintData_GetPrivData", (PyCFunction) _wrap_PrintData_GetPrivData, METH_VARARGS | METH_KEYWORDS, NULL},
28185          { (char *)"PrintData_SetPrivData", (PyCFunction) _wrap_PrintData_SetPrivData, METH_VARARGS | METH_KEYWORDS, NULL},
28186          { (char *)"PrintData_GetPrinterCommand", (PyCFunction) _wrap_PrintData_GetPrinterCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28187          { (char *)"PrintData_GetPrinterOptions", (PyCFunction) _wrap_PrintData_GetPrinterOptions, METH_VARARGS | METH_KEYWORDS, NULL},
28188          { (char *)"PrintData_GetPreviewCommand", (PyCFunction) _wrap_PrintData_GetPreviewCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28189          { (char *)"PrintData_GetFontMetricPath", (PyCFunction) _wrap_PrintData_GetFontMetricPath, METH_VARARGS | METH_KEYWORDS, NULL},
28190          { (char *)"PrintData_GetPrinterScaleX", (PyCFunction) _wrap_PrintData_GetPrinterScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
28191          { (char *)"PrintData_GetPrinterScaleY", (PyCFunction) _wrap_PrintData_GetPrinterScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
28192          { (char *)"PrintData_GetPrinterTranslateX", (PyCFunction) _wrap_PrintData_GetPrinterTranslateX, METH_VARARGS | METH_KEYWORDS, NULL},
28193          { (char *)"PrintData_GetPrinterTranslateY", (PyCFunction) _wrap_PrintData_GetPrinterTranslateY, METH_VARARGS | METH_KEYWORDS, NULL},
28194          { (char *)"PrintData_SetPrinterCommand", (PyCFunction) _wrap_PrintData_SetPrinterCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28195          { (char *)"PrintData_SetPrinterOptions", (PyCFunction) _wrap_PrintData_SetPrinterOptions, METH_VARARGS | METH_KEYWORDS, NULL},
28196          { (char *)"PrintData_SetPreviewCommand", (PyCFunction) _wrap_PrintData_SetPreviewCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28197          { (char *)"PrintData_SetFontMetricPath", (PyCFunction) _wrap_PrintData_SetFontMetricPath, METH_VARARGS | METH_KEYWORDS, NULL},
28198          { (char *)"PrintData_SetPrinterScaleX", (PyCFunction) _wrap_PrintData_SetPrinterScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
28199          { (char *)"PrintData_SetPrinterScaleY", (PyCFunction) _wrap_PrintData_SetPrinterScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
28200          { (char *)"PrintData_SetPrinterScaling", (PyCFunction) _wrap_PrintData_SetPrinterScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28201          { (char *)"PrintData_SetPrinterTranslateX", (PyCFunction) _wrap_PrintData_SetPrinterTranslateX, METH_VARARGS | METH_KEYWORDS, NULL},
28202          { (char *)"PrintData_SetPrinterTranslateY", (PyCFunction) _wrap_PrintData_SetPrinterTranslateY, METH_VARARGS | METH_KEYWORDS, NULL},
28203          { (char *)"PrintData_SetPrinterTranslation", (PyCFunction) _wrap_PrintData_SetPrinterTranslation, METH_VARARGS | METH_KEYWORDS, NULL},
28204          { (char *)"PrintData_swigregister", PrintData_swigregister, METH_VARARGS, NULL},
28205          { (char *)"new_PageSetupDialogData", _wrap_new_PageSetupDialogData, METH_VARARGS, NULL},
28206          { (char *)"delete_PageSetupDialogData", (PyCFunction) _wrap_delete_PageSetupDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28207          { (char *)"PageSetupDialogData_EnableHelp", (PyCFunction) _wrap_PageSetupDialogData_EnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28208          { (char *)"PageSetupDialogData_EnableMargins", (PyCFunction) _wrap_PageSetupDialogData_EnableMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28209          { (char *)"PageSetupDialogData_EnableOrientation", (PyCFunction) _wrap_PageSetupDialogData_EnableOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28210          { (char *)"PageSetupDialogData_EnablePaper", (PyCFunction) _wrap_PageSetupDialogData_EnablePaper, METH_VARARGS | METH_KEYWORDS, NULL},
28211          { (char *)"PageSetupDialogData_EnablePrinter", (PyCFunction) _wrap_PageSetupDialogData_EnablePrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28212          { (char *)"PageSetupDialogData_GetDefaultMinMargins", (PyCFunction) _wrap_PageSetupDialogData_GetDefaultMinMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28213          { (char *)"PageSetupDialogData_GetEnableMargins", (PyCFunction) _wrap_PageSetupDialogData_GetEnableMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28214          { (char *)"PageSetupDialogData_GetEnableOrientation", (PyCFunction) _wrap_PageSetupDialogData_GetEnableOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28215          { (char *)"PageSetupDialogData_GetEnablePaper", (PyCFunction) _wrap_PageSetupDialogData_GetEnablePaper, METH_VARARGS | METH_KEYWORDS, NULL},
28216          { (char *)"PageSetupDialogData_GetEnablePrinter", (PyCFunction) _wrap_PageSetupDialogData_GetEnablePrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28217          { (char *)"PageSetupDialogData_GetEnableHelp", (PyCFunction) _wrap_PageSetupDialogData_GetEnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28218          { (char *)"PageSetupDialogData_GetDefaultInfo", (PyCFunction) _wrap_PageSetupDialogData_GetDefaultInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28219          { (char *)"PageSetupDialogData_GetMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_GetMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28220          { (char *)"PageSetupDialogData_GetMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_GetMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28221          { (char *)"PageSetupDialogData_GetMinMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_GetMinMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28222          { (char *)"PageSetupDialogData_GetMinMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_GetMinMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28223          { (char *)"PageSetupDialogData_GetPaperId", (PyCFunction) _wrap_PageSetupDialogData_GetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28224          { (char *)"PageSetupDialogData_GetPaperSize", (PyCFunction) _wrap_PageSetupDialogData_GetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28225          { (char *)"PageSetupDialogData_GetPrintData", (PyCFunction) _wrap_PageSetupDialogData_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28226          { (char *)"PageSetupDialogData_Ok", (PyCFunction) _wrap_PageSetupDialogData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28227          { (char *)"PageSetupDialogData_SetDefaultInfo", (PyCFunction) _wrap_PageSetupDialogData_SetDefaultInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28228          { (char *)"PageSetupDialogData_SetDefaultMinMargins", (PyCFunction) _wrap_PageSetupDialogData_SetDefaultMinMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28229          { (char *)"PageSetupDialogData_SetMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_SetMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28230          { (char *)"PageSetupDialogData_SetMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_SetMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28231          { (char *)"PageSetupDialogData_SetMinMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_SetMinMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28232          { (char *)"PageSetupDialogData_SetMinMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_SetMinMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28233          { (char *)"PageSetupDialogData_SetPaperId", (PyCFunction) _wrap_PageSetupDialogData_SetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28234          { (char *)"PageSetupDialogData_SetPaperSize", (PyCFunction) _wrap_PageSetupDialogData_SetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28235          { (char *)"PageSetupDialogData_SetPrintData", (PyCFunction) _wrap_PageSetupDialogData_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28236          { (char *)"PageSetupDialogData_CalculateIdFromPaperSize", (PyCFunction) _wrap_PageSetupDialogData_CalculateIdFromPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28237          { (char *)"PageSetupDialogData_CalculatePaperSizeFromId", (PyCFunction) _wrap_PageSetupDialogData_CalculatePaperSizeFromId, METH_VARARGS | METH_KEYWORDS, NULL},
28238          { (char *)"PageSetupDialogData_swigregister", PageSetupDialogData_swigregister, METH_VARARGS, NULL},
28239          { (char *)"new_PageSetupDialog", (PyCFunction) _wrap_new_PageSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28240          { (char *)"PageSetupDialog_GetPageSetupData", (PyCFunction) _wrap_PageSetupDialog_GetPageSetupData, METH_VARARGS | METH_KEYWORDS, NULL},
28241          { (char *)"PageSetupDialog_GetPageSetupDialogData", (PyCFunction) _wrap_PageSetupDialog_GetPageSetupDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28242          { (char *)"PageSetupDialog_ShowModal", (PyCFunction) _wrap_PageSetupDialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
28243          { (char *)"PageSetupDialog_swigregister", PageSetupDialog_swigregister, METH_VARARGS, NULL},
28244          { (char *)"new_PrintDialogData", _wrap_new_PrintDialogData, METH_VARARGS, NULL},
28245          { (char *)"delete_PrintDialogData", (PyCFunction) _wrap_delete_PrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28246          { (char *)"PrintDialogData_GetFromPage", (PyCFunction) _wrap_PrintDialogData_GetFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
28247          { (char *)"PrintDialogData_GetToPage", (PyCFunction) _wrap_PrintDialogData_GetToPage, METH_VARARGS | METH_KEYWORDS, NULL},
28248          { (char *)"PrintDialogData_GetMinPage", (PyCFunction) _wrap_PrintDialogData_GetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28249          { (char *)"PrintDialogData_GetMaxPage", (PyCFunction) _wrap_PrintDialogData_GetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28250          { (char *)"PrintDialogData_GetNoCopies", (PyCFunction) _wrap_PrintDialogData_GetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28251          { (char *)"PrintDialogData_GetAllPages", (PyCFunction) _wrap_PrintDialogData_GetAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
28252          { (char *)"PrintDialogData_GetSelection", (PyCFunction) _wrap_PrintDialogData_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28253          { (char *)"PrintDialogData_GetCollate", (PyCFunction) _wrap_PrintDialogData_GetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28254          { (char *)"PrintDialogData_GetPrintToFile", (PyCFunction) _wrap_PrintDialogData_GetPrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28255          { (char *)"PrintDialogData_GetSetupDialog", (PyCFunction) _wrap_PrintDialogData_GetSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28256          { (char *)"PrintDialogData_SetSetupDialog", (PyCFunction) _wrap_PrintDialogData_SetSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28257          { (char *)"PrintDialogData_SetFromPage", (PyCFunction) _wrap_PrintDialogData_SetFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
28258          { (char *)"PrintDialogData_SetToPage", (PyCFunction) _wrap_PrintDialogData_SetToPage, METH_VARARGS | METH_KEYWORDS, NULL},
28259          { (char *)"PrintDialogData_SetMinPage", (PyCFunction) _wrap_PrintDialogData_SetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28260          { (char *)"PrintDialogData_SetMaxPage", (PyCFunction) _wrap_PrintDialogData_SetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28261          { (char *)"PrintDialogData_SetNoCopies", (PyCFunction) _wrap_PrintDialogData_SetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28262          { (char *)"PrintDialogData_SetAllPages", (PyCFunction) _wrap_PrintDialogData_SetAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
28263          { (char *)"PrintDialogData_SetSelection", (PyCFunction) _wrap_PrintDialogData_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28264          { (char *)"PrintDialogData_SetCollate", (PyCFunction) _wrap_PrintDialogData_SetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28265          { (char *)"PrintDialogData_SetPrintToFile", (PyCFunction) _wrap_PrintDialogData_SetPrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28266          { (char *)"PrintDialogData_EnablePrintToFile", (PyCFunction) _wrap_PrintDialogData_EnablePrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28267          { (char *)"PrintDialogData_EnableSelection", (PyCFunction) _wrap_PrintDialogData_EnableSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28268          { (char *)"PrintDialogData_EnablePageNumbers", (PyCFunction) _wrap_PrintDialogData_EnablePageNumbers, METH_VARARGS | METH_KEYWORDS, NULL},
28269          { (char *)"PrintDialogData_EnableHelp", (PyCFunction) _wrap_PrintDialogData_EnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28270          { (char *)"PrintDialogData_GetEnablePrintToFile", (PyCFunction) _wrap_PrintDialogData_GetEnablePrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28271          { (char *)"PrintDialogData_GetEnableSelection", (PyCFunction) _wrap_PrintDialogData_GetEnableSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28272          { (char *)"PrintDialogData_GetEnablePageNumbers", (PyCFunction) _wrap_PrintDialogData_GetEnablePageNumbers, METH_VARARGS | METH_KEYWORDS, NULL},
28273          { (char *)"PrintDialogData_GetEnableHelp", (PyCFunction) _wrap_PrintDialogData_GetEnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28274          { (char *)"PrintDialogData_Ok", (PyCFunction) _wrap_PrintDialogData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28275          { (char *)"PrintDialogData_GetPrintData", (PyCFunction) _wrap_PrintDialogData_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28276          { (char *)"PrintDialogData_SetPrintData", (PyCFunction) _wrap_PrintDialogData_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28277          { (char *)"PrintDialogData_swigregister", PrintDialogData_swigregister, METH_VARARGS, NULL},
28278          { (char *)"new_PrintDialog", (PyCFunction) _wrap_new_PrintDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28279          { (char *)"PrintDialog_ShowModal", (PyCFunction) _wrap_PrintDialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
28280          { (char *)"PrintDialog_GetPrintDialogData", (PyCFunction) _wrap_PrintDialog_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28281          { (char *)"PrintDialog_GetPrintData", (PyCFunction) _wrap_PrintDialog_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28282          { (char *)"PrintDialog_GetPrintDC", (PyCFunction) _wrap_PrintDialog_GetPrintDC, METH_VARARGS | METH_KEYWORDS, NULL},
28283          { (char *)"PrintDialog_swigregister", PrintDialog_swigregister, METH_VARARGS, NULL},
28284          { (char *)"new_Printer", (PyCFunction) _wrap_new_Printer, METH_VARARGS | METH_KEYWORDS, NULL},
28285          { (char *)"delete_Printer", (PyCFunction) _wrap_delete_Printer, METH_VARARGS | METH_KEYWORDS, NULL},
28286          { (char *)"Printer_CreateAbortWindow", (PyCFunction) _wrap_Printer_CreateAbortWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28287          { (char *)"Printer_ReportError", (PyCFunction) _wrap_Printer_ReportError, METH_VARARGS | METH_KEYWORDS, NULL},
28288          { (char *)"Printer_Setup", (PyCFunction) _wrap_Printer_Setup, METH_VARARGS | METH_KEYWORDS, NULL},
28289          { (char *)"Printer_Print", (PyCFunction) _wrap_Printer_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28290          { (char *)"Printer_PrintDialog", (PyCFunction) _wrap_Printer_PrintDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28291          { (char *)"Printer_GetPrintDialogData", (PyCFunction) _wrap_Printer_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28292          { (char *)"Printer_GetAbort", (PyCFunction) _wrap_Printer_GetAbort, METH_VARARGS | METH_KEYWORDS, NULL},
28293          { (char *)"Printer_GetLastError", (PyCFunction) _wrap_Printer_GetLastError, METH_VARARGS | METH_KEYWORDS, NULL},
28294          { (char *)"Printer_swigregister", Printer_swigregister, METH_VARARGS, NULL},
28295          { (char *)"new_Printout", (PyCFunction) _wrap_new_Printout, METH_VARARGS | METH_KEYWORDS, NULL},
28296          { (char *)"Printout__setCallbackInfo", (PyCFunction) _wrap_Printout__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28297          { (char *)"Printout_GetTitle", (PyCFunction) _wrap_Printout_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
28298          { (char *)"Printout_GetDC", (PyCFunction) _wrap_Printout_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
28299          { (char *)"Printout_SetDC", (PyCFunction) _wrap_Printout_SetDC, METH_VARARGS | METH_KEYWORDS, NULL},
28300          { (char *)"Printout_SetPageSizePixels", (PyCFunction) _wrap_Printout_SetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
28301          { (char *)"Printout_GetPageSizePixels", (PyCFunction) _wrap_Printout_GetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
28302          { (char *)"Printout_SetPageSizeMM", (PyCFunction) _wrap_Printout_SetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
28303          { (char *)"Printout_GetPageSizeMM", (PyCFunction) _wrap_Printout_GetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
28304          { (char *)"Printout_SetPPIScreen", (PyCFunction) _wrap_Printout_SetPPIScreen, METH_VARARGS | METH_KEYWORDS, NULL},
28305          { (char *)"Printout_GetPPIScreen", (PyCFunction) _wrap_Printout_GetPPIScreen, METH_VARARGS | METH_KEYWORDS, NULL},
28306          { (char *)"Printout_SetPPIPrinter", (PyCFunction) _wrap_Printout_SetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28307          { (char *)"Printout_GetPPIPrinter", (PyCFunction) _wrap_Printout_GetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28308          { (char *)"Printout_IsPreview", (PyCFunction) _wrap_Printout_IsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28309          { (char *)"Printout_SetIsPreview", (PyCFunction) _wrap_Printout_SetIsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28310          { (char *)"Printout_base_OnBeginDocument", (PyCFunction) _wrap_Printout_base_OnBeginDocument, METH_VARARGS | METH_KEYWORDS, NULL},
28311          { (char *)"Printout_base_OnEndDocument", (PyCFunction) _wrap_Printout_base_OnEndDocument, METH_VARARGS | METH_KEYWORDS, NULL},
28312          { (char *)"Printout_base_OnBeginPrinting", (PyCFunction) _wrap_Printout_base_OnBeginPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28313          { (char *)"Printout_base_OnEndPrinting", (PyCFunction) _wrap_Printout_base_OnEndPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28314          { (char *)"Printout_base_OnPreparePrinting", (PyCFunction) _wrap_Printout_base_OnPreparePrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28315          { (char *)"Printout_base_HasPage", (PyCFunction) _wrap_Printout_base_HasPage, METH_VARARGS | METH_KEYWORDS, NULL},
28316          { (char *)"Printout_base_GetPageInfo", (PyCFunction) _wrap_Printout_base_GetPageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28317          { (char *)"Printout_swigregister", Printout_swigregister, METH_VARARGS, NULL},
28318          { (char *)"new_PreviewCanvas", (PyCFunction) _wrap_new_PreviewCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28319          { (char *)"PreviewCanvas_swigregister", PreviewCanvas_swigregister, METH_VARARGS, NULL},
28320          { (char *)"new_PreviewFrame", (PyCFunction) _wrap_new_PreviewFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28321          { (char *)"PreviewFrame_Initialize", (PyCFunction) _wrap_PreviewFrame_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
28322          { (char *)"PreviewFrame_CreateControlBar", (PyCFunction) _wrap_PreviewFrame_CreateControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28323          { (char *)"PreviewFrame_CreateCanvas", (PyCFunction) _wrap_PreviewFrame_CreateCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28324          { (char *)"PreviewFrame_GetControlBar", (PyCFunction) _wrap_PreviewFrame_GetControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28325          { (char *)"PreviewFrame_swigregister", PreviewFrame_swigregister, METH_VARARGS, NULL},
28326          { (char *)"new_PreviewControlBar", (PyCFunction) _wrap_new_PreviewControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28327          { (char *)"PreviewControlBar_GetZoomControl", (PyCFunction) _wrap_PreviewControlBar_GetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28328          { (char *)"PreviewControlBar_SetZoomControl", (PyCFunction) _wrap_PreviewControlBar_SetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28329          { (char *)"PreviewControlBar_GetPrintPreview", (PyCFunction) _wrap_PreviewControlBar_GetPrintPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28330          { (char *)"PreviewControlBar_OnNext", (PyCFunction) _wrap_PreviewControlBar_OnNext, METH_VARARGS | METH_KEYWORDS, NULL},
28331          { (char *)"PreviewControlBar_OnPrevious", (PyCFunction) _wrap_PreviewControlBar_OnPrevious, METH_VARARGS | METH_KEYWORDS, NULL},
28332          { (char *)"PreviewControlBar_OnFirst", (PyCFunction) _wrap_PreviewControlBar_OnFirst, METH_VARARGS | METH_KEYWORDS, NULL},
28333          { (char *)"PreviewControlBar_OnLast", (PyCFunction) _wrap_PreviewControlBar_OnLast, METH_VARARGS | METH_KEYWORDS, NULL},
28334          { (char *)"PreviewControlBar_OnGoto", (PyCFunction) _wrap_PreviewControlBar_OnGoto, METH_VARARGS | METH_KEYWORDS, NULL},
28335          { (char *)"PreviewControlBar_swigregister", PreviewControlBar_swigregister, METH_VARARGS, NULL},
28336          { (char *)"new_PrintPreview", _wrap_new_PrintPreview, METH_VARARGS, NULL},
28337          { (char *)"PrintPreview_SetCurrentPage", (PyCFunction) _wrap_PrintPreview_SetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28338          { (char *)"PrintPreview_GetCurrentPage", (PyCFunction) _wrap_PrintPreview_GetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28339          { (char *)"PrintPreview_SetPrintout", (PyCFunction) _wrap_PrintPreview_SetPrintout, METH_VARARGS | METH_KEYWORDS, NULL},
28340          { (char *)"PrintPreview_GetPrintout", (PyCFunction) _wrap_PrintPreview_GetPrintout, METH_VARARGS | METH_KEYWORDS, NULL},
28341          { (char *)"PrintPreview_GetPrintoutForPrinting", (PyCFunction) _wrap_PrintPreview_GetPrintoutForPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28342          { (char *)"PrintPreview_SetFrame", (PyCFunction) _wrap_PrintPreview_SetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28343          { (char *)"PrintPreview_SetCanvas", (PyCFunction) _wrap_PrintPreview_SetCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28344          { (char *)"PrintPreview_GetFrame", (PyCFunction) _wrap_PrintPreview_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28345          { (char *)"PrintPreview_GetCanvas", (PyCFunction) _wrap_PrintPreview_GetCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28346          { (char *)"PrintPreview_PaintPage", (PyCFunction) _wrap_PrintPreview_PaintPage, METH_VARARGS | METH_KEYWORDS, NULL},
28347          { (char *)"PrintPreview_DrawBlankPage", (PyCFunction) _wrap_PrintPreview_DrawBlankPage, METH_VARARGS | METH_KEYWORDS, NULL},
28348          { (char *)"PrintPreview_RenderPage", (PyCFunction) _wrap_PrintPreview_RenderPage, METH_VARARGS | METH_KEYWORDS, NULL},
28349          { (char *)"PrintPreview_AdjustScrollbars", (PyCFunction) _wrap_PrintPreview_AdjustScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
28350          { (char *)"PrintPreview_GetPrintDialogData", (PyCFunction) _wrap_PrintPreview_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28351          { (char *)"PrintPreview_SetZoom", (PyCFunction) _wrap_PrintPreview_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28352          { (char *)"PrintPreview_GetZoom", (PyCFunction) _wrap_PrintPreview_GetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28353          { (char *)"PrintPreview_GetMaxPage", (PyCFunction) _wrap_PrintPreview_GetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28354          { (char *)"PrintPreview_GetMinPage", (PyCFunction) _wrap_PrintPreview_GetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28355          { (char *)"PrintPreview_Ok", (PyCFunction) _wrap_PrintPreview_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28356          { (char *)"PrintPreview_SetOk", (PyCFunction) _wrap_PrintPreview_SetOk, METH_VARARGS | METH_KEYWORDS, NULL},
28357          { (char *)"PrintPreview_Print", (PyCFunction) _wrap_PrintPreview_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28358          { (char *)"PrintPreview_DetermineScaling", (PyCFunction) _wrap_PrintPreview_DetermineScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28359          { (char *)"PrintPreview_swigregister", PrintPreview_swigregister, METH_VARARGS, NULL},
28360          { (char *)"new_PyPrintPreview", _wrap_new_PyPrintPreview, METH_VARARGS, NULL},
28361          { (char *)"PyPrintPreview__setCallbackInfo", (PyCFunction) _wrap_PyPrintPreview__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28362          { (char *)"PyPrintPreview_base_SetCurrentPage", (PyCFunction) _wrap_PyPrintPreview_base_SetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28363          { (char *)"PyPrintPreview_base_PaintPage", (PyCFunction) _wrap_PyPrintPreview_base_PaintPage, METH_VARARGS | METH_KEYWORDS, NULL},
28364          { (char *)"PyPrintPreview_base_DrawBlankPage", (PyCFunction) _wrap_PyPrintPreview_base_DrawBlankPage, METH_VARARGS | METH_KEYWORDS, NULL},
28365          { (char *)"PyPrintPreview_base_RenderPage", (PyCFunction) _wrap_PyPrintPreview_base_RenderPage, METH_VARARGS | METH_KEYWORDS, NULL},
28366          { (char *)"PyPrintPreview_base_SetZoom", (PyCFunction) _wrap_PyPrintPreview_base_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28367          { (char *)"PyPrintPreview_base_Print", (PyCFunction) _wrap_PyPrintPreview_base_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28368          { (char *)"PyPrintPreview_base_DetermineScaling", (PyCFunction) _wrap_PyPrintPreview_base_DetermineScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28369          { (char *)"PyPrintPreview_swigregister", PyPrintPreview_swigregister, METH_VARARGS, NULL},
28370          { (char *)"new_PyPreviewFrame", (PyCFunction) _wrap_new_PyPreviewFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28371          { (char *)"PyPreviewFrame__setCallbackInfo", (PyCFunction) _wrap_PyPreviewFrame__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28372          { (char *)"PyPreviewFrame_SetPreviewCanvas", (PyCFunction) _wrap_PyPreviewFrame_SetPreviewCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28373          { (char *)"PyPreviewFrame_SetControlBar", (PyCFunction) _wrap_PyPreviewFrame_SetControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28374          { (char *)"PyPreviewFrame_base_Initialize", (PyCFunction) _wrap_PyPreviewFrame_base_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
28375          { (char *)"PyPreviewFrame_base_CreateCanvas", (PyCFunction) _wrap_PyPreviewFrame_base_CreateCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28376          { (char *)"PyPreviewFrame_base_CreateControlBar", (PyCFunction) _wrap_PyPreviewFrame_base_CreateControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28377          { (char *)"PyPreviewFrame_swigregister", PyPreviewFrame_swigregister, METH_VARARGS, NULL},
28378          { (char *)"new_PyPreviewControlBar", (PyCFunction) _wrap_new_PyPreviewControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28379          { (char *)"PyPreviewControlBar__setCallbackInfo", (PyCFunction) _wrap_PyPreviewControlBar__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28380          { (char *)"PyPreviewControlBar_SetPrintPreview", (PyCFunction) _wrap_PyPreviewControlBar_SetPrintPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28381          { (char *)"PyPreviewControlBar_base_CreateButtons", (PyCFunction) _wrap_PyPreviewControlBar_base_CreateButtons, METH_VARARGS | METH_KEYWORDS, NULL},
28382          { (char *)"PyPreviewControlBar_base_SetZoomControl", (PyCFunction) _wrap_PyPreviewControlBar_base_SetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28383          { (char *)"PyPreviewControlBar_swigregister", PyPreviewControlBar_swigregister, METH_VARARGS, NULL},
28384          { NULL, NULL, 0, NULL }
28385 };
28386
28387
28388 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
28389
28390 static void *_p_wxPyPreviewFrameTo_p_wxPreviewFrame(void *x) {
28391     return (void *)((wxPreviewFrame *)  ((wxPyPreviewFrame *) x));
28392 }
28393 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
28394     return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
28395 }
28396 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
28397     return (void *)((wxEvent *)  ((wxMenuEvent *) x));
28398 }
28399 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
28400     return (void *)((wxEvent *)  ((wxCloseEvent *) x));
28401 }
28402 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
28403     return (void *)((wxEvent *)  ((wxMouseEvent *) x));
28404 }
28405 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
28406     return (void *)((wxEvent *)  ((wxEraseEvent *) x));
28407 }
28408 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
28409     return (void *)((wxEvent *)  ((wxSetCursorEvent *) x));
28410 }
28411 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
28412     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
28413 }
28414 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
28415     return (void *)((wxEvent *)  ((wxInitDialogEvent *) x));
28416 }
28417 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
28418     return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
28419 }
28420 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
28421     return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
28422 }
28423 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
28424     return (void *)((wxEvent *)  ((wxPyEvent *) x));
28425 }
28426 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
28427     return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
28428 }
28429 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
28430     return (void *)((wxEvent *)  ((wxCalculateLayoutEvent *) x));
28431 }
28432 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
28433     return (void *)((wxEvent *)  ((wxIdleEvent *) x));
28434 }
28435 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
28436     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
28437 }
28438 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
28439     return (void *)((wxEvent *)  ((wxQueryNewPaletteEvent *) x));
28440 }
28441 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
28442     return (void *)((wxEvent *)  ((wxMaximizeEvent *) x));
28443 }
28444 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
28445     return (void *)((wxEvent *)  ((wxIconizeEvent *) x));
28446 }
28447 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
28448     return (void *)((wxEvent *)  ((wxActivateEvent *) x));
28449 }
28450 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
28451     return (void *)((wxEvent *)  ((wxSizeEvent *) x));
28452 }
28453 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
28454     return (void *)((wxEvent *)  ((wxMoveEvent *) x));
28455 }
28456 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
28457     return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
28458 }
28459 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
28460     return (void *)((wxEvent *)  ((wxPaintEvent *) x));
28461 }
28462 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
28463     return (void *)((wxEvent *)  ((wxNcPaintEvent *) x));
28464 }
28465 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
28466     return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
28467 }
28468 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
28469     return (void *)((wxEvent *)  ((wxPaletteChangedEvent *) x));
28470 }
28471 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
28472     return (void *)((wxEvent *)  ((wxDisplayChangedEvent *) x));
28473 }
28474 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
28475     return (void *)((wxEvent *)  ((wxMouseCaptureChangedEvent *) x));
28476 }
28477 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
28478     return (void *)((wxEvent *)  ((wxSysColourChangedEvent *) x));
28479 }
28480 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
28481     return (void *)((wxEvent *)  ((wxDropFilesEvent *) x));
28482 }
28483 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
28484     return (void *)((wxEvent *)  ((wxFocusEvent *) x));
28485 }
28486 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
28487     return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
28488 }
28489 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
28490     return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
28491 }
28492 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
28493     return (void *)((wxEvent *)  ((wxQueryLayoutInfoEvent *) x));
28494 }
28495 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
28496     return (void *)((wxEvent *)  ((wxShowEvent *) x));
28497 }
28498 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
28499     return (void *)((wxEvent *)  ((wxCommandEvent *) x));
28500 }
28501 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
28502     return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
28503 }
28504 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
28505     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
28506 }
28507 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
28508     return (void *)((wxEvent *)  ((wxNavigationKeyEvent *) x));
28509 }
28510 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
28511     return (void *)((wxEvent *)  ((wxKeyEvent *) x));
28512 }
28513 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
28514     return (void *)((wxEvent *)  ((wxScrollWinEvent *) x));
28515 }
28516 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
28517     return (void *)((wxEvent *)  ((wxTaskBarIconEvent *) x));
28518 }
28519 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
28520     return (void *)((wxNotifyEvent *)  ((wxSplitterEvent *) x));
28521 }
28522 static void *_p_wxPasswordEntryDialogTo_p_wxTextEntryDialog(void *x) {
28523     return (void *)((wxTextEntryDialog *)  ((wxPasswordEntryDialog *) x));
28524 }
28525 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
28526     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
28527 }
28528 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
28529     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
28530 }
28531 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
28532     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
28533 }
28534 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
28535     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
28536 }
28537 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
28538     return (void *)((wxEvtHandler *)  ((wxValidator *) x));
28539 }
28540 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
28541     return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
28542 }
28543 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
28544     return (void *)((wxEvtHandler *)  ((wxMenu *) x));
28545 }
28546 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
28547     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
28548 }
28549 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
28550     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
28551 }
28552 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
28553     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
28554 }
28555 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
28556     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
28557 }
28558 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
28559     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
28560 }
28561 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
28562     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
28563 }
28564 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
28565     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
28566 }
28567 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
28568     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
28569 }
28570 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
28571     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
28572 }
28573 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
28574     return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
28575 }
28576 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
28577     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
28578 }
28579 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
28580     return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
28581 }
28582 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
28583     return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
28584 }
28585 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
28586     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
28587 }
28588 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
28589     return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
28590 }
28591 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
28592     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
28593 }
28594 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
28595     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
28596 }
28597 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
28598     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
28599 }
28600 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
28601     return (void *)((wxEvtHandler *)  ((wxWindow *) x));
28602 }
28603 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
28604     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
28605 }
28606 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
28607     return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
28608 }
28609 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
28610     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
28611 }
28612 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
28613     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
28614 }
28615 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
28616     return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
28617 }
28618 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
28619     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
28620 }
28621 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
28622     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28623 }
28624 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
28625     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
28626 }
28627 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
28628     return (void *)((wxEvtHandler *)  ((wxPyApp *) x));
28629 }
28630 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
28631     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
28632 }
28633 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
28634     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
28635 }
28636 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
28637     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
28638 }
28639 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
28640     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
28641 }
28642 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
28643     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
28644 }
28645 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
28646     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
28647 }
28648 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
28649     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
28650 }
28651 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
28652     return (void *)((wxEvtHandler *)  ((wxPyTaskBarIcon *) x));
28653 }
28654 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
28655     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
28656 }
28657 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
28658     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
28659 }
28660 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
28661     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
28662 }
28663 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
28664     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
28665 }
28666 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
28667     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
28668 }
28669 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
28670     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
28671 }
28672 static void *_p_wxPyHtmlListBoxTo_p_wxPyVListBox(void *x) {
28673     return (void *)((wxPyVListBox *)  ((wxPyHtmlListBox *) x));
28674 }
28675 static void *_p_wxMDIChildFrameTo_p_wxFrame(void *x) {
28676     return (void *)((wxFrame *)  ((wxMDIChildFrame *) x));
28677 }
28678 static void *_p_wxProgressDialogTo_p_wxFrame(void *x) {
28679     return (void *)((wxFrame *)  ((wxProgressDialog *) x));
28680 }
28681 static void *_p_wxPreviewFrameTo_p_wxFrame(void *x) {
28682     return (void *)((wxFrame *)  ((wxPreviewFrame *) x));
28683 }
28684 static void *_p_wxPyPreviewFrameTo_p_wxFrame(void *x) {
28685     return (void *)((wxFrame *) (wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28686 }
28687 static void *_p_wxMiniFrameTo_p_wxFrame(void *x) {
28688     return (void *)((wxFrame *)  ((wxMiniFrame *) x));
28689 }
28690 static void *_p_wxSplashScreenTo_p_wxFrame(void *x) {
28691     return (void *)((wxFrame *)  ((wxSplashScreen *) x));
28692 }
28693 static void *_p_wxMDIParentFrameTo_p_wxFrame(void *x) {
28694     return (void *)((wxFrame *)  ((wxMDIParentFrame *) x));
28695 }
28696 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
28697     return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
28698 }
28699 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
28700     return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
28701 }
28702 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
28703     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
28704 }
28705 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
28706     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28707 }
28708 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
28709     return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
28710 }
28711 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
28712     return (void *)((wxObject *)  ((wxSizerItem *) x));
28713 }
28714 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
28715     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
28716 }
28717 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
28718     return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
28719 }
28720 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
28721     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
28722 }
28723 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
28724     return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
28725 }
28726 static void *_p_wxSizerTo_p_wxObject(void *x) {
28727     return (void *)((wxObject *)  ((wxSizer *) x));
28728 }
28729 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
28730     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
28731 }
28732 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
28733     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
28734 }
28735 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
28736     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
28737 }
28738 static void *_p_wxEventTo_p_wxObject(void *x) {
28739     return (void *)((wxObject *)  ((wxEvent *) x));
28740 }
28741 static void *_p_wxFontDataTo_p_wxObject(void *x) {
28742     return (void *)((wxObject *)  ((wxFontData *) x));
28743 }
28744 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
28745     return (void *)((wxObject *)  ((wxPrintData *) x));
28746 }
28747 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
28748     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
28749 }
28750 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
28751     return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
28752 }
28753 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
28754     return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
28755 }
28756 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
28757     return (void *)((wxObject *)  ((wxLayoutAlgorithm *) x));
28758 }
28759 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
28760     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
28761 }
28762 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
28763     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
28764 }
28765 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
28766     return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
28767 }
28768 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
28769     return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
28770 }
28771 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
28772     return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
28773 }
28774 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
28775     return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
28776 }
28777 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
28778     return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
28779 }
28780 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
28781     return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
28782 }
28783 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
28784     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
28785 }
28786 static void *_p_wxControlTo_p_wxObject(void *x) {
28787     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
28788 }
28789 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
28790     return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
28791 }
28792 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
28793     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
28794 }
28795 static void *_p_wxFSFileTo_p_wxObject(void *x) {
28796     return (void *)((wxObject *)  ((wxFSFile *) x));
28797 }
28798 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
28799     return (void *)((wxObject *)  ((wxFindReplaceData *) x));
28800 }
28801 static void *_p_wxPySizerTo_p_wxObject(void *x) {
28802     return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
28803 }
28804 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
28805     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
28806 }
28807 static void *_p_wxColourDataTo_p_wxObject(void *x) {
28808     return (void *)((wxObject *)  ((wxColourData *) x));
28809 }
28810 static void *_p_wxPyEventTo_p_wxObject(void *x) {
28811     return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
28812 }
28813 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
28814     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
28815 }
28816 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
28817     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
28818 }
28819 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
28820     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
28821 }
28822 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
28823     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
28824 }
28825 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
28826     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
28827 }
28828 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
28829     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
28830 }
28831 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
28832     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
28833 }
28834 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
28835     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
28836 }
28837 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
28838     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
28839 }
28840 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
28841     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
28842 }
28843 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
28844     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
28845 }
28846 static void *_p_wxShowEventTo_p_wxObject(void *x) {
28847     return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
28848 }
28849 static void *_p_wxPrinterTo_p_wxObject(void *x) {
28850     return (void *)((wxObject *)  ((wxPrinter *) x));
28851 }
28852 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
28853     return (void *)((wxObject *)  ((wxMenuItem *) x));
28854 }
28855 static void *_p_wxDateEventTo_p_wxObject(void *x) {
28856     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
28857 }
28858 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
28859     return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
28860 }
28861 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
28862     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
28863 }
28864 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
28865     return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
28866 }
28867 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
28868     return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
28869 }
28870 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
28871     return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
28872 }
28873 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
28874     return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
28875 }
28876 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
28877     return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
28878 }
28879 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
28880     return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
28881 }
28882 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
28883     return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
28884 }
28885 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
28886     return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
28887 }
28888 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
28889     return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
28890 }
28891 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
28892     return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
28893 }
28894 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
28895     return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
28896 }
28897 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
28898     return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
28899 }
28900 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
28901     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
28902 }
28903 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
28904     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
28905 }
28906 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
28907     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
28908 }
28909 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
28910     return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
28911 }
28912 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
28913     return (void *)((wxObject *)  ((wxImageHandler *) x));
28914 }
28915 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
28916     return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
28917 }
28918 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
28919     return (void *)((wxObject *)  ((wxEvtHandler *) x));
28920 }
28921 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
28922     return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
28923 }
28924 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
28925     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
28926 }
28927 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
28928     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
28929 }
28930 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
28931     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
28932 }
28933 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
28934     return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
28935 }
28936 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
28937     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
28938 }
28939 static void *_p_wxImageTo_p_wxObject(void *x) {
28940     return (void *)((wxObject *)  ((wxImage *) x));
28941 }
28942 static void *_p_wxFrameTo_p_wxObject(void *x) {
28943     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
28944 }
28945 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
28946     return (void *)((wxObject *)  ((wxPyPrintout *) x));
28947 }
28948 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
28949     return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
28950 }
28951 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
28952     return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
28953 }
28954 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
28955     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
28956 }
28957 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
28958     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
28959 }
28960 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
28961     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
28962 }
28963 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
28964     return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
28965 }
28966 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
28967     return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
28968 }
28969 static void *_p_wxWindowTo_p_wxObject(void *x) {
28970     return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
28971 }
28972 static void *_p_wxMenuTo_p_wxObject(void *x) {
28973     return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
28974 }
28975 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
28976     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
28977 }
28978 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
28979     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
28980 }
28981 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
28982     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
28983 }
28984 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
28985     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
28986 }
28987 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
28988     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
28989 }
28990 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
28991     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
28992 }
28993 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
28994     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
28995 }
28996 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
28997     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
28998 }
28999 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
29000     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
29001 }
29002 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
29003     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29004 }
29005 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
29006     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
29007 }
29008 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
29009     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
29010 }
29011 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
29012     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29013 }
29014 static void *_p_wxSashEventTo_p_wxObject(void *x) {
29015     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
29016 }
29017 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
29018     return (void *)((wxObject *)  ((wxPrintPreview *) x));
29019 }
29020 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
29021     return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
29022 }
29023 static void *_p_wxPanelTo_p_wxObject(void *x) {
29024     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
29025 }
29026 static void *_p_wxDialogTo_p_wxObject(void *x) {
29027     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
29028 }
29029 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
29030     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
29031 }
29032 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
29033     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
29034 }
29035 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
29036     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
29037 }
29038 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
29039     return (void *)((wxObject *)  ((wxPageSetupDialog *) x));
29040 }
29041 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
29042     return (void *)((wxObject *)  ((wxPrintDialog *) x));
29043 }
29044 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
29045     return (void *)((wxObject *)  ((wxFileSystem *) x));
29046 }
29047 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
29048     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
29049 }
29050 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
29051     return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
29052 }
29053 static void *_p_wxPyAppTo_p_wxObject(void *x) {
29054     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
29055 }
29056 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
29057     return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
29058 }
29059 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
29060     return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
29061 }
29062 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
29063     return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
29064 }
29065 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
29066     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
29067 }
29068 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
29069     return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
29070 }
29071 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
29072     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
29073 }
29074 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
29075     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29076 }
29077 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
29078     return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
29079 }
29080 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
29081     return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
29082 }
29083 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
29084     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
29085 }
29086 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
29087     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
29088 }
29089 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
29090     return (void *)((wxObject *)  ((wxPageSetupDialogData *) x));
29091 }
29092 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
29093     return (void *)((wxObject *)  ((wxPrintDialogData *) x));
29094 }
29095 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
29096     return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
29097 }
29098 static void *_p_wxValidatorTo_p_wxObject(void *x) {
29099     return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
29100 }
29101 static void *_p_wxPyVListBoxTo_p_wxPyVScrolledWindow(void *x) {
29102     return (void *)((wxPyVScrolledWindow *)  ((wxPyVListBox *) x));
29103 }
29104 static void *_p_wxPyHtmlListBoxTo_p_wxPyVScrolledWindow(void *x) {
29105     return (void *)((wxPyVScrolledWindow *) (wxPyVListBox *) ((wxPyHtmlListBox *) x));
29106 }
29107 static void *_p_wxTipWindowTo_p_wxPyPopupTransientWindow(void *x) {
29108     return (void *)((wxPyPopupTransientWindow *)  ((wxTipWindow *) x));
29109 }
29110 static void *_p_wxPyPopupTransientWindowTo_p_wxPopupWindow(void *x) {
29111     return (void *)((wxPopupWindow *)  ((wxPyPopupTransientWindow *) x));
29112 }
29113 static void *_p_wxTipWindowTo_p_wxPopupWindow(void *x) {
29114     return (void *)((wxPopupWindow *) (wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29115 }
29116 static void *_p_wxSashLayoutWindowTo_p_wxSashWindow(void *x) {
29117     return (void *)((wxSashWindow *)  ((wxSashLayoutWindow *) x));
29118 }
29119 static void *_p_wxFrameTo_p_wxTopLevelWindow(void *x) {
29120     return (void *)((wxTopLevelWindow *)  ((wxFrame *) x));
29121 }
29122 static void *_p_wxMiniFrameTo_p_wxTopLevelWindow(void *x) {
29123     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMiniFrame *) x));
29124 }
29125 static void *_p_wxFontDialogTo_p_wxTopLevelWindow(void *x) {
29126     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFontDialog *) x));
29127 }
29128 static void *_p_wxDirDialogTo_p_wxTopLevelWindow(void *x) {
29129     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxDirDialog *) x));
29130 }
29131 static void *_p_wxColourDialogTo_p_wxTopLevelWindow(void *x) {
29132     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxColourDialog *) x));
29133 }
29134 static void *_p_wxDialogTo_p_wxTopLevelWindow(void *x) {
29135     return (void *)((wxTopLevelWindow *)  ((wxDialog *) x));
29136 }
29137 static void *_p_wxSplashScreenTo_p_wxTopLevelWindow(void *x) {
29138     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxSplashScreen *) x));
29139 }
29140 static void *_p_wxMDIParentFrameTo_p_wxTopLevelWindow(void *x) {
29141     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIParentFrame *) x));
29142 }
29143 static void *_p_wxMDIChildFrameTo_p_wxTopLevelWindow(void *x) {
29144     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIChildFrame *) x));
29145 }
29146 static void *_p_wxProgressDialogTo_p_wxTopLevelWindow(void *x) {
29147     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxProgressDialog *) x));
29148 }
29149 static void *_p_wxMessageDialogTo_p_wxTopLevelWindow(void *x) {
29150     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMessageDialog *) x));
29151 }
29152 static void *_p_wxPasswordEntryDialogTo_p_wxTopLevelWindow(void *x) {
29153     return (void *)((wxTopLevelWindow *) (wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29154 }
29155 static void *_p_wxTextEntryDialogTo_p_wxTopLevelWindow(void *x) {
29156     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxTextEntryDialog *) x));
29157 }
29158 static void *_p_wxSingleChoiceDialogTo_p_wxTopLevelWindow(void *x) {
29159     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxSingleChoiceDialog *) x));
29160 }
29161 static void *_p_wxMultiChoiceDialogTo_p_wxTopLevelWindow(void *x) {
29162     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMultiChoiceDialog *) x));
29163 }
29164 static void *_p_wxFileDialogTo_p_wxTopLevelWindow(void *x) {
29165     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFileDialog *) x));
29166 }
29167 static void *_p_wxFindReplaceDialogTo_p_wxTopLevelWindow(void *x) {
29168     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFindReplaceDialog *) x));
29169 }
29170 static void *_p_wxPreviewFrameTo_p_wxTopLevelWindow(void *x) {
29171     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxPreviewFrame *) x));
29172 }
29173 static void *_p_wxPyPreviewFrameTo_p_wxTopLevelWindow(void *x) {
29174     return (void *)((wxTopLevelWindow *) (wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
29175 }
29176 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
29177     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
29178 }
29179 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
29180     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
29181 }
29182 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
29183     return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
29184 }
29185 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
29186     return (void *)((wxWindow *)  ((wxMenuBar *) x));
29187 }
29188 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
29189     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
29190 }
29191 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
29192     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
29193 }
29194 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
29195     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
29196 }
29197 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
29198     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29199 }
29200 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
29201     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
29202 }
29203 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
29204     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
29205 }
29206 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
29207     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
29208 }
29209 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
29210     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
29211 }
29212 static void *_p_wxPanelTo_p_wxWindow(void *x) {
29213     return (void *)((wxWindow *)  ((wxPanel *) x));
29214 }
29215 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
29216     return (void *)((wxWindow *)  ((wxStatusBar *) x));
29217 }
29218 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
29219     return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
29220 }
29221 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
29222     return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29223 }
29224 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
29225     return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
29226 }
29227 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
29228     return (void *)((wxWindow *)  ((wxPopupWindow *) x));
29229 }
29230 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
29231     return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
29232 }
29233 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
29234     return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
29235 }
29236 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
29237     return (void *)((wxWindow *)  ((wxTopLevelWindow *) x));
29238 }
29239 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
29240     return (void *)((wxWindow *)  ((wxSplashScreenWindow *) x));
29241 }
29242 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
29243     return (void *)((wxWindow *)  ((wxSplitterWindow *) x));
29244 }
29245 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
29246     return (void *)((wxWindow *)  ((wxSashWindow *) x));
29247 }
29248 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
29249     return (void *)((wxWindow *)  ((wxMDIClientWindow *) x));
29250 }
29251 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
29252     return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29253 }
29254 static void *_p_wxControlTo_p_wxWindow(void *x) {
29255     return (void *)((wxWindow *)  ((wxControl *) x));
29256 }
29257 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
29258     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
29259 }
29260 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
29261     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
29262 }
29263 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
29264     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
29265 }
29266 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
29267     return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
29268 }
29269 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
29270     return (void *)((wxWindow *)  ((wxPyWindow *) x));
29271 }
29272 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
29273     return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
29274 }
29275 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
29276     return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29277 }
29278 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
29279     return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29280 }
29281 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
29282     return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
29283 }
29284 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
29285     return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29286 }
29287 static void *_p_wxFrameTo_p_wxWindow(void *x) {
29288     return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
29289 }
29290 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
29291     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
29292 }
29293 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
29294     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
29295 }
29296 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
29297     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
29298 }
29299 static void *_p_wxDialogTo_p_wxWindow(void *x) {
29300     return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
29301 }
29302 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
29303     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
29304 }
29305 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
29306     return (void *)((wxScrolledWindow *)  ((wxPyScrolledWindow *) x));
29307 }
29308 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
29309     return (void *)((wxScrolledWindow *)  ((wxPreviewCanvas *) x));
29310 }
29311 static void *_p_wxPyPrintPreviewTo_p_wxPrintPreview(void *x) {
29312     return (void *)((wxPrintPreview *)  ((wxPyPrintPreview *) x));
29313 }
29314 static void *_p_wxColourDialogTo_p_wxDialog(void *x) {
29315     return (void *)((wxDialog *)  ((wxColourDialog *) x));
29316 }
29317 static void *_p_wxDirDialogTo_p_wxDialog(void *x) {
29318     return (void *)((wxDialog *)  ((wxDirDialog *) x));
29319 }
29320 static void *_p_wxFontDialogTo_p_wxDialog(void *x) {
29321     return (void *)((wxDialog *)  ((wxFontDialog *) x));
29322 }
29323 static void *_p_wxFileDialogTo_p_wxDialog(void *x) {
29324     return (void *)((wxDialog *)  ((wxFileDialog *) x));
29325 }
29326 static void *_p_wxMultiChoiceDialogTo_p_wxDialog(void *x) {
29327     return (void *)((wxDialog *)  ((wxMultiChoiceDialog *) x));
29328 }
29329 static void *_p_wxSingleChoiceDialogTo_p_wxDialog(void *x) {
29330     return (void *)((wxDialog *)  ((wxSingleChoiceDialog *) x));
29331 }
29332 static void *_p_wxTextEntryDialogTo_p_wxDialog(void *x) {
29333     return (void *)((wxDialog *)  ((wxTextEntryDialog *) x));
29334 }
29335 static void *_p_wxPasswordEntryDialogTo_p_wxDialog(void *x) {
29336     return (void *)((wxDialog *) (wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29337 }
29338 static void *_p_wxMessageDialogTo_p_wxDialog(void *x) {
29339     return (void *)((wxDialog *)  ((wxMessageDialog *) x));
29340 }
29341 static void *_p_wxFindReplaceDialogTo_p_wxDialog(void *x) {
29342     return (void *)((wxDialog *)  ((wxFindReplaceDialog *) x));
29343 }
29344 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
29345     return (void *)((wxPanel *)  ((wxScrolledWindow *) x));
29346 }
29347 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
29348     return (void *)((wxPanel *)  ((wxPyVScrolledWindow *) x));
29349 }
29350 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
29351     return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29352 }
29353 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
29354     return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29355 }
29356 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
29357     return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29358 }
29359 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
29360     return (void *)((wxPanel *)  ((wxPyPanel *) x));
29361 }
29362 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
29363     return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
29364 }
29365 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
29366     return (void *)((wxPanel *)  ((wxPreviewControlBar *) x));
29367 }
29368 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
29369     return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29370 }
29371 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
29372     return (void *)((wxCommandEvent *)  ((wxChildFocusEvent *) x));
29373 }
29374 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
29375     return (void *)((wxCommandEvent *)  ((wxScrollEvent *) x));
29376 }
29377 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
29378     return (void *)((wxCommandEvent *)  ((wxWindowCreateEvent *) x));
29379 }
29380 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
29381     return (void *)((wxCommandEvent *)  ((wxDateEvent *) x));
29382 }
29383 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
29384     return (void *)((wxCommandEvent *)  ((wxUpdateUIEvent *) x));
29385 }
29386 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
29387     return (void *)((wxCommandEvent *)  ((wxFindDialogEvent *) x));
29388 }
29389 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
29390     return (void *)((wxCommandEvent *)  ((wxWindowDestroyEvent *) x));
29391 }
29392 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
29393     return (void *)((wxCommandEvent *)  ((wxContextMenuEvent *) x));
29394 }
29395 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
29396     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
29397 }
29398 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
29399     return (void *)((wxCommandEvent *)  ((wxNotifyEvent *) x));
29400 }
29401 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
29402     return (void *)((wxCommandEvent *)  ((wxPyCommandEvent *) x));
29403 }
29404 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
29405     return (void *)((wxCommandEvent *)  ((wxSashEvent *) x));
29406 }
29407 static void *_p_wxPyPreviewControlBarTo_p_wxPreviewControlBar(void *x) {
29408     return (void *)((wxPreviewControlBar *)  ((wxPyPreviewControlBar *) x));
29409 }
29410 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}};
29411 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}};
29412 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}};
29413 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}};
29414 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}};
29415 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}};
29416 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}};
29417 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}};
29418 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}};
29419 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}};
29420 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}};
29421 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}};
29422 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}};
29423 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}};
29424 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}};
29425 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}};
29426 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}};
29427 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}};
29428 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}};
29429 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}};
29430 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}};
29431 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}};
29432 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}};
29433 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}};
29434 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}};
29435 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}};
29436 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}};
29437 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}};
29438 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}};
29439 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}};
29440 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}};
29441 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}};
29442 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}};
29443 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}};
29444 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}};
29445 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}};
29446 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}};
29447 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}};
29448 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}};
29449 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}};
29450 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}};
29451 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}};
29452 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}};
29453 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}};
29454 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}};
29455 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}};
29456 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}};
29457 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}};
29458 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}};
29459 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}};
29460 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}};
29461 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}};
29462 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}};
29463 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}};
29464 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}};
29465 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}};
29466 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}};
29467 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}};
29468 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}};
29469 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}};
29470 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}};
29471 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}};
29472 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}};
29473 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}};
29474 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}};
29475 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}};
29476 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}};
29477 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}};
29478 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}};
29479 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}};
29480 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}};
29481 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}};
29482 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}};
29483 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}};
29484 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}};
29485 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}};
29486 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}};
29487 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}};
29488 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}};
29489 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}};
29490 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}};
29491 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}};
29492 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}};
29493 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}};
29494 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}};
29495 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}};
29496 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}};
29497 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}};
29498 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}};
29499 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}};
29500 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}};
29501 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}};
29502 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}};
29503 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}};
29504 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}};
29505 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}};
29506 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}};
29507
29508 static swig_type_info *swig_types_initial[] = {
29509 _swigt__p_wxQueryLayoutInfoEvent,
29510 _swigt__p_wxPreviewFrame,
29511 _swigt__p_wxPyPreviewFrame,
29512 _swigt__p_wxPyPanel,
29513 _swigt__p_wxMenu,
29514 _swigt__p_wxFontData,
29515 _swigt__p_wxEvent,
29516 _swigt__p_wxPrintData,
29517 _swigt__p_wxTaskBarIcon,
29518 _swigt__p_wxPyTaskBarIcon,
29519 _swigt__p_wxIconBundle,
29520 _swigt__p_wxLayoutAlgorithm,
29521 _swigt__p_wxFindDialogEvent,
29522 _swigt__p_wxPreviewCanvas,
29523 _swigt__p_wxFont,
29524 _swigt__p_wxSplitterEvent,
29525 _swigt__p_wxRegion,
29526 _swigt__ptrdiff_t,
29527 _swigt__std__ptrdiff_t,
29528 _swigt__p_wxFindReplaceData,
29529 _swigt__p_int,
29530 _swigt__p_wxSize,
29531 _swigt__p_wxDC,
29532 _swigt__p_wxIcon,
29533 _swigt__p_wxVisualAttributes,
29534 _swigt__p_wxMDIChildFrame,
29535 _swigt__p_wxColourData,
29536 _swigt__p_wxNotifyEvent,
29537 _swigt__p_wxPyWindow,
29538 _swigt__p_form_ops_t,
29539 _swigt__p_wxSplashScreen,
29540 _swigt__p_wxPasswordEntryDialog,
29541 _swigt__p_wxSingleChoiceDialog,
29542 _swigt__p_wxMultiChoiceDialog,
29543 _swigt__p_wxFileDialog,
29544 _swigt__p_wxTextEntryDialog,
29545 _swigt__p_wxMessageDialog,
29546 _swigt__p_wxProgressDialog,
29547 _swigt__p_wxFindReplaceDialog,
29548 _swigt__p_wxPrinter,
29549 _swigt__p_wxArrayInt,
29550 _swigt__p_wxDuplexMode,
29551 _swigt__p_wxEvtHandler,
29552 _swigt__p_wxCalculateLayoutEvent,
29553 _swigt__p_wxPyHtmlListBox,
29554 _swigt__p_wxPyVListBox,
29555 _swigt__p_wxRect,
29556 _swigt__p_wxStdDialogButtonSizer,
29557 _swigt__p_char,
29558 _swigt__p_wxMiniFrame,
29559 _swigt__p_wxFrame,
29560 _swigt__p_wxPyPrintout,
29561 _swigt__p_wxTaskBarIconEvent,
29562 _swigt__p_wxScrollWinEvent,
29563 _swigt__p_wxPaperSize,
29564 _swigt__p_wxStatusBar,
29565 _swigt__p_wxMDIParentFrame,
29566 _swigt__p_wxPoint,
29567 _swigt__p_wxObject,
29568 _swigt__p_unsigned_long,
29569 _swigt__p_wxTipWindow,
29570 _swigt__p_wxSashLayoutWindow,
29571 _swigt__p_wxSplitterWindow,
29572 _swigt__p_wxSplashScreenWindow,
29573 _swigt__p_wxPyVScrolledWindow,
29574 _swigt__p_wxPyPopupTransientWindow,
29575 _swigt__p_wxPopupWindow,
29576 _swigt__p_wxSashWindow,
29577 _swigt__p_wxTopLevelWindow,
29578 _swigt__p_wxWindow,
29579 _swigt__p_wxScrolledWindow,
29580 _swigt__p_wxMenuBar,
29581 _swigt__p_wxMDIClientWindow,
29582 _swigt__p_wxPyScrolledWindow,
29583 _swigt__p_wxPrintPreview,
29584 _swigt__p_wxSashEvent,
29585 _swigt__p_wxString,
29586 _swigt__p_wxPyPrintPreview,
29587 _swigt__p_wxDirDialog,
29588 _swigt__p_wxColourDialog,
29589 _swigt__p_wxDialog,
29590 _swigt__p_wxPanel,
29591 _swigt__p_wxFontDialog,
29592 _swigt__p_wxPageSetupDialog,
29593 _swigt__p_wxPrintDialog,
29594 _swigt__p_wxFileSystem,
29595 _swigt__p_wxBitmap,
29596 _swigt__unsigned_int,
29597 _swigt__p_unsigned_int,
29598 _swigt__p_unsigned_char,
29599 _swigt__p_wxCommandEvent,
29600 _swigt__p_wxPreviewControlBar,
29601 _swigt__p_wxPyPreviewControlBar,
29602 _swigt__p_wxColour,
29603 _swigt__p_wxToolBar,
29604 _swigt__p_wxPageSetupDialogData,
29605 _swigt__p_wxPrintDialogData,
29606 0
29607 };
29608
29609
29610 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
29611
29612 static swig_const_info swig_const_table[] = {
29613 {0, 0, 0, 0.0, 0, 0}};
29614
29615 #ifdef __cplusplus
29616 }
29617 #endif
29618
29619
29620 #ifdef __cplusplus
29621 extern "C" {
29622 #endif
29623
29624     /* Python-specific SWIG API */
29625 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
29626 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
29627 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
29628
29629     /* -----------------------------------------------------------------------------
29630      * global variable support code.
29631      * ----------------------------------------------------------------------------- */
29632
29633     typedef struct swig_globalvar {
29634         char       *name;                  /* Name of global variable */
29635         PyObject *(*get_attr)();           /* Return the current value */
29636         int       (*set_attr)(PyObject *); /* Set the value */
29637         struct swig_globalvar *next;
29638     } swig_globalvar;
29639
29640     typedef struct swig_varlinkobject {
29641         PyObject_HEAD
29642         swig_globalvar *vars;
29643     } swig_varlinkobject;
29644
29645     static PyObject *
29646     swig_varlink_repr(swig_varlinkobject *v) {
29647         v = v;
29648         return PyString_FromString("<Swig global variables>");
29649     }
29650
29651     static int
29652     swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
29653         swig_globalvar  *var;
29654         flags = flags;
29655         fprintf(fp,"Swig global variables { ");
29656         for (var = v->vars; var; var=var->next) {
29657             fprintf(fp,"%s", var->name);
29658             if (var->next) fprintf(fp,", ");
29659         }
29660         fprintf(fp," }\n");
29661         return 0;
29662     }
29663
29664     static PyObject *
29665     swig_varlink_getattr(swig_varlinkobject *v, char *n) {
29666         swig_globalvar *var = v->vars;
29667         while (var) {
29668             if (strcmp(var->name,n) == 0) {
29669                 return (*var->get_attr)();
29670             }
29671             var = var->next;
29672         }
29673         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29674         return NULL;
29675     }
29676
29677     static int
29678     swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
29679         swig_globalvar *var = v->vars;
29680         while (var) {
29681             if (strcmp(var->name,n) == 0) {
29682                 return (*var->set_attr)(p);
29683             }
29684             var = var->next;
29685         }
29686         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29687         return 1;
29688     }
29689
29690     static PyTypeObject varlinktype = {
29691         PyObject_HEAD_INIT(0)
29692         0,                                  /* Number of items in variable part (ob_size) */
29693         (char *)"swigvarlink",              /* Type name (tp_name) */
29694         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
29695         0,                                  /* Itemsize (tp_itemsize) */
29696         0,                                  /* Deallocator (tp_dealloc) */
29697         (printfunc) swig_varlink_print,     /* Print (tp_print) */
29698         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
29699         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
29700         0,                                  /* tp_compare */
29701         (reprfunc) swig_varlink_repr,       /* tp_repr */
29702         0,                                  /* tp_as_number */
29703         0,                                  /* tp_as_sequence */
29704         0,                                  /* tp_as_mapping */
29705         0,                                  /* tp_hash */
29706         0,                                  /* tp_call */
29707         0,                                  /* tp_str */
29708         0,                                  /* tp_getattro */
29709         0,                                  /* tp_setattro */
29710         0,                                  /* tp_as_buffer */
29711         0,                                  /* tp_flags */
29712         0,                                  /* tp_doc */
29713 #if PY_VERSION_HEX >= 0x02000000
29714         0,                                  /* tp_traverse */
29715         0,                                  /* tp_clear */
29716 #endif
29717 #if PY_VERSION_HEX >= 0x02010000
29718         0,                                  /* tp_richcompare */
29719         0,                                  /* tp_weaklistoffset */
29720 #endif
29721 #if PY_VERSION_HEX >= 0x02020000
29722         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
29723 #endif
29724 #if PY_VERSION_HEX >= 0x02030000
29725         0,                                  /* tp_del */
29726 #endif
29727 #ifdef COUNT_ALLOCS
29728         0,0,0,0                             /* tp_alloc -> tp_next */
29729 #endif
29730     };
29731
29732     /* Create a variable linking object for use later */
29733     static PyObject *
29734     SWIG_Python_newvarlink(void) {
29735         swig_varlinkobject *result = 0;
29736         result = PyMem_NEW(swig_varlinkobject,1);
29737         varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
29738         result->ob_type = &varlinktype;
29739         result->vars = 0;
29740         result->ob_refcnt = 0;
29741         Py_XINCREF((PyObject *) result);
29742         return ((PyObject*) result);
29743     }
29744
29745     static void
29746     SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
29747         swig_varlinkobject *v;
29748         swig_globalvar *gv;
29749         v= (swig_varlinkobject *) p;
29750         gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
29751         gv->name = (char *) malloc(strlen(name)+1);
29752         strcpy(gv->name,name);
29753         gv->get_attr = get_attr;
29754         gv->set_attr = set_attr;
29755         gv->next = v->vars;
29756         v->vars = gv;
29757     }
29758
29759     /* -----------------------------------------------------------------------------
29760      * constants/methods manipulation
29761      * ----------------------------------------------------------------------------- */
29762
29763     /* Install Constants */
29764     static void
29765     SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
29766         PyObject *obj = 0;
29767         size_t i;
29768         for (i = 0; constants[i].type; i++) {
29769             switch(constants[i].type) {
29770                 case SWIG_PY_INT:
29771                 obj = PyInt_FromLong(constants[i].lvalue);
29772                 break;
29773                 case SWIG_PY_FLOAT:
29774                 obj = PyFloat_FromDouble(constants[i].dvalue);
29775                 break;
29776                 case SWIG_PY_STRING:
29777                 if (constants[i].pvalue) {
29778                     obj = PyString_FromString((char *) constants[i].pvalue);
29779                 } else {
29780                     Py_INCREF(Py_None);
29781                     obj = Py_None;
29782                 }
29783                 break;
29784                 case SWIG_PY_POINTER:
29785                 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
29786                 break;
29787                 case SWIG_PY_BINARY:
29788                 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
29789                 break;
29790                 default:
29791                 obj = 0;
29792                 break;
29793             }
29794             if (obj) {
29795                 PyDict_SetItemString(d,constants[i].name,obj);
29796                 Py_DECREF(obj);
29797             }
29798         }
29799     }
29800
29801     /* -----------------------------------------------------------------------------*/
29802     /* Fix SwigMethods to carry the callback ptrs when needed */
29803     /* -----------------------------------------------------------------------------*/
29804
29805     static void
29806     SWIG_Python_FixMethods(PyMethodDef *methods,
29807     swig_const_info *const_table,
29808     swig_type_info **types,
29809     swig_type_info **types_initial) {
29810         size_t i;
29811         for (i = 0; methods[i].ml_name; ++i) {
29812             char *c = methods[i].ml_doc;
29813             if (c && (c = strstr(c, "swig_ptr: "))) {
29814                 int j;
29815                 swig_const_info *ci = 0;
29816                 char *name = c + 10;
29817                 for (j = 0; const_table[j].type; j++) {
29818                     if (strncmp(const_table[j].name, name,
29819                     strlen(const_table[j].name)) == 0) {
29820                         ci = &(const_table[j]);
29821                         break;
29822                     }
29823                 }
29824                 if (ci) {
29825                     size_t shift = (ci->ptype) - types;
29826                     swig_type_info *ty = types_initial[shift];
29827                     size_t ldoc = (c - methods[i].ml_doc);
29828                     size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
29829                     char *ndoc = (char*)malloc(ldoc + lptr + 10);
29830                     char *buff = ndoc;
29831                     void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
29832                     strncpy(buff, methods[i].ml_doc, ldoc);
29833                     buff += ldoc;
29834                     strncpy(buff, "swig_ptr: ", 10);
29835                     buff += 10;
29836                     SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
29837                     methods[i].ml_doc = ndoc;
29838                 }
29839             }
29840         }
29841     }
29842
29843     /* -----------------------------------------------------------------------------*
29844      *  Initialize type list
29845      * -----------------------------------------------------------------------------*/
29846
29847 #if PY_MAJOR_VERSION < 2
29848     /* PyModule_AddObject function was introduced in Python 2.0.  The following function
29849     is copied out of Python/modsupport.c in python version 2.3.4 */
29850     static int
29851     PyModule_AddObject(PyObject *m, char *name, PyObject *o)
29852     {
29853         PyObject *dict;
29854         if (!PyModule_Check(m)) {
29855             PyErr_SetString(PyExc_TypeError,
29856             "PyModule_AddObject() needs module as first arg");
29857             return -1;
29858         }
29859         if (!o) {
29860             PyErr_SetString(PyExc_TypeError,
29861             "PyModule_AddObject() needs non-NULL value");
29862             return -1;
29863         }
29864
29865         dict = PyModule_GetDict(m);
29866         if (dict == NULL) {
29867             /* Internal error -- modules must have a dict! */
29868             PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
29869             PyModule_GetName(m));
29870             return -1;
29871         }
29872         if (PyDict_SetItemString(dict, name, o))
29873         return -1;
29874         Py_DECREF(o);
29875         return 0;
29876     }
29877 #endif
29878
29879     static swig_type_info **
29880     SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
29881         static PyMethodDef swig_empty_runtime_method_table[] = {
29882             {
29883                 NULL, NULL, 0, NULL
29884             }
29885         };/* Sentinel */
29886
29887         PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
29888         swig_empty_runtime_method_table);
29889         PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
29890         if (pointer && module) {
29891             PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
29892         }
29893         return type_list_handle;
29894     }
29895
29896     static swig_type_info **
29897     SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
29898         swig_type_info **type_pointer;
29899
29900         /* first check if module already created */
29901         type_pointer = SWIG_Python_GetTypeListHandle();
29902         if (type_pointer) {
29903             return type_pointer;
29904         } else {
29905             /* create a new module and variable */
29906             return SWIG_Python_SetTypeListHandle(type_list_handle);
29907         }
29908     }
29909
29910 #ifdef __cplusplus
29911 }
29912 #endif
29913
29914 /* -----------------------------------------------------------------------------*
29915  *  Partial Init method
29916  * -----------------------------------------------------------------------------*/
29917
29918 #ifdef SWIG_LINK_RUNTIME
29919 #ifdef __cplusplus
29920 extern "C"
29921 #endif
29922 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
29923 #endif
29924
29925 #ifdef __cplusplus
29926 extern "C"
29927 #endif
29928 SWIGEXPORT(void) SWIG_init(void) {
29929     static PyObject *SWIG_globals = 0;
29930     static int       typeinit = 0;
29931     PyObject *m, *d;
29932     int       i;
29933     if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
29934
29935     /* Fix SwigMethods to carry the callback ptrs when needed */
29936     SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
29937
29938     m = Py_InitModule((char *) SWIG_name, SwigMethods);
29939     d = PyModule_GetDict(m);
29940
29941     if (!typeinit) {
29942 #ifdef SWIG_LINK_RUNTIME
29943         swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
29944 #else
29945 #  ifndef SWIG_STATIC_RUNTIME
29946         swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
29947 #  endif
29948 #endif
29949         for (i = 0; swig_types_initial[i]; i++) {
29950             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
29951         }
29952         typeinit = 1;
29953     }
29954     SWIG_InstallConstants(d,swig_const_table);
29955
29956     PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
29957     SWIG_addvarlink(SWIG_globals,(char*)"FrameNameStr",_wrap_FrameNameStr_get, _wrap_FrameNameStr_set);
29958     SWIG_addvarlink(SWIG_globals,(char*)"DialogNameStr",_wrap_DialogNameStr_get, _wrap_DialogNameStr_set);
29959     SWIG_addvarlink(SWIG_globals,(char*)"StatusLineNameStr",_wrap_StatusLineNameStr_get, _wrap_StatusLineNameStr_set);
29960     SWIG_addvarlink(SWIG_globals,(char*)"ToolBarNameStr",_wrap_ToolBarNameStr_get, _wrap_ToolBarNameStr_set);
29961     {
29962         PyDict_SetItemString(d,"STAY_ON_TOP", SWIG_From_int((int)(wxSTAY_ON_TOP)));
29963     }
29964     {
29965         PyDict_SetItemString(d,"ICONIZE", SWIG_From_int((int)(wxICONIZE)));
29966     }
29967     {
29968         PyDict_SetItemString(d,"MINIMIZE", SWIG_From_int((int)(wxMINIMIZE)));
29969     }
29970     {
29971         PyDict_SetItemString(d,"MAXIMIZE", SWIG_From_int((int)(wxMAXIMIZE)));
29972     }
29973     {
29974         PyDict_SetItemString(d,"CLOSE_BOX", SWIG_From_int((int)(wxCLOSE_BOX)));
29975     }
29976     {
29977         PyDict_SetItemString(d,"THICK_FRAME", SWIG_From_int((int)(wxTHICK_FRAME)));
29978     }
29979     {
29980         PyDict_SetItemString(d,"SYSTEM_MENU", SWIG_From_int((int)(wxSYSTEM_MENU)));
29981     }
29982     {
29983         PyDict_SetItemString(d,"MINIMIZE_BOX", SWIG_From_int((int)(wxMINIMIZE_BOX)));
29984     }
29985     {
29986         PyDict_SetItemString(d,"MAXIMIZE_BOX", SWIG_From_int((int)(wxMAXIMIZE_BOX)));
29987     }
29988     {
29989         PyDict_SetItemString(d,"TINY_CAPTION_HORIZ", SWIG_From_int((int)(wxTINY_CAPTION_HORIZ)));
29990     }
29991     {
29992         PyDict_SetItemString(d,"TINY_CAPTION_VERT", SWIG_From_int((int)(wxTINY_CAPTION_VERT)));
29993     }
29994     {
29995         PyDict_SetItemString(d,"RESIZE_BOX", SWIG_From_int((int)(wxRESIZE_BOX)));
29996     }
29997     {
29998         PyDict_SetItemString(d,"RESIZE_BORDER", SWIG_From_int((int)(wxRESIZE_BORDER)));
29999     }
30000     {
30001         PyDict_SetItemString(d,"DIALOG_NO_PARENT", SWIG_From_int((int)(wxDIALOG_NO_PARENT)));
30002     }
30003     {
30004         PyDict_SetItemString(d,"DEFAULT_FRAME_STYLE", SWIG_From_int((int)(wxDEFAULT_FRAME_STYLE)));
30005     }
30006     {
30007         PyDict_SetItemString(d,"DEFAULT_DIALOG_STYLE", SWIG_From_int((int)(wxDEFAULT_DIALOG_STYLE)));
30008     }
30009     {
30010         PyDict_SetItemString(d,"FRAME_TOOL_WINDOW", SWIG_From_int((int)(wxFRAME_TOOL_WINDOW)));
30011     }
30012     {
30013         PyDict_SetItemString(d,"FRAME_FLOAT_ON_PARENT", SWIG_From_int((int)(wxFRAME_FLOAT_ON_PARENT)));
30014     }
30015     {
30016         PyDict_SetItemString(d,"FRAME_NO_WINDOW_MENU", SWIG_From_int((int)(wxFRAME_NO_WINDOW_MENU)));
30017     }
30018     {
30019         PyDict_SetItemString(d,"FRAME_NO_TASKBAR", SWIG_From_int((int)(wxFRAME_NO_TASKBAR)));
30020     }
30021     {
30022         PyDict_SetItemString(d,"FRAME_SHAPED", SWIG_From_int((int)(wxFRAME_SHAPED)));
30023     }
30024     {
30025         PyDict_SetItemString(d,"FRAME_DRAWER", SWIG_From_int((int)(wxFRAME_DRAWER)));
30026     }
30027     {
30028         PyDict_SetItemString(d,"FRAME_EX_METAL", SWIG_From_int((int)(wxFRAME_EX_METAL)));
30029     }
30030     {
30031         PyDict_SetItemString(d,"DIALOG_EX_METAL", SWIG_From_int((int)(wxDIALOG_EX_METAL)));
30032     }
30033     {
30034         PyDict_SetItemString(d,"DIALOG_MODAL", SWIG_From_int((int)(wxDIALOG_MODAL)));
30035     }
30036     {
30037         PyDict_SetItemString(d,"DIALOG_MODELESS", SWIG_From_int((int)(wxDIALOG_MODELESS)));
30038     }
30039     {
30040         PyDict_SetItemString(d,"USER_COLOURS", SWIG_From_int((int)(wxUSER_COLOURS)));
30041     }
30042     {
30043         PyDict_SetItemString(d,"NO_3D", SWIG_From_int((int)(wxNO_3D)));
30044     }
30045     {
30046         PyDict_SetItemString(d,"FULLSCREEN_NOMENUBAR", SWIG_From_int((int)(wxFULLSCREEN_NOMENUBAR)));
30047     }
30048     {
30049         PyDict_SetItemString(d,"FULLSCREEN_NOTOOLBAR", SWIG_From_int((int)(wxFULLSCREEN_NOTOOLBAR)));
30050     }
30051     {
30052         PyDict_SetItemString(d,"FULLSCREEN_NOSTATUSBAR", SWIG_From_int((int)(wxFULLSCREEN_NOSTATUSBAR)));
30053     }
30054     {
30055         PyDict_SetItemString(d,"FULLSCREEN_NOBORDER", SWIG_From_int((int)(wxFULLSCREEN_NOBORDER)));
30056     }
30057     {
30058         PyDict_SetItemString(d,"FULLSCREEN_NOCAPTION", SWIG_From_int((int)(wxFULLSCREEN_NOCAPTION)));
30059     }
30060     {
30061         PyDict_SetItemString(d,"FULLSCREEN_ALL", SWIG_From_int((int)(wxFULLSCREEN_ALL)));
30062     }
30063     {
30064         PyDict_SetItemString(d,"TOPLEVEL_EX_DIALOG", SWIG_From_int((int)(wxTOPLEVEL_EX_DIALOG)));
30065     }
30066     {
30067         PyDict_SetItemString(d,"USER_ATTENTION_INFO", SWIG_From_int((int)(wxUSER_ATTENTION_INFO)));
30068     }
30069     {
30070         PyDict_SetItemString(d,"USER_ATTENTION_ERROR", SWIG_From_int((int)(wxUSER_ATTENTION_ERROR)));
30071     }
30072     {
30073         PyDict_SetItemString(d,"SPLASH_CENTRE_ON_PARENT", SWIG_From_int((int)(wxSPLASH_CENTRE_ON_PARENT)));
30074     }
30075     {
30076         PyDict_SetItemString(d,"SPLASH_CENTRE_ON_SCREEN", SWIG_From_int((int)(wxSPLASH_CENTRE_ON_SCREEN)));
30077     }
30078     {
30079         PyDict_SetItemString(d,"SPLASH_NO_CENTRE", SWIG_From_int((int)(wxSPLASH_NO_CENTRE)));
30080     }
30081     {
30082         PyDict_SetItemString(d,"SPLASH_TIMEOUT", SWIG_From_int((int)(wxSPLASH_TIMEOUT)));
30083     }
30084     {
30085         PyDict_SetItemString(d,"SPLASH_NO_TIMEOUT", SWIG_From_int((int)(wxSPLASH_NO_TIMEOUT)));
30086     }
30087     {
30088         PyDict_SetItemString(d,"SB_NORMAL", SWIG_From_int((int)(wxSB_NORMAL)));
30089     }
30090     {
30091         PyDict_SetItemString(d,"SB_FLAT", SWIG_From_int((int)(wxSB_FLAT)));
30092     }
30093     {
30094         PyDict_SetItemString(d,"SB_RAISED", SWIG_From_int((int)(wxSB_RAISED)));
30095     }
30096     SWIG_addvarlink(SWIG_globals,(char*)"SplitterNameStr",_wrap_SplitterNameStr_get, _wrap_SplitterNameStr_set);
30097     {
30098         PyDict_SetItemString(d,"SP_NOBORDER", SWIG_From_int((int)(wxSP_NOBORDER)));
30099     }
30100     {
30101         PyDict_SetItemString(d,"SP_NOSASH", SWIG_From_int((int)(wxSP_NOSASH)));
30102     }
30103     {
30104         PyDict_SetItemString(d,"SP_PERMIT_UNSPLIT", SWIG_From_int((int)(wxSP_PERMIT_UNSPLIT)));
30105     }
30106     {
30107         PyDict_SetItemString(d,"SP_LIVE_UPDATE", SWIG_From_int((int)(wxSP_LIVE_UPDATE)));
30108     }
30109     {
30110         PyDict_SetItemString(d,"SP_3DSASH", SWIG_From_int((int)(wxSP_3DSASH)));
30111     }
30112     {
30113         PyDict_SetItemString(d,"SP_3DBORDER", SWIG_From_int((int)(wxSP_3DBORDER)));
30114     }
30115     {
30116         PyDict_SetItemString(d,"SP_NO_XP_THEME", SWIG_From_int((int)(wxSP_NO_XP_THEME)));
30117     }
30118     {
30119         PyDict_SetItemString(d,"SP_BORDER", SWIG_From_int((int)(wxSP_BORDER)));
30120     }
30121     {
30122         PyDict_SetItemString(d,"SP_3D", SWIG_From_int((int)(wxSP_3D)));
30123     }
30124     {
30125         PyDict_SetItemString(d,"SPLIT_HORIZONTAL", SWIG_From_int((int)(wxSPLIT_HORIZONTAL)));
30126     }
30127     {
30128         PyDict_SetItemString(d,"SPLIT_VERTICAL", SWIG_From_int((int)(wxSPLIT_VERTICAL)));
30129     }
30130     {
30131         PyDict_SetItemString(d,"SPLIT_DRAG_NONE", SWIG_From_int((int)(wxSPLIT_DRAG_NONE)));
30132     }
30133     {
30134         PyDict_SetItemString(d,"SPLIT_DRAG_DRAGGING", SWIG_From_int((int)(wxSPLIT_DRAG_DRAGGING)));
30135     }
30136     {
30137         PyDict_SetItemString(d,"SPLIT_DRAG_LEFT_DOWN", SWIG_From_int((int)(wxSPLIT_DRAG_LEFT_DOWN)));
30138     }
30139     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED));
30140     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING));
30141     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_DOUBLECLICKED));
30142     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_UNSPLIT", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_UNSPLIT));
30143     SWIG_addvarlink(SWIG_globals,(char*)"SashNameStr",_wrap_SashNameStr_get, _wrap_SashNameStr_set);
30144     SWIG_addvarlink(SWIG_globals,(char*)"SashLayoutNameStr",_wrap_SashLayoutNameStr_get, _wrap_SashLayoutNameStr_set);
30145     {
30146         PyDict_SetItemString(d,"SASH_DRAG_NONE", SWIG_From_int((int)(wxSASH_DRAG_NONE)));
30147     }
30148     {
30149         PyDict_SetItemString(d,"SASH_DRAG_DRAGGING", SWIG_From_int((int)(wxSASH_DRAG_DRAGGING)));
30150     }
30151     {
30152         PyDict_SetItemString(d,"SASH_DRAG_LEFT_DOWN", SWIG_From_int((int)(wxSASH_DRAG_LEFT_DOWN)));
30153     }
30154     {
30155         PyDict_SetItemString(d,"SW_NOBORDER", SWIG_From_int((int)(wxSW_NOBORDER)));
30156     }
30157     {
30158         PyDict_SetItemString(d,"SW_BORDER", SWIG_From_int((int)(wxSW_BORDER)));
30159     }
30160     {
30161         PyDict_SetItemString(d,"SW_3DSASH", SWIG_From_int((int)(wxSW_3DSASH)));
30162     }
30163     {
30164         PyDict_SetItemString(d,"SW_3DBORDER", SWIG_From_int((int)(wxSW_3DBORDER)));
30165     }
30166     {
30167         PyDict_SetItemString(d,"SW_3D", SWIG_From_int((int)(wxSW_3D)));
30168     }
30169     {
30170         PyDict_SetItemString(d,"SASH_TOP", SWIG_From_int((int)(wxSASH_TOP)));
30171     }
30172     {
30173         PyDict_SetItemString(d,"SASH_RIGHT", SWIG_From_int((int)(wxSASH_RIGHT)));
30174     }
30175     {
30176         PyDict_SetItemString(d,"SASH_BOTTOM", SWIG_From_int((int)(wxSASH_BOTTOM)));
30177     }
30178     {
30179         PyDict_SetItemString(d,"SASH_LEFT", SWIG_From_int((int)(wxSASH_LEFT)));
30180     }
30181     {
30182         PyDict_SetItemString(d,"SASH_NONE", SWIG_From_int((int)(wxSASH_NONE)));
30183     }
30184     {
30185         PyDict_SetItemString(d,"SASH_STATUS_OK", SWIG_From_int((int)(wxSASH_STATUS_OK)));
30186     }
30187     {
30188         PyDict_SetItemString(d,"SASH_STATUS_OUT_OF_RANGE", SWIG_From_int((int)(wxSASH_STATUS_OUT_OF_RANGE)));
30189     }
30190     PyDict_SetItemString(d, "wxEVT_SASH_DRAGGED", PyInt_FromLong(wxEVT_SASH_DRAGGED));
30191     {
30192         PyDict_SetItemString(d,"LAYOUT_HORIZONTAL", SWIG_From_int((int)(wxLAYOUT_HORIZONTAL)));
30193     }
30194     {
30195         PyDict_SetItemString(d,"LAYOUT_VERTICAL", SWIG_From_int((int)(wxLAYOUT_VERTICAL)));
30196     }
30197     {
30198         PyDict_SetItemString(d,"LAYOUT_NONE", SWIG_From_int((int)(wxLAYOUT_NONE)));
30199     }
30200     {
30201         PyDict_SetItemString(d,"LAYOUT_TOP", SWIG_From_int((int)(wxLAYOUT_TOP)));
30202     }
30203     {
30204         PyDict_SetItemString(d,"LAYOUT_LEFT", SWIG_From_int((int)(wxLAYOUT_LEFT)));
30205     }
30206     {
30207         PyDict_SetItemString(d,"LAYOUT_RIGHT", SWIG_From_int((int)(wxLAYOUT_RIGHT)));
30208     }
30209     {
30210         PyDict_SetItemString(d,"LAYOUT_BOTTOM", SWIG_From_int((int)(wxLAYOUT_BOTTOM)));
30211     }
30212     {
30213         PyDict_SetItemString(d,"LAYOUT_LENGTH_Y", SWIG_From_int((int)(wxLAYOUT_LENGTH_Y)));
30214     }
30215     {
30216         PyDict_SetItemString(d,"LAYOUT_LENGTH_X", SWIG_From_int((int)(wxLAYOUT_LENGTH_X)));
30217     }
30218     {
30219         PyDict_SetItemString(d,"LAYOUT_MRU_LENGTH", SWIG_From_int((int)(wxLAYOUT_MRU_LENGTH)));
30220     }
30221     {
30222         PyDict_SetItemString(d,"LAYOUT_QUERY", SWIG_From_int((int)(wxLAYOUT_QUERY)));
30223     }
30224     PyDict_SetItemString(d, "wxEVT_QUERY_LAYOUT_INFO", PyInt_FromLong(wxEVT_QUERY_LAYOUT_INFO));
30225     PyDict_SetItemString(d, "wxEVT_CALCULATE_LAYOUT", PyInt_FromLong(wxEVT_CALCULATE_LAYOUT));
30226     SWIG_addvarlink(SWIG_globals,(char*)"VListBoxNameStr",_wrap_VListBoxNameStr_get, _wrap_VListBoxNameStr_set);
30227
30228     // Map renamed classes back to their common name for OOR
30229     wxPyPtrTypeMap_Add("wxHtmlListBox",     "wxPyHtmlListBox");
30230     wxPyPtrTypeMap_Add("wxVListBox",        "wxPyVListBox");
30231     wxPyPtrTypeMap_Add("wxVScrolledWindow", "wxPyVScrolledWindow");
30232
30233     PyDict_SetItemString(d, "wxEVT_TASKBAR_MOVE", PyInt_FromLong(wxEVT_TASKBAR_MOVE));
30234     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DOWN", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DOWN));
30235     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_UP", PyInt_FromLong(wxEVT_TASKBAR_LEFT_UP));
30236     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DOWN", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DOWN));
30237     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_UP", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_UP));
30238     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DCLICK));
30239     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DCLICK));
30240     SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
30241     SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
30242     SWIG_addvarlink(SWIG_globals,(char*)"DirDialogNameStr",_wrap_DirDialogNameStr_get, _wrap_DirDialogNameStr_set);
30243     SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
30244     SWIG_addvarlink(SWIG_globals,(char*)"GetTextFromUserPromptStr",_wrap_GetTextFromUserPromptStr_get, _wrap_GetTextFromUserPromptStr_set);
30245     SWIG_addvarlink(SWIG_globals,(char*)"MessageBoxCaptionStr",_wrap_MessageBoxCaptionStr_get, _wrap_MessageBoxCaptionStr_set);
30246     {
30247         PyDict_SetItemString(d,"CHOICEDLG_STYLE", SWIG_From_int((int)(wxCHOICEDLG_STYLE)));
30248     }
30249     {
30250         PyDict_SetItemString(d,"TextEntryDialogStyle", SWIG_From_int((int)(wxTextEntryDialogStyle)));
30251     }
30252     SWIG_addvarlink(SWIG_globals,(char*)"GetPasswordFromUserPromptStr",_wrap_GetPasswordFromUserPromptStr_get, _wrap_GetPasswordFromUserPromptStr_set);
30253     {
30254         PyDict_SetItemString(d,"FR_DOWN", SWIG_From_int((int)(wxFR_DOWN)));
30255     }
30256     {
30257         PyDict_SetItemString(d,"FR_WHOLEWORD", SWIG_From_int((int)(wxFR_WHOLEWORD)));
30258     }
30259     {
30260         PyDict_SetItemString(d,"FR_MATCHCASE", SWIG_From_int((int)(wxFR_MATCHCASE)));
30261     }
30262     {
30263         PyDict_SetItemString(d,"FR_REPLACEDIALOG", SWIG_From_int((int)(wxFR_REPLACEDIALOG)));
30264     }
30265     {
30266         PyDict_SetItemString(d,"FR_NOUPDOWN", SWIG_From_int((int)(wxFR_NOUPDOWN)));
30267     }
30268     {
30269         PyDict_SetItemString(d,"FR_NOMATCHCASE", SWIG_From_int((int)(wxFR_NOMATCHCASE)));
30270     }
30271     {
30272         PyDict_SetItemString(d,"FR_NOWHOLEWORD", SWIG_From_int((int)(wxFR_NOWHOLEWORD)));
30273     }
30274     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND", PyInt_FromLong(wxEVT_COMMAND_FIND));
30275     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_NEXT", PyInt_FromLong(wxEVT_COMMAND_FIND_NEXT));
30276     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE));
30277     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE_ALL", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE_ALL));
30278     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_CLOSE", PyInt_FromLong(wxEVT_COMMAND_FIND_CLOSE));
30279     {
30280         PyDict_SetItemString(d,"IDM_WINDOWTILE", SWIG_From_int((int)(4001)));
30281     }
30282     {
30283         PyDict_SetItemString(d,"IDM_WINDOWTILEHOR", SWIG_From_int((int)(4001)));
30284     }
30285     {
30286         PyDict_SetItemString(d,"IDM_WINDOWCASCADE", SWIG_From_int((int)(4002)));
30287     }
30288     {
30289         PyDict_SetItemString(d,"IDM_WINDOWICONS", SWIG_From_int((int)(4003)));
30290     }
30291     {
30292         PyDict_SetItemString(d,"IDM_WINDOWNEXT", SWIG_From_int((int)(4004)));
30293     }
30294     {
30295         PyDict_SetItemString(d,"IDM_WINDOWTILEVERT", SWIG_From_int((int)(4005)));
30296     }
30297     {
30298         PyDict_SetItemString(d,"IDM_WINDOWPREV", SWIG_From_int((int)(4006)));
30299     }
30300     {
30301         PyDict_SetItemString(d,"FIRST_MDI_CHILD", SWIG_From_int((int)(4100)));
30302     }
30303     {
30304         PyDict_SetItemString(d,"LAST_MDI_CHILD", SWIG_From_int((int)(4600)));
30305     }
30306     SWIG_addvarlink(SWIG_globals,(char*)"PrintoutTitleStr",_wrap_PrintoutTitleStr_get, _wrap_PrintoutTitleStr_set);
30307     SWIG_addvarlink(SWIG_globals,(char*)"PreviewCanvasNameStr",_wrap_PreviewCanvasNameStr_get, _wrap_PreviewCanvasNameStr_set);
30308     {
30309         PyDict_SetItemString(d,"PRINT_MODE_NONE", SWIG_From_int((int)(wxPRINT_MODE_NONE)));
30310     }
30311     {
30312         PyDict_SetItemString(d,"PRINT_MODE_PREVIEW", SWIG_From_int((int)(wxPRINT_MODE_PREVIEW)));
30313     }
30314     {
30315         PyDict_SetItemString(d,"PRINT_MODE_FILE", SWIG_From_int((int)(wxPRINT_MODE_FILE)));
30316     }
30317     {
30318         PyDict_SetItemString(d,"PRINT_MODE_PRINTER", SWIG_From_int((int)(wxPRINT_MODE_PRINTER)));
30319     }
30320     {
30321         PyDict_SetItemString(d,"PRINT_MODE_STREAM", SWIG_From_int((int)(wxPRINT_MODE_STREAM)));
30322     }
30323     {
30324         PyDict_SetItemString(d,"PRINTBIN_DEFAULT", SWIG_From_int((int)(wxPRINTBIN_DEFAULT)));
30325     }
30326     {
30327         PyDict_SetItemString(d,"PRINTBIN_ONLYONE", SWIG_From_int((int)(wxPRINTBIN_ONLYONE)));
30328     }
30329     {
30330         PyDict_SetItemString(d,"PRINTBIN_LOWER", SWIG_From_int((int)(wxPRINTBIN_LOWER)));
30331     }
30332     {
30333         PyDict_SetItemString(d,"PRINTBIN_MIDDLE", SWIG_From_int((int)(wxPRINTBIN_MIDDLE)));
30334     }
30335     {
30336         PyDict_SetItemString(d,"PRINTBIN_MANUAL", SWIG_From_int((int)(wxPRINTBIN_MANUAL)));
30337     }
30338     {
30339         PyDict_SetItemString(d,"PRINTBIN_ENVELOPE", SWIG_From_int((int)(wxPRINTBIN_ENVELOPE)));
30340     }
30341     {
30342         PyDict_SetItemString(d,"PRINTBIN_ENVMANUAL", SWIG_From_int((int)(wxPRINTBIN_ENVMANUAL)));
30343     }
30344     {
30345         PyDict_SetItemString(d,"PRINTBIN_AUTO", SWIG_From_int((int)(wxPRINTBIN_AUTO)));
30346     }
30347     {
30348         PyDict_SetItemString(d,"PRINTBIN_TRACTOR", SWIG_From_int((int)(wxPRINTBIN_TRACTOR)));
30349     }
30350     {
30351         PyDict_SetItemString(d,"PRINTBIN_SMALLFMT", SWIG_From_int((int)(wxPRINTBIN_SMALLFMT)));
30352     }
30353     {
30354         PyDict_SetItemString(d,"PRINTBIN_LARGEFMT", SWIG_From_int((int)(wxPRINTBIN_LARGEFMT)));
30355     }
30356     {
30357         PyDict_SetItemString(d,"PRINTBIN_LARGECAPACITY", SWIG_From_int((int)(wxPRINTBIN_LARGECAPACITY)));
30358     }
30359     {
30360         PyDict_SetItemString(d,"PRINTBIN_CASSETTE", SWIG_From_int((int)(wxPRINTBIN_CASSETTE)));
30361     }
30362     {
30363         PyDict_SetItemString(d,"PRINTBIN_FORMSOURCE", SWIG_From_int((int)(wxPRINTBIN_FORMSOURCE)));
30364     }
30365     {
30366         PyDict_SetItemString(d,"PRINTBIN_USER", SWIG_From_int((int)(wxPRINTBIN_USER)));
30367     }
30368     {
30369         PyDict_SetItemString(d,"PRINTER_NO_ERROR", SWIG_From_int((int)(wxPRINTER_NO_ERROR)));
30370     }
30371     {
30372         PyDict_SetItemString(d,"PRINTER_CANCELLED", SWIG_From_int((int)(wxPRINTER_CANCELLED)));
30373     }
30374     {
30375         PyDict_SetItemString(d,"PRINTER_ERROR", SWIG_From_int((int)(wxPRINTER_ERROR)));
30376     }
30377     {
30378         PyDict_SetItemString(d,"PREVIEW_PRINT", SWIG_From_int((int)(wxPREVIEW_PRINT)));
30379     }
30380     {
30381         PyDict_SetItemString(d,"PREVIEW_PREVIOUS", SWIG_From_int((int)(wxPREVIEW_PREVIOUS)));
30382     }
30383     {
30384         PyDict_SetItemString(d,"PREVIEW_NEXT", SWIG_From_int((int)(wxPREVIEW_NEXT)));
30385     }
30386     {
30387         PyDict_SetItemString(d,"PREVIEW_ZOOM", SWIG_From_int((int)(wxPREVIEW_ZOOM)));
30388     }
30389     {
30390         PyDict_SetItemString(d,"PREVIEW_FIRST", SWIG_From_int((int)(wxPREVIEW_FIRST)));
30391     }
30392     {
30393         PyDict_SetItemString(d,"PREVIEW_LAST", SWIG_From_int((int)(wxPREVIEW_LAST)));
30394     }
30395     {
30396         PyDict_SetItemString(d,"PREVIEW_GOTO", SWIG_From_int((int)(wxPREVIEW_GOTO)));
30397     }
30398     {
30399         PyDict_SetItemString(d,"PREVIEW_DEFAULT", SWIG_From_int((int)(wxPREVIEW_DEFAULT)));
30400     }
30401     {
30402         PyDict_SetItemString(d,"ID_PREVIEW_CLOSE", SWIG_From_int((int)(wxID_PREVIEW_CLOSE)));
30403     }
30404     {
30405         PyDict_SetItemString(d,"ID_PREVIEW_NEXT", SWIG_From_int((int)(wxID_PREVIEW_NEXT)));
30406     }
30407     {
30408         PyDict_SetItemString(d,"ID_PREVIEW_PREVIOUS", SWIG_From_int((int)(wxID_PREVIEW_PREVIOUS)));
30409     }
30410     {
30411         PyDict_SetItemString(d,"ID_PREVIEW_PRINT", SWIG_From_int((int)(wxID_PREVIEW_PRINT)));
30412     }
30413     {
30414         PyDict_SetItemString(d,"ID_PREVIEW_ZOOM", SWIG_From_int((int)(wxID_PREVIEW_ZOOM)));
30415     }
30416     {
30417         PyDict_SetItemString(d,"ID_PREVIEW_FIRST", SWIG_From_int((int)(wxID_PREVIEW_FIRST)));
30418     }
30419     {
30420         PyDict_SetItemString(d,"ID_PREVIEW_LAST", SWIG_From_int((int)(wxID_PREVIEW_LAST)));
30421     }
30422     {
30423         PyDict_SetItemString(d,"ID_PREVIEW_GOTO", SWIG_From_int((int)(wxID_PREVIEW_GOTO)));
30424     }
30425
30426     wxPyPtrTypeMap_Add("wxPrintout", "wxPyPrintout");
30427
30428 }
30429