wxPython/src/msw/_windows_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.24
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #define SWIGPYTHON
  12
  13 #ifdef __cplusplus
  14 template<class T> class SwigValueWrapper {
  15     T *tt;
  16 public:
  17     SwigValueWrapper() : tt(0) { }
  18     SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
  19     SwigValueWrapper(const T& t) : tt(new T(t)) { }
  20     ~SwigValueWrapper() { delete tt; }
  21     SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
  22     operator T&() const { return *tt; }
  23     T *operator&() { return tt; }
  24 private:
  25     SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  26 };
  27 #endif
  28
  29
  30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
  31 #  if defined(__SUNPRO_CC)
  32 #    define SWIG_TEMPLATE_DISAMBIGUATOR template
  33 #  else
  34 #    define SWIG_TEMPLATE_DISAMBIGUATOR
  35 #  endif
  36 #endif
  37
  38
  39 #include <Python.h>
  40
  41 /***********************************************************************
  42  * swigrun.swg
  43  *
  44  *     This file contains generic CAPI SWIG runtime support for pointer
  45  *     type checking.
  46  *
  47  ************************************************************************/
  48
  49 /* This should only be incremented when either the layout of swig_type_info changes,
  50    or for whatever reason, the runtime changes incompatibly */
  51 #define SWIG_RUNTIME_VERSION "1"
  52
  53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
  54 #ifdef SWIG_TYPE_TABLE
  55 #define SWIG_QUOTE_STRING(x) #x
  56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
  57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
  58 #else
  59 #define SWIG_TYPE_TABLE_NAME
  60 #endif
  61
  62 #include <string.h>
  63
  64 #ifndef SWIGINLINE
  65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  66 #  define SWIGINLINE inline
  67 #else
  68 #  define SWIGINLINE
  69 #endif
  70 #endif
  71
  72 /*
  73   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  74   creating a static or dynamic library from the swig runtime code.
  75   In 99.9% of the cases, swig just needs to declare them as 'static'.
  76
  77   But only do this if is strictly necessary, ie, if you have problems
  78   with your compiler or so.
  79 */
  80 #ifndef SWIGRUNTIME
  81 #define SWIGRUNTIME static
  82 #endif
  83 #ifndef SWIGRUNTIMEINLINE
  84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
  85 #endif
  86
  87 #ifdef __cplusplus
  88 extern "C" {
  89 #endif
  90
  91 typedef void *(*swig_converter_func)(void *);
  92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
  93
  94 typedef struct swig_type_info {
  95   const char             *name;
  96   swig_converter_func     converter;
  97   const char             *str;
  98   void                   *clientdata;
  99   swig_dycast_func        dcast;
 100   struct swig_type_info  *next;
 101   struct swig_type_info  *prev;
 102 } swig_type_info;
 103
 104 /*
 105   Compare two type names skipping the space characters, therefore
 106   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 107
 108   Return 0 when the two name types are equivalent, as in
 109   strncmp, but skipping ' '.
 110 */
 111 SWIGRUNTIME int
 112 SWIG_TypeNameComp(const char *f1, const char *l1,
 113                   const char *f2, const char *l2) {
 114   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 115     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 116     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 117     if (*f1 != *f2) return *f1 - *f2;
 118   }
 119   return (l1 - f1) - (l2 - f2);
 120 }
 121
 122 /*
 123   Check type equivalence in a name list like <name1>|<name2>|...
 124 */
 125 SWIGRUNTIME int
 126 SWIG_TypeEquiv(const char *nb, const char *tb) {
 127   int equiv = 0;
 128   const char* te = tb + strlen(tb);
 129   const char* ne = nb;
 130   while (!equiv && *ne) {
 131     for (nb = ne; *ne; ++ne) {
 132       if (*ne == '|') break;
 133     }
 134     equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
 135     if (*ne) ++ne;
 136   }
 137   return equiv;
 138 }
 139
 140 /*
 141   Register a type mapping with the type-checking
 142 */
 143 SWIGRUNTIME swig_type_info *
 144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
 145   swig_type_info *tc, *head, *ret, *next;
 146   /* Check to see if this type has already been registered */
 147   tc = *tl;
 148   while (tc) {
 149     /* check simple type equivalence */
 150     int typeequiv = (strcmp(tc->name, ti->name) == 0);
 151     /* check full type equivalence, resolving typedefs */
 152     if (!typeequiv) {
 153       /* only if tc is not a typedef (no '|' on it) */
 154       if (tc->str && ti->str && !strstr(tc->str,"|")) {
 155         typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
 156       }
 157     }
 158     if (typeequiv) {
 159       /* Already exists in the table.  Just add additional types to the list */
 160       if (ti->clientdata) tc->clientdata = ti->clientdata;
 161       head = tc;
 162       next = tc->next;
 163       goto l1;
 164     }
 165     tc = tc->prev;
 166   }
 167   head = ti;
 168   next = 0;
 169
 170   /* Place in list */
 171   ti->prev = *tl;
 172   *tl = ti;
 173
 174   /* Build linked lists */
 175   l1:
 176   ret = head;
 177   tc = ti + 1;
 178   /* Patch up the rest of the links */
 179   while (tc->name) {
 180     head->next = tc;
 181     tc->prev = head;
 182     head = tc;
 183     tc++;
 184   }
 185   if (next) next->prev = head;
 186   head->next = next;
 187
 188   return ret;
 189 }
 190
 191 /*
 192   Check the typename
 193 */
 194 SWIGRUNTIME swig_type_info *
 195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 196   swig_type_info *s;
 197   if (!ty) return 0;        /* Void pointer */
 198   s = ty->next;             /* First element always just a name */
 199   do {
 200     if (strcmp(s->name,c) == 0) {
 201       if (s == ty->next) return s;
 202       /* Move s to the top of the linked list */
 203       s->prev->next = s->next;
 204       if (s->next) {
 205         s->next->prev = s->prev;
 206       }
 207       /* Insert s as second element in the list */
 208       s->next = ty->next;
 209       if (ty->next) ty->next->prev = s;
 210       ty->next = s;
 211       s->prev = ty;
 212       return s;
 213     }
 214     s = s->next;
 215   } while (s && (s != ty->next));
 216   return 0;
 217 }
 218
 219 /*
 220   Cast a pointer up an inheritance hierarchy
 221 */
 222 SWIGRUNTIMEINLINE void *
 223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
 224   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
 225 }
 226
 227 /*
 228    Dynamic pointer casting. Down an inheritance hierarchy
 229 */
 230 SWIGRUNTIME swig_type_info *
 231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 232   swig_type_info *lastty = ty;
 233   if (!ty || !ty->dcast) return ty;
 234   while (ty && (ty->dcast)) {
 235     ty = (*ty->dcast)(ptr);
 236     if (ty) lastty = ty;
 237   }
 238   return lastty;
 239 }
 240
 241 /*
 242   Return the name associated with this type
 243 */
 244 SWIGRUNTIMEINLINE const char *
 245 SWIG_TypeName(const swig_type_info *ty) {
 246   return ty->name;
 247 }
 248
 249 /*
 250   Return the pretty name associated with this type,
 251   that is an unmangled type name in a form presentable to the user.
 252 */
 253 SWIGRUNTIME const char *
 254 SWIG_TypePrettyName(const swig_type_info *type) {
 255   /* The "str" field contains the equivalent pretty names of the
 256      type, separated by vertical-bar characters.  We choose
 257      to print the last name, as it is often (?) the most
 258      specific. */
 259   if (type->str != NULL) {
 260     const char *last_name = type->str;
 261     const char *s;
 262     for (s = type->str; *s; s++)
 263       if (*s == '|') last_name = s+1;
 264     return last_name;
 265   }
 266   else
 267     return type->name;
 268 }
 269
 270 /*
 271   Search for a swig_type_info structure
 272 */
 273 SWIGRUNTIME swig_type_info *
 274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
 275   swig_type_info *ty = tl;
 276   while (ty) {
 277     if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
 278     if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
 279     ty = ty->prev;
 280   }
 281   return 0;
 282 }
 283
 284 /*
 285    Set the clientdata field for a type
 286 */
 287 SWIGRUNTIME void
 288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
 289   swig_type_info *tc, *equiv;
 290   if (ti->clientdata) return;
 291   /* if (ti->clientdata == clientdata) return; */
 292   ti->clientdata = clientdata;
 293   equiv = ti->next;
 294   while (equiv) {
 295     if (!equiv->converter) {
 296       tc = tl;
 297       while (tc) {
 298         if ((strcmp(tc->name, equiv->name) == 0))
 299           SWIG_TypeClientDataTL(tl,tc,clientdata);
 300         tc = tc->prev;
 301       }
 302     }
 303     equiv = equiv->next;
 304   }
 305 }
 306
 307 /*
 308    Pack binary data into a string
 309 */
 310 SWIGRUNTIME char *
 311 SWIG_PackData(char *c, void *ptr, size_t sz) {
 312   static char hex[17] = "0123456789abcdef";
 313   unsigned char *u = (unsigned char *) ptr;
 314   const unsigned char *eu =  u + sz;
 315   register unsigned char uu;
 316   for (; u != eu; ++u) {
 317     uu = *u;
 318     *(c++) = hex[(uu & 0xf0) >> 4];
 319     *(c++) = hex[uu & 0xf];
 320   }
 321   return c;
 322 }
 323
 324 /*
 325    Unpack binary data from a string
 326 */
 327 SWIGRUNTIME const char *
 328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 329   register unsigned char *u = (unsigned char *) ptr;
 330   register const unsigned char *eu =  u + sz;
 331   for (; u != eu; ++u) {
 332     register int d = *(c++);
 333     register unsigned char uu = 0;
 334     if ((d >= '0') && (d <= '9'))
 335       uu = ((d - '0') << 4);
 336     else if ((d >= 'a') && (d <= 'f'))
 337       uu = ((d - ('a'-10)) << 4);
 338     else
 339       return (char *) 0;
 340     d = *(c++);
 341     if ((d >= '0') && (d <= '9'))
 342       uu |= (d - '0');
 343     else if ((d >= 'a') && (d <= 'f'))
 344       uu |= (d - ('a'-10));
 345     else
 346       return (char *) 0;
 347     *u = uu;
 348   }
 349   return c;
 350 }
 351
 352 /*
 353   This function will propagate the clientdata field of type to any new
 354   swig_type_info structures that have been added into the list of
 355   equivalent types.  It is like calling SWIG_TypeClientData(type,
 356   clientdata) a second time.
 357 */
 358 SWIGRUNTIME void
 359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
 360   swig_type_info *equiv = type->next;
 361   swig_type_info *tc;
 362   if (!type->clientdata) return;
 363   while (equiv) {
 364     if (!equiv->converter) {
 365       tc = tl;
 366       while (tc) {
 367         if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
 368           SWIG_TypeClientDataTL(tl,tc, type->clientdata);
 369         tc = tc->prev;
 370       }
 371     }
 372     equiv = equiv->next;
 373   }
 374 }
 375
 376 /*
 377    Pack 'void *' into a string buffer.
 378 */
 379 SWIGRUNTIME char *
 380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 381   char *r = buff;
 382   if ((2*sizeof(void *) + 2) > bsz) return 0;
 383   *(r++) = '_';
 384   r = SWIG_PackData(r,&ptr,sizeof(void *));
 385   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 386   strcpy(r,name);
 387   return buff;
 388 }
 389
 390 SWIGRUNTIME const char *
 391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 392   if (*c != '_') {
 393     if (strcmp(c,"NULL") == 0) {
 394       *ptr = (void *) 0;
 395       return name;
 396     } else {
 397       return 0;
 398     }
 399   }
 400   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 401 }
 402
 403 SWIGRUNTIME char *
 404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 405   char *r = buff;
 406   size_t lname = (name ? strlen(name) : 0);
 407   if ((2*sz + 2 + lname) > bsz) return 0;
 408   *(r++) = '_';
 409   r = SWIG_PackData(r,ptr,sz);
 410   if (lname) {
 411     strncpy(r,name,lname+1);
 412   } else {
 413     *r = 0;
 414   }
 415   return buff;
 416 }
 417
 418 SWIGRUNTIME const char *
 419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 420   if (*c != '_') {
 421     if (strcmp(c,"NULL") == 0) {
 422       memset(ptr,0,sz);
 423       return name;
 424     } else {
 425       return 0;
 426     }
 427   }
 428   return SWIG_UnpackData(++c,ptr,sz);
 429 }
 430
 431 #ifdef __cplusplus
 432 }
 433 #endif
 434
 435 /***********************************************************************
 436  * common.swg
 437  *
 438  *     This file contains generic SWIG runtime support for pointer
 439  *     type checking as well as a few commonly used macros to control
 440  *     external linkage.
 441  *
 442  * Author : David Beazley (beazley@cs.uchicago.edu)
 443  *
 444  * Copyright (c) 1999-2000, The University of Chicago
 445  *
 446  * This file may be freely redistributed without license or fee provided
 447  * this copyright message remains intact.
 448  ************************************************************************/
 449
 450
 451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 452 #  if !defined(STATIC_LINKED)
 453 #    define SWIGEXPORT(a) __declspec(dllexport) a
 454 #  else
 455 #    define SWIGEXPORT(a) a
 456 #  endif
 457 #else
 458 #  define SWIGEXPORT(a) a
 459 #endif
 460
 461 #ifdef __cplusplus
 462 extern "C" {
 463 #endif
 464
 465
 466 /*************************************************************************/
 467
 468
 469 /* The static type info list */
 470
 471 static swig_type_info *swig_type_list = 0;
 472 static swig_type_info **swig_type_list_handle = &swig_type_list;
 473
 474
 475 /* Register a type mapping with the type-checking */
 476 static swig_type_info *
 477 SWIG_TypeRegister(swig_type_info *ti) {
 478   return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
 479 }
 480
 481 /* Search for a swig_type_info structure */
 482 static swig_type_info *
 483 SWIG_TypeQuery(const char *name) {
 484   return SWIG_TypeQueryTL(*swig_type_list_handle, name);
 485 }
 486
 487 /* Set the clientdata field for a type */
 488 static void
 489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 490   SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
 491 }
 492
 493 /* This function will propagate the clientdata field of type to
 494 * any new swig_type_info structures that have been added into the list
 495 * of equivalent types.  It is like calling
 496 * SWIG_TypeClientData(type, clientdata) a second time.
 497 */
 498 static void
 499 SWIG_PropagateClientData(swig_type_info *type) {
 500   SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
 501 }
 502
 503 #ifdef __cplusplus
 504 }
 505 #endif
 506
 507 /* -----------------------------------------------------------------------------
 508  * SWIG API. Portion that goes into the runtime
 509  * ----------------------------------------------------------------------------- */
 510
 511 #ifdef __cplusplus
 512 extern "C" {
 513 #endif
 514
 515 /* -----------------------------------------------------------------------------
 516  * for internal method declarations
 517  * ----------------------------------------------------------------------------- */
 518
 519 #ifndef SWIGINTERN
 520 #define SWIGINTERN static
 521 #endif
 522
 523 #ifndef SWIGINTERNSHORT
 524 #ifdef __cplusplus
 525 #define SWIGINTERNSHORT static inline
 526 #else /* C case */
 527 #define SWIGINTERNSHORT static
 528 #endif /* __cplusplus */
 529 #endif
 530
 531
 532 /*
 533   Exception handling in wrappers
 534 */
 535 #define SWIG_fail                goto fail
 536 #define SWIG_arg_fail(arg)       SWIG_Python_ArgFail(arg)
 537 #define SWIG_append_errmsg(msg)   SWIG_Python_AddErrMesg(msg,0)
 538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
 539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
 540 #define SWIG_null_ref(type)       SWIG_Python_NullRef(type)
 541
 542 /*
 543   Contract support
 544 */
 545 #define SWIG_contract_assert(expr, msg) \
 546  if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
 547
 548 /* -----------------------------------------------------------------------------
 549  * Constant declarations
 550  * ----------------------------------------------------------------------------- */
 551
 552 /* Constant Types */
 553 #define SWIG_PY_INT     1
 554 #define SWIG_PY_FLOAT   2
 555 #define SWIG_PY_STRING  3
 556 #define SWIG_PY_POINTER 4
 557 #define SWIG_PY_BINARY  5
 558
 559 /* Constant information structure */
 560 typedef struct swig_const_info {
 561     int type;
 562     char *name;
 563     long lvalue;
 564     double dvalue;
 565     void   *pvalue;
 566     swig_type_info **ptype;
 567 } swig_const_info;
 568
 569
 570 /* -----------------------------------------------------------------------------
 571  * Alloc. memory flags
 572  * ----------------------------------------------------------------------------- */
 573 #define SWIG_OLDOBJ  1
 574 #define SWIG_NEWOBJ  SWIG_OLDOBJ + 1
 575 #define SWIG_PYSTR   SWIG_NEWOBJ + 1
 576
 577 #ifdef __cplusplus
 578 }
 579 #endif
 580
 581
 582 /***********************************************************************
 583  * pyrun.swg
 584  *
 585  *     This file contains the runtime support for Python modules
 586  *     and includes code for managing global variables and pointer
 587  *     type checking.
 588  *
 589  * Author : David Beazley (beazley@cs.uchicago.edu)
 590  ************************************************************************/
 591
 592 /* Common SWIG API */
 593 #define SWIG_ConvertPtr(obj, pp, type, flags)    SWIG_Python_ConvertPtr(obj, pp, type, flags)
 594 #define SWIG_NewPointerObj(p, type, flags)       SWIG_Python_NewPointerObj(p, type, flags)
 595 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
 596
 597
 598 /* Python-specific SWIG API */
 599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags)   SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
 600 #define SWIG_NewPackedObj(ptr, sz, type)              SWIG_Python_NewPackedObj(ptr, sz, type)
 601
 602
 603 /* -----------------------------------------------------------------------------
 604  * Pointer declarations
 605  * ----------------------------------------------------------------------------- */
 606 /*
 607   Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
 608   C/C++ pointers in the python side. Very useful for debugging, but
 609   not always safe.
 610 */
 611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
 612 #  define SWIG_COBJECT_TYPES
 613 #endif
 614
 615 /* Flags for pointer conversion */
 616 #define SWIG_POINTER_EXCEPTION     0x1
 617 #define SWIG_POINTER_DISOWN        0x2
 618
 619
 620 #ifdef __cplusplus
 621 extern "C" {
 622 #endif
 623
 624 /* -----------------------------------------------------------------------------
 625  * Create a new pointer string
 626  * ----------------------------------------------------------------------------- */
 627
 628 #ifndef SWIG_BUFFER_SIZE
 629 #define SWIG_BUFFER_SIZE 1024
 630 #endif
 631
 632 #if defined(SWIG_COBJECT_TYPES)
 633 #if !defined(SWIG_COBJECT_PYTHON)
 634 /* -----------------------------------------------------------------------------
 635  * Implements a simple Swig Object type, and use it instead of PyCObject
 636  * ----------------------------------------------------------------------------- */
 637
 638 typedef struct {
 639   PyObject_HEAD
 640   void *ptr;
 641   const char *desc;
 642 } PySwigObject;
 643
 644 /* Declarations for objects of type PySwigObject */
 645
 646 SWIGRUNTIME int
 647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
 648 {
 649   char result[SWIG_BUFFER_SIZE];
 650   if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
 651     fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
 652     return 0;
 653   } else {
 654     return 1;
 655   }
 656 }
 657
 658 SWIGRUNTIME PyObject *
 659 PySwigObject_repr(PySwigObject *v)
 660 {
 661   char result[SWIG_BUFFER_SIZE];
 662   return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
 663     PyString_FromFormat("<Swig Object at %s>", result) : 0;
 664 }
 665
 666 SWIGRUNTIME PyObject *
 667 PySwigObject_str(PySwigObject *v)
 668 {
 669   char result[SWIG_BUFFER_SIZE];
 670   return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
 671     PyString_FromString(result) : 0;
 672 }
 673
 674 SWIGRUNTIME PyObject *
 675 PySwigObject_long(PySwigObject *v)
 676 {
 677   return PyLong_FromUnsignedLong((unsigned long) v->ptr);
 678 }
 679
 680 SWIGRUNTIME PyObject *
 681 PySwigObject_oct(PySwigObject *v)
 682 {
 683   char buf[100];
 684   unsigned long x = (unsigned long)v->ptr;
 685   if (x == 0)
 686     strcpy(buf, "0");
 687   else
 688     PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
 689   return PyString_FromString(buf);
 690 }
 691
 692 SWIGRUNTIME PyObject *
 693 PySwigObject_hex(PySwigObject *v)
 694 {
 695   char buf[100];
 696   PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
 697   return PyString_FromString(buf);
 698 }
 699
 700 SWIGRUNTIME int
 701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
 702 {
 703   int c = strcmp(v->desc, w->desc);
 704   if (c) {
 705     return c;
 706   } else {
 707     void *i = v->ptr;
 708     void *j = w->ptr;
 709     return (i < j) ? -1 : (i > j) ? 1 : 0;
 710   }
 711 }
 712
 713 SWIGRUNTIME void
 714 PySwigObject_dealloc(PySwigObject *self)
 715 {
 716   PyObject_DEL(self);
 717 }
 718
 719 SWIGRUNTIME PyTypeObject*
 720 PySwigObject_GetType() {
 721   static char PySwigObject_Type__doc__[] =
 722     "Swig object carries a C/C++ instance pointer";
 723
 724   static PyNumberMethods PySwigObject_as_number = {
 725     (binaryfunc)0, /*nb_add*/
 726     (binaryfunc)0, /*nb_subtract*/
 727     (binaryfunc)0, /*nb_multiply*/
 728     (binaryfunc)0, /*nb_divide*/
 729     (binaryfunc)0, /*nb_remainder*/
 730     (binaryfunc)0, /*nb_divmod*/
 731     (ternaryfunc)0,/*nb_power*/
 732     (unaryfunc)0,  /*nb_negative*/
 733     (unaryfunc)0,  /*nb_positive*/
 734     (unaryfunc)0,  /*nb_absolute*/
 735     (inquiry)0,    /*nb_nonzero*/
 736     0,             /*nb_invert*/
 737     0,             /*nb_lshift*/
 738     0,             /*nb_rshift*/
 739     0,             /*nb_and*/
 740     0,             /*nb_xor*/
 741     0,             /*nb_or*/
 742     (coercion)0,   /*nb_coerce*/
 743     (unaryfunc)PySwigObject_long, /*nb_int*/
 744     (unaryfunc)PySwigObject_long, /*nb_long*/
 745     (unaryfunc)0,                 /*nb_float*/
 746     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
 747     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
 748 #if PY_VERSION_HEX >= 0x02000000
 749     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
 750 #endif
 751   };
 752
 753   static int type_init = 0;
 754   static PyTypeObject PySwigObject_Type;
 755
 756   if (!type_init) {
 757     PyTypeObject tmp = {
 758     PyObject_HEAD_INIT(&PyType_Type)
 759     0,                                  /*ob_size*/
 760     "PySwigObject",                     /*tp_name*/
 761     sizeof(PySwigObject),               /*tp_basicsize*/
 762     0,                                  /*tp_itemsize*/
 763     /* methods */
 764     (destructor)PySwigObject_dealloc,   /*tp_dealloc*/
 765     (printfunc)PySwigObject_print,      /*tp_print*/
 766     (getattrfunc)0,                     /*tp_getattr*/
 767     (setattrfunc)0,                     /*tp_setattr*/
 768     (cmpfunc)PySwigObject_compare,      /*tp_compare*/
 769     (reprfunc)PySwigObject_repr,        /*tp_repr*/
 770     &PySwigObject_as_number,            /*tp_as_number*/
 771     0,                                  /*tp_as_sequence*/
 772     0,                                  /*tp_as_mapping*/
 773     (hashfunc)0,                        /*tp_hash*/
 774     (ternaryfunc)0,                     /*tp_call*/
 775     (reprfunc)PySwigObject_str,         /*tp_str*/
 776     /* Space for future expansion */
 777     0L,0L,0L,0L,
 778     PySwigObject_Type__doc__,           /* Documentation string */
 779 #if PY_VERSION_HEX >= 0x02000000
 780     0,                                  /* tp_traverse */
 781     0,                                  /* tp_clear */
 782 #endif
 783 #if PY_VERSION_HEX >= 0x02010000
 784     0,                                  /* tp_richcompare */
 785     0,                                  /* tp_weaklistoffset */
 786 #endif
 787 #if PY_VERSION_HEX >= 0x02020000
 788     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
 789 #endif
 790 #if PY_VERSION_HEX >= 0x02030000
 791     0,                                  /* tp_del */
 792 #endif
 793 #ifdef COUNT_ALLOCS
 794     0,0,0,0                             /* tp_alloc -> tp_next */
 795 #endif
 796     };
 797
 798     PySwigObject_Type = tmp;
 799     type_init = 1;
 800   }
 801
 802   return &PySwigObject_Type;
 803 }
 804
 805 SWIGRUNTIME PyObject *
 806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
 807 {
 808   PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
 809   if (self == NULL) return NULL;
 810   self->ptr = ptr;
 811   self->desc = desc;
 812   return (PyObject *)self;
 813 }
 814
 815 SWIGRUNTIMEINLINE void *
 816 PySwigObject_AsVoidPtr(PyObject *self)
 817 {
 818   return ((PySwigObject *)self)->ptr;
 819 }
 820
 821 SWIGRUNTIMEINLINE const char *
 822 PySwigObject_GetDesc(PyObject *self)
 823 {
 824   return ((PySwigObject *)self)->desc;
 825 }
 826
 827 SWIGRUNTIMEINLINE int
 828 PySwigObject_Check(PyObject *op) {
 829   return ((op)->ob_type == PySwigObject_GetType())
 830     || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
 831 }
 832
 833 /* -----------------------------------------------------------------------------
 834  * Implements a simple Swig Packed type, and use it instead of string
 835  * ----------------------------------------------------------------------------- */
 836
 837 typedef struct {
 838   PyObject_HEAD
 839   void *pack;
 840   const char *desc;
 841   size_t size;
 842 } PySwigPacked;
 843
 844 SWIGRUNTIME int
 845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
 846 {
 847   char result[SWIG_BUFFER_SIZE];
 848   fputs("<Swig Packed ", fp);
 849   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
 850     fputs("at ", fp);
 851     fputs(result, fp);
 852   }
 853   fputs(v->desc,fp);
 854   fputs(">", fp);
 855   return 0;
 856 }
 857
 858 SWIGRUNTIME PyObject *
 859 PySwigPacked_repr(PySwigPacked *v)
 860 {
 861   char result[SWIG_BUFFER_SIZE];
 862   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
 863     return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
 864   } else {
 865     return PyString_FromFormat("<Swig Packed %s>", v->desc);
 866   }
 867 }
 868
 869 SWIGRUNTIME PyObject *
 870 PySwigPacked_str(PySwigPacked *v)
 871 {
 872   char result[SWIG_BUFFER_SIZE];
 873   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
 874     return PyString_FromFormat("%s%s", result, v->desc);
 875   } else {
 876     return PyString_FromFormat("%s", v->desc);
 877   }
 878 }
 879
 880 SWIGRUNTIME int
 881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
 882 {
 883   int c = strcmp(v->desc, w->desc);
 884   if (c) {
 885     return c;
 886   } else {
 887     size_t i = v->size;
 888     size_t j = w->size;
 889     int s = (i < j) ? -1 : (i > j) ? 1 : 0;
 890     return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
 891   }
 892 }
 893
 894 SWIGRUNTIME void
 895 PySwigPacked_dealloc(PySwigPacked *self)
 896 {
 897   free(self->pack);
 898   PyObject_DEL(self);
 899 }
 900
 901 SWIGRUNTIME PyTypeObject*
 902 PySwigPacked_GetType() {
 903   static char PySwigPacked_Type__doc__[] =
 904     "Swig object carries a C/C++ instance pointer";
 905   static int type_init = 0;
 906
 907   static PyTypeObject PySwigPacked_Type;
 908   if (!type_init) {
 909     PyTypeObject tmp = {
 910     PyObject_HEAD_INIT(&PyType_Type)
 911     0,                                  /*ob_size*/
 912     "PySwigPacked",                     /*tp_name*/
 913     sizeof(PySwigPacked),               /*tp_basicsize*/
 914     0,                                  /*tp_itemsize*/
 915     /* methods */
 916     (destructor)PySwigPacked_dealloc,   /*tp_dealloc*/
 917     (printfunc)PySwigPacked_print,      /*tp_print*/
 918     (getattrfunc)0,                     /*tp_getattr*/
 919     (setattrfunc)0,                     /*tp_setattr*/
 920     (cmpfunc)PySwigPacked_compare,      /*tp_compare*/
 921     (reprfunc)PySwigPacked_repr,        /*tp_repr*/
 922     0,                                  /*tp_as_number*/
 923     0,                                  /*tp_as_sequence*/
 924     0,                                  /*tp_as_mapping*/
 925     (hashfunc)0,                        /*tp_hash*/
 926     (ternaryfunc)0,                     /*tp_call*/
 927     (reprfunc)PySwigPacked_str,         /*tp_str*/
 928     /* Space for future expansion */
 929     0L,0L,0L,0L,
 930     PySwigPacked_Type__doc__,           /* Documentation string */
 931 #if PY_VERSION_HEX >= 0x02000000
 932     0,                                  /* tp_traverse */
 933     0,                                  /* tp_clear */
 934 #endif
 935 #if PY_VERSION_HEX >= 0x02010000
 936     0,                                  /* tp_richcompare */
 937     0,                                  /* tp_weaklistoffset */
 938 #endif
 939 #if PY_VERSION_HEX >= 0x02020000
 940     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
 941 #endif
 942 #if PY_VERSION_HEX >= 0x02030000
 943     0,                                  /* tp_del */
 944 #endif
 945 #ifdef COUNT_ALLOCS
 946     0,0,0,0                             /* tp_alloc -> tp_next */
 947 #endif
 948     };
 949
 950     PySwigPacked_Type = tmp;
 951     type_init = 1;
 952   }
 953
 954
 955
 956   return &PySwigPacked_Type;
 957 }
 958
 959 SWIGRUNTIME PyObject *
 960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
 961 {
 962   PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
 963   if (self == NULL) {
 964     return NULL;
 965   } else {
 966     void *pack = malloc(size);
 967     memcpy(pack, ptr, size);
 968     self->pack = pack;
 969     self->desc = desc;
 970     self->size = size;
 971     return (PyObject *) self;
 972   }
 973 }
 974
 975 SWIGRUNTIMEINLINE const char *
 976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
 977 {
 978   PySwigPacked *self = (PySwigPacked *)obj;
 979   if (self->size != size) return 0;
 980   memcpy(ptr, self->pack, size);
 981   return self->desc;
 982 }
 983
 984 SWIGRUNTIMEINLINE const char *
 985 PySwigPacked_GetDesc(PyObject *self)
 986 {
 987   return ((PySwigPacked *)self)->desc;
 988 }
 989
 990 SWIGRUNTIMEINLINE int
 991 PySwigPacked_Check(PyObject *op) {
 992   return ((op)->ob_type == PySwigPacked_GetType())
 993     || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
 994 }
 995
 996 #else
 997 /* -----------------------------------------------------------------------------
 998  * Use the old Python PyCObject instead of PySwigObject
 999  * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj)                  PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj)            PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj)        PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d)  PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011  * errors manipulation
1012  * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017   if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019     if (PySwigObject_Check(obj)) {
1020       const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021       if (otype) {
1022         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023                      type, otype);
1024         return;
1025       }
1026     } else
1027 #endif
1028     {
1029       const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030       if (otype) {
1031         PyObject *str = PyObject_Str(obj);
1032         const char *cstr = str ? PyString_AsString(str) : 0;
1033         if (cstr) {
1034           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035                        type, otype, cstr);
1036         } else {
1037           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038                        type, otype);
1039         }
1040         Py_DECREF(str);
1041         return;
1042       }
1043     }
1044     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045   } else {
1046     PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047   }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053   if (type) {
1054     PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055   } else {
1056     PyErr_Format(PyExc_TypeError, "null reference was received");
1057   }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063   if (PyErr_Occurred()) {
1064     PyObject *type = 0;
1065     PyObject *value = 0;
1066     PyObject *traceback = 0;
1067     PyErr_Fetch(&type, &value, &traceback);
1068     if (value) {
1069       PyObject *old_str = PyObject_Str(value);
1070       Py_XINCREF(type);
1071       PyErr_Clear();
1072       if (infront) {
1073         PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074       } else {
1075         PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076       }
1077       Py_DECREF(old_str);
1078     }
1079     return 1;
1080   } else {
1081     return 0;
1082   }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088   if (PyErr_Occurred()) {
1089     /* add information about failing argument */
1090     char mesg[256];
1091     sprintf(mesg, "argument number %d:", argnum);
1092     return SWIG_Python_AddErrMesg(mesg, 1);
1093   } else {
1094     return 0;
1095   }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100  * pointers/data manipulation
1101  * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106   swig_type_info *tc;
1107   const char *c = 0;
1108   static PyObject *SWIG_this = 0;
1109   int    newref = 0;
1110   PyObject  *pyobj = 0;
1111   void *vptr;
1112
1113   if (!obj) return 0;
1114   if (obj == Py_None) {
1115     *ptr = 0;
1116     return 0;
1117   }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120   if (!(PySwigObject_Check(obj))) {
1121     if (!SWIG_this)
1122       SWIG_this = PyString_FromString("this");
1123     pyobj = obj;
1124     obj = PyObject_GetAttr(obj,SWIG_this);
1125     newref = 1;
1126     if (!obj) goto type_error;
1127     if (!PySwigObject_Check(obj)) {
1128       Py_DECREF(obj);
1129       goto type_error;
1130     }
1131   }
1132   vptr = PySwigObject_AsVoidPtr(obj);
1133   c = (const char *) PySwigObject_GetDesc(obj);
1134   if (newref) { Py_DECREF(obj); }
1135   goto type_check;
1136 #else
1137   if (!(PyString_Check(obj))) {
1138     if (!SWIG_this)
1139       SWIG_this = PyString_FromString("this");
1140     pyobj = obj;
1141     obj = PyObject_GetAttr(obj,SWIG_this);
1142     newref = 1;
1143     if (!obj) goto type_error;
1144     if (!PyString_Check(obj)) {
1145       Py_DECREF(obj);
1146       goto type_error;
1147     }
1148   }
1149   c = PyString_AS_STRING(obj);
1150   /* Pointer values must start with leading underscore */
1151   c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152   if (newref) { Py_DECREF(obj); }
1153   if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158   if (ty) {
1159     tc = SWIG_TypeCheck(c,ty);
1160     if (!tc) goto type_error;
1161     *ptr = SWIG_TypeCast(tc,vptr);
1162   } else {
1163     *ptr = vptr;
1164   }
1165
1166   if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167     PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168   }
1169   return 0;
1170
1171 type_error:
1172   PyErr_Clear();
1173   if (pyobj && !obj) {
1174     obj = pyobj;
1175     if (PyCFunction_Check(obj)) {
1176       /* here we get the method pointer for callbacks */
1177       char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178       c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179       if (c) {
1180         c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181         if (!c) goto type_error;
1182         goto type_check;
1183       }
1184     }
1185   }
1186   if (flags & SWIG_POINTER_EXCEPTION) {
1187     if (ty) {
1188       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189     } else {
1190       SWIG_Python_TypeError("C/C++ pointer", obj);
1191     }
1192   }
1193   return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199   void *result;
1200   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201     PyErr_Clear();
1202     if (flags & SWIG_POINTER_EXCEPTION) {
1203       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204       SWIG_Python_ArgFail(argnum);
1205     }
1206   }
1207   return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213   swig_type_info *tc;
1214   const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217   c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219   if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220   c = PyString_AS_STRING(obj);
1221   /* Pointer values must start with leading underscore */
1222   c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224   if (!c) goto type_error;
1225   if (ty) {
1226     tc = SWIG_TypeCheck(c,ty);
1227     if (!tc) goto type_error;
1228   }
1229   return 0;
1230
1231 type_error:
1232   PyErr_Clear();
1233   if (flags & SWIG_POINTER_EXCEPTION) {
1234     if (ty) {
1235       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236     } else {
1237       SWIG_Python_TypeError("C/C++ packed data", obj);
1238     }
1239   }
1240   return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246   PyObject *robj = 0;
1247   if (!ptr) {
1248     Py_INCREF(Py_None);
1249     return Py_None;
1250   }
1251 #ifdef SWIG_COBJECT_TYPES
1252   robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254   {
1255     char result[SWIG_BUFFER_SIZE];
1256     robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257       PyString_FromString(result) : 0;
1258   }
1259 #endif
1260   if (!robj || (robj == Py_None)) return robj;
1261   if (type->clientdata) {
1262     PyObject *inst;
1263     PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264     Py_DECREF(robj);
1265     inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266     Py_DECREF(args);
1267     if (inst) {
1268       if (own) {
1269         PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270       }
1271       robj = inst;
1272     }
1273   }
1274   return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279   PyObject *robj = 0;
1280   if (!ptr) {
1281     Py_INCREF(Py_None);
1282     return Py_None;
1283   }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285   robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287   {
1288     char result[SWIG_BUFFER_SIZE];
1289     robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290       PyString_FromString(result) : 0;
1291   }
1292 #endif
1293   return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297  *  Get type list
1298  * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306   static void *type_pointer = (void *)0;
1307   /* first check if module already created */
1308   if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314     if (PyErr_Occurred()) {
1315       PyErr_Clear();
1316       type_pointer = (void *)0;
1317     }
1318   }
1319 #endif
1320   return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324   Search for a swig_type_info structure
1325  */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328   swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329   return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define  SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[0]
1342 #define  SWIGTYPE_p_wxPreviewFrame swig_types[1]
1343 #define  SWIGTYPE_p_wxPyPreviewFrame swig_types[2]
1344 #define  SWIGTYPE_p_wxPyPanel swig_types[3]
1345 #define  SWIGTYPE_p_wxMenu swig_types[4]
1346 #define  SWIGTYPE_p_wxFontData swig_types[5]
1347 #define  SWIGTYPE_p_wxEvent swig_types[6]
1348 #define  SWIGTYPE_p_wxPrintData swig_types[7]
1349 #define  SWIGTYPE_p_wxTaskBarIcon swig_types[8]
1350 #define  SWIGTYPE_p_wxPyTaskBarIcon swig_types[9]
1351 #define  SWIGTYPE_p_wxIconBundle swig_types[10]
1352 #define  SWIGTYPE_p_wxLayoutAlgorithm swig_types[11]
1353 #define  SWIGTYPE_p_wxFindDialogEvent swig_types[12]
1354 #define  SWIGTYPE_p_wxPreviewCanvas swig_types[13]
1355 #define  SWIGTYPE_p_wxFont swig_types[14]
1356 #define  SWIGTYPE_p_wxSplitterEvent swig_types[15]
1357 #define  SWIGTYPE_p_wxRegion swig_types[16]
1358 #define  SWIGTYPE_ptrdiff_t swig_types[17]
1359 #define  SWIGTYPE_std__ptrdiff_t swig_types[18]
1360 #define  SWIGTYPE_p_wxFindReplaceData swig_types[19]
1361 #define  SWIGTYPE_p_int swig_types[20]
1362 #define  SWIGTYPE_p_wxSize swig_types[21]
1363 #define  SWIGTYPE_p_wxDC swig_types[22]
1364 #define  SWIGTYPE_p_wxIcon swig_types[23]
1365 #define  SWIGTYPE_p_wxVisualAttributes swig_types[24]
1366 #define  SWIGTYPE_p_wxMDIChildFrame swig_types[25]
1367 #define  SWIGTYPE_p_wxColourData swig_types[26]
1368 #define  SWIGTYPE_p_wxNotifyEvent swig_types[27]
1369 #define  SWIGTYPE_p_wxPyWindow swig_types[28]
1370 #define  SWIGTYPE_p_form_ops_t swig_types[29]
1371 #define  SWIGTYPE_p_wxSplashScreen swig_types[30]
1372 #define  SWIGTYPE_p_wxPasswordEntryDialog swig_types[31]
1373 #define  SWIGTYPE_p_wxSingleChoiceDialog swig_types[32]
1374 #define  SWIGTYPE_p_wxMultiChoiceDialog swig_types[33]
1375 #define  SWIGTYPE_p_wxFileDialog swig_types[34]
1376 #define  SWIGTYPE_p_wxTextEntryDialog swig_types[35]
1377 #define  SWIGTYPE_p_wxMessageDialog swig_types[36]
1378 #define  SWIGTYPE_p_wxProgressDialog swig_types[37]
1379 #define  SWIGTYPE_p_wxFindReplaceDialog swig_types[38]
1380 #define  SWIGTYPE_p_wxPrinter swig_types[39]
1381 #define  SWIGTYPE_p_wxArrayInt swig_types[40]
1382 #define  SWIGTYPE_p_wxDuplexMode swig_types[41]
1383 #define  SWIGTYPE_p_wxEvtHandler swig_types[42]
1384 #define  SWIGTYPE_p_wxCalculateLayoutEvent swig_types[43]
1385 #define  SWIGTYPE_p_wxPyHtmlListBox swig_types[44]
1386 #define  SWIGTYPE_p_wxPyVListBox swig_types[45]
1387 #define  SWIGTYPE_p_wxRect swig_types[46]
1388 #define  SWIGTYPE_p_wxStdDialogButtonSizer swig_types[47]
1389 #define  SWIGTYPE_p_char swig_types[48]
1390 #define  SWIGTYPE_p_wxMiniFrame swig_types[49]
1391 #define  SWIGTYPE_p_wxFrame swig_types[50]
1392 #define  SWIGTYPE_p_wxPyPrintout swig_types[51]
1393 #define  SWIGTYPE_p_wxTaskBarIconEvent swig_types[52]
1394 #define  SWIGTYPE_p_wxScrollWinEvent swig_types[53]
1395 #define  SWIGTYPE_p_wxPaperSize swig_types[54]
1396 #define  SWIGTYPE_p_wxStatusBar swig_types[55]
1397 #define  SWIGTYPE_p_wxMDIParentFrame swig_types[56]
1398 #define  SWIGTYPE_p_wxPoint swig_types[57]
1399 #define  SWIGTYPE_p_wxObject swig_types[58]
1400 #define  SWIGTYPE_p_unsigned_long swig_types[59]
1401 #define  SWIGTYPE_p_wxTipWindow swig_types[60]
1402 #define  SWIGTYPE_p_wxSashLayoutWindow swig_types[61]
1403 #define  SWIGTYPE_p_wxSplitterWindow swig_types[62]
1404 #define  SWIGTYPE_p_wxSplashScreenWindow swig_types[63]
1405 #define  SWIGTYPE_p_wxPyVScrolledWindow swig_types[64]
1406 #define  SWIGTYPE_p_wxPyPopupTransientWindow swig_types[65]
1407 #define  SWIGTYPE_p_wxPopupWindow swig_types[66]
1408 #define  SWIGTYPE_p_wxSashWindow swig_types[67]
1409 #define  SWIGTYPE_p_wxTopLevelWindow swig_types[68]
1410 #define  SWIGTYPE_p_wxWindow swig_types[69]
1411 #define  SWIGTYPE_p_wxScrolledWindow swig_types[70]
1412 #define  SWIGTYPE_p_wxMenuBar swig_types[71]
1413 #define  SWIGTYPE_p_wxMDIClientWindow swig_types[72]
1414 #define  SWIGTYPE_p_wxPyScrolledWindow swig_types[73]
1415 #define  SWIGTYPE_p_wxPrintPreview swig_types[74]
1416 #define  SWIGTYPE_p_wxSashEvent swig_types[75]
1417 #define  SWIGTYPE_p_wxString swig_types[76]
1418 #define  SWIGTYPE_p_wxPyPrintPreview swig_types[77]
1419 #define  SWIGTYPE_p_wxDirDialog swig_types[78]
1420 #define  SWIGTYPE_p_wxColourDialog swig_types[79]
1421 #define  SWIGTYPE_p_wxDialog swig_types[80]
1422 #define  SWIGTYPE_p_wxPanel swig_types[81]
1423 #define  SWIGTYPE_p_wxFontDialog swig_types[82]
1424 #define  SWIGTYPE_p_wxPageSetupDialog swig_types[83]
1425 #define  SWIGTYPE_p_wxPrintDialog swig_types[84]
1426 #define  SWIGTYPE_p_wxFileSystem swig_types[85]
1427 #define  SWIGTYPE_p_wxBitmap swig_types[86]
1428 #define  SWIGTYPE_unsigned_int swig_types[87]
1429 #define  SWIGTYPE_p_unsigned_int swig_types[88]
1430 #define  SWIGTYPE_p_unsigned_char swig_types[89]
1431 #define  SWIGTYPE_p_wxCommandEvent swig_types[90]
1432 #define  SWIGTYPE_p_wxPreviewControlBar swig_types[91]
1433 #define  SWIGTYPE_p_wxPyPreviewControlBar swig_types[92]
1434 #define  SWIGTYPE_p_wxColour swig_types[93]
1435 #define  SWIGTYPE_p_wxToolBar swig_types[94]
1436 #define  SWIGTYPE_p_wxPageSetupDialogData swig_types[95]
1437 #define  SWIGTYPE_p_wxPrintDialogData swig_types[96]
1438 static swig_type_info *swig_types[98];
1439
1440 /* -------- TYPES TABLE (END) -------- */
1441
1442
1443 /*-----------------------------------------------
1444               @(target):= _windows_.so
1445   ------------------------------------------------*/
1446 #define SWIG_init    init_windows_
1447
1448 #define SWIG_name    "_windows_"
1449
1450 #include "wx/wxPython/wxPython.h"
1451 #include "wx/wxPython/pyclasses.h"
1452
1453
1454  static const wxString wxPyEmptyString(wxEmptyString);
1455  static const wxString wxPyPanelNameStr(wxPanelNameStr);
1456
1457
1458
1459 #include <limits.h>
1460
1461
1462 SWIGINTERN int
1463   SWIG_CheckLongInRange(long value, long min_value, long max_value,
1464                         const char *errmsg)
1465 {
1466   if (value < min_value) {
1467     if (errmsg) {
1468       PyErr_Format(PyExc_OverflowError,
1469                    "value %ld is less than '%s' minimum %ld",
1470                    value, errmsg, min_value);
1471     }
1472     return 0;
1473   } else if (value > max_value) {
1474     if (errmsg) {
1475       PyErr_Format(PyExc_OverflowError,
1476                    "value %ld is greater than '%s' maximum %ld",
1477                    value, errmsg, max_value);
1478     }
1479     return 0;
1480   }
1481   return 1;
1482 }
1483
1484
1485 SWIGINTERN int
1486 SWIG_AsVal_long(PyObject* obj, long* val)
1487 {
1488     if (PyNumber_Check(obj)) {
1489         if (val) *val = PyInt_AsLong(obj);
1490         return 1;
1491     }
1492     else {
1493         SWIG_type_error("number", obj);
1494     }
1495     return 0;
1496 }
1497
1498
1499 #if INT_MAX != LONG_MAX
1500 SWIGINTERN int
1501   SWIG_AsVal_int(PyObject *obj, int *val)
1502 {
1503   const char* errmsg = val ? "int" : (char*)0;
1504   long v;
1505   if (SWIG_AsVal_long(obj, &v)) {
1506     if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1507       if (val) *val = (int)(v);
1508       return 1;
1509     } else {
1510       return 0;
1511     }
1512   } else {
1513     PyErr_Clear();
1514   }
1515   if (val) {
1516     SWIG_type_error(errmsg, obj);
1517   }
1518   return 0;
1519 }
1520 #else
1521 SWIGINTERNSHORT int
1522   SWIG_AsVal_int(PyObject *obj, int *val)
1523 {
1524   return SWIG_AsVal_long(obj,(long*)val);
1525 }
1526 #endif
1527
1528
1529 SWIGINTERNSHORT int
1530 SWIG_As_int(PyObject* obj)
1531 {
1532   int v;
1533   if (!SWIG_AsVal_int(obj, &v)) {
1534     /*
1535       this is needed to make valgrind/purify happier.
1536      */
1537     memset((void*)&v, 0, sizeof(int));
1538   }
1539   return v;
1540 }
1541
1542
1543 SWIGINTERNSHORT long
1544 SWIG_As_long(PyObject* obj)
1545 {
1546   long v;
1547   if (!SWIG_AsVal_long(obj, &v)) {
1548     /*
1549       this is needed to make valgrind/purify happier.
1550      */
1551     memset((void*)&v, 0, sizeof(long));
1552   }
1553   return v;
1554 }
1555
1556
1557 SWIGINTERNSHORT int
1558 SWIG_Check_int(PyObject* obj)
1559 {
1560   return SWIG_AsVal_int(obj, (int*)0);
1561 }
1562
1563
1564 SWIGINTERNSHORT int
1565 SWIG_Check_long(PyObject* obj)
1566 {
1567   return SWIG_AsVal_long(obj, (long*)0);
1568 }
1569
1570
1571 SWIGINTERN int
1572   SWIG_AsVal_bool(PyObject *obj, bool *val)
1573 {
1574   if (obj == Py_True) {
1575     if (val) *val = true;
1576     return 1;
1577   }
1578   if (obj == Py_False) {
1579     if (val) *val = false;
1580     return 1;
1581   }
1582   int res = 0;
1583   if (SWIG_AsVal_int(obj, &res)) {
1584     if (val) *val = res ? true : false;
1585     return 1;
1586   } else {
1587     PyErr_Clear();
1588   }
1589   if (val) {
1590     SWIG_type_error("bool", obj);
1591   }
1592   return 0;
1593 }
1594
1595
1596 SWIGINTERNSHORT bool
1597 SWIG_As_bool(PyObject* obj)
1598 {
1599   bool v;
1600   if (!SWIG_AsVal_bool(obj, &v)) {
1601     /*
1602       this is needed to make valgrind/purify happier.
1603      */
1604     memset((void*)&v, 0, sizeof(bool));
1605   }
1606   return v;
1607 }
1608
1609
1610 SWIGINTERNSHORT int
1611 SWIG_Check_bool(PyObject* obj)
1612 {
1613   return SWIG_AsVal_bool(obj, (bool*)0);
1614 }
1615
1616
1617   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1618 #define SWIG_From_int PyInt_FromLong
1619 /*@@*/
1620
1621
1622   static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1623     PyObject*   o2;
1624     PyObject*   o3;
1625
1626     if (!target) {
1627         target = o;
1628     } else if (target == Py_None) {
1629         Py_DECREF(Py_None);
1630         target = o;
1631     } else {
1632         if (!PyTuple_Check(target)) {
1633             o2 = target;
1634             target = PyTuple_New(1);
1635             PyTuple_SetItem(target, 0, o2);
1636         }
1637         o3 = PyTuple_New(1);
1638         PyTuple_SetItem(o3, 0, o);
1639
1640         o2 = target;
1641         target = PySequence_Concat(o2, o3);
1642         Py_DECREF(o2);
1643         Py_DECREF(o3);
1644     }
1645     return target;
1646   }
1647
1648
1649
1650 SWIGINTERN int
1651 SWIG_AsVal_double(PyObject *obj, double* val)
1652 {
1653     if (PyNumber_Check(obj)) {
1654         if (val) *val = PyFloat_AsDouble(obj);
1655         return 1;
1656     }
1657     else {
1658         SWIG_type_error("number", obj);
1659     }
1660     return 0;
1661 }
1662
1663
1664 SWIGINTERNSHORT double
1665 SWIG_As_double(PyObject* obj)
1666 {
1667   double v;
1668   if (!SWIG_AsVal_double(obj, &v)) {
1669     /*
1670       this is needed to make valgrind/purify happier.
1671      */
1672     memset((void*)&v, 0, sizeof(double));
1673   }
1674   return v;
1675 }
1676
1677
1678 SWIGINTERNSHORT int
1679 SWIG_Check_double(PyObject* obj)
1680 {
1681   return SWIG_AsVal_double(obj, (double*)0);
1682 }
1683
1684
1685   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1686 #define SWIG_From_double PyFloat_FromDouble
1687 /*@@*/
1688
1689  static const wxString wxPyFrameNameStr(wxFrameNameStr);
1690  static const wxString wxPyDialogNameStr(wxDialogNameStr);
1691  static const wxString wxPyStatusLineNameStr(wxStatusLineNameStr);
1692  static const wxString wxPyToolBarNameStr(wxToolBarNameStr);
1693 static void wxTopLevelWindow_MacSetMetalAppearance(wxTopLevelWindow *self,bool on){ /*wxPyRaiseNotImplemented();*/ }
1694 static bool wxTopLevelWindow_MacGetMetalAppearance(wxTopLevelWindow const *self){ /*wxPyRaiseNotImplemented();*/ return false; }
1695
1696   /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1697 #define SWIG_From_long PyInt_FromLong
1698 /*@@*/
1699
1700
1701
1702 static wxRect wxStatusBar_GetFieldRect(wxStatusBar *self,int i){
1703             wxRect r;
1704             self->GetFieldRect(i, r);
1705             return r;
1706         }
1707  static const wxString wxPySplitterNameStr(wxT("splitter"));
1708  static const wxString wxPySashNameStr(wxT("sashWindow"));
1709  static const wxString wxPySashLayoutNameStr(wxT("layoutWindow"));
1710
1711 #include <wx/popupwin.h>
1712
1713
1714 class wxPyPopupTransientWindow : public wxPopupTransientWindow
1715 {
1716 public:
1717     wxPyPopupTransientWindow() : wxPopupTransientWindow() {}
1718     wxPyPopupTransientWindow(wxWindow* parent, int style = wxBORDER_NONE)
1719         : wxPopupTransientWindow(parent, style) {}
1720
1721     DEC_PYCALLBACK_BOOL_ME(ProcessLeftDown);
1722     DEC_PYCALLBACK__(OnDismiss);
1723     DEC_PYCALLBACK_BOOL_(CanDismiss);
1724     PYPRIVATE;
1725 };
1726
1727
1728 IMP_PYCALLBACK_BOOL_ME(wxPyPopupTransientWindow, wxPopupTransientWindow, ProcessLeftDown);
1729 IMP_PYCALLBACK__(wxPyPopupTransientWindow, wxPopupTransientWindow, OnDismiss);
1730 IMP_PYCALLBACK_BOOL_(wxPyPopupTransientWindow, wxPopupTransientWindow, CanDismiss);
1731
1732
1733 #include <wx/tipwin.h>
1734
1735 static wxTipWindow *new_wxTipWindow(wxWindow *parent,wxString const &text,int maxLength=100,wxRect *rectBound=NULL){
1736             return new wxTipWindow(parent, text, maxLength, NULL, rectBound);
1737         }
1738
1739 #include <wx/tipwin.h>
1740
1741
1742 #include <wx/vscroll.h>
1743
1744
1745 class wxPyVScrolledWindow  : public wxVScrolledWindow
1746 {
1747     DECLARE_ABSTRACT_CLASS(wxPyVScrolledWindow);
1748 public:
1749     wxPyVScrolledWindow() : wxVScrolledWindow() {}
1750
1751     wxPyVScrolledWindow(wxWindow *parent,
1752                         wxWindowID id = wxID_ANY,
1753                         const wxPoint& pos = wxDefaultPosition,
1754                         const wxSize& size = wxDefaultSize,
1755                         long style = 0,
1756                         const wxString& name = wxPyPanelNameStr)
1757         : wxVScrolledWindow(parent, id, pos, size, style, name)
1758     {}
1759
1760     // Overridable virtuals
1761
1762     // this function must be overridden in the derived class and it should
1763     // return the height of the given line in pixels
1764     DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetLineHeight);
1765
1766
1767     // this function doesn't have to be overridden but it may be useful to do
1768     // it if calculating the lines heights is a relatively expensive operation
1769     // as it gives the user code a possibility to calculate several of them at
1770     // once
1771     //
1772     // OnGetLinesHint() is normally called just before OnGetLineHeight() but you
1773     // shouldn't rely on the latter being called for all lines in the interval
1774     // specified here. It is also possible that OnGetLineHeight() will be
1775     // called for the lines outside of this interval, so this is really just a
1776     // hint, not a promise.
1777     //
1778     // finally note that lineMin is inclusive, while lineMax is exclusive, as
1779     // usual
1780     DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetLinesHint);
1781
1782
1783     // when the number of lines changes, we try to estimate the total height
1784     // of all lines which is a rather expensive operation in terms of lines
1785     // access, so if the user code may estimate the average height
1786     // better/faster than we do, it should override this function to implement
1787     // its own logic
1788     //
1789     // this function should return the best guess for the total height it may
1790     // make
1791     DEC_PYCALLBACK_COORD_const(EstimateTotalHeight);
1792
1793
1794     // Also expose some other interesting protected methods
1795
1796
1797     // find the index of the line we need to show at the top of the window such
1798     // that the last (fully or partially) visible line is the given one
1799     size_t FindFirstFromBottom(size_t lineLast, bool fullyVisible = false)
1800     { return wxVScrolledWindow::FindFirstFromBottom(lineLast, fullyVisible); }
1801
1802     // get the total height of the lines between lineMin (inclusive) and
1803     // lineMax (exclusive)
1804     wxCoord GetLinesHeight(size_t lineMin, size_t lineMax) const
1805     { return wxVScrolledWindow::GetLinesHeight(lineMin, lineMax); }
1806
1807
1808     PYPRIVATE;
1809 };
1810
1811 IMPLEMENT_ABSTRACT_CLASS(wxPyVScrolledWindow, wxVScrolledWindow);
1812
1813 IMP_PYCALLBACK_COORD_SIZET_constpure(wxPyVScrolledWindow, wxVScrolledWindow, OnGetLineHeight);
1814 IMP_PYCALLBACK_VOID_SIZETSIZET_const(wxPyVScrolledWindow, wxVScrolledWindow, OnGetLinesHint);
1815 IMP_PYCALLBACK_COORD_const          (wxPyVScrolledWindow, wxVScrolledWindow, EstimateTotalHeight);
1816
1817
1818 SWIGINTERN int
1819 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1820 {
1821     long v = 0;
1822     if (SWIG_AsVal_long(obj, &v) && v < 0) {
1823         SWIG_type_error("unsigned number", obj);
1824     }
1825     else if (val)
1826         *val = (unsigned long)v;
1827     return 1;
1828 }
1829
1830
1831 SWIGINTERNSHORT unsigned long
1832 SWIG_As_unsigned_SS_long(PyObject* obj)
1833 {
1834   unsigned long v;
1835   if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1836     /*
1837       this is needed to make valgrind/purify happier.
1838      */
1839     memset((void*)&v, 0, sizeof(unsigned long));
1840   }
1841   return v;
1842 }
1843
1844
1845 SWIGINTERNSHORT int
1846 SWIG_Check_unsigned_SS_long(PyObject* obj)
1847 {
1848   return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1849 }
1850
1851
1852 SWIGINTERNSHORT PyObject*
1853   SWIG_From_unsigned_SS_long(unsigned long value)
1854 {
1855   return (value > LONG_MAX) ?
1856     PyLong_FromUnsignedLong(value)
1857     : PyInt_FromLong((long)(value));
1858 }
1859
1860
1861 #include <wx/vlbox.h>
1862
1863  static const wxString wxPyVListBoxNameStr(wxVListBoxNameStr);
1864
1865 class wxPyVListBox  : public wxVListBox
1866 {
1867     DECLARE_ABSTRACT_CLASS(wxPyVListBox);
1868 public:
1869     wxPyVListBox() : wxVListBox() {}
1870
1871     wxPyVListBox(wxWindow *parent,
1872                  wxWindowID id = wxID_ANY,
1873                  const wxPoint& pos = wxDefaultPosition,
1874                  const wxSize& size = wxDefaultSize,
1875                  long style = 0,
1876                  const wxString& name = wxPyVListBoxNameStr)
1877         : wxVListBox(parent, id, pos, size, style, name)
1878     {}
1879
1880     // Overridable virtuals
1881
1882     // the derived class must implement this function to actually draw the item
1883     // with the given index on the provided DC
1884     // virtual void OnDrawItem(wxDC& dc, const wxRect& rect, size_t n) const = 0;
1885     DEC_PYCALLBACK__DCRECTSIZET_constpure(OnDrawItem);
1886
1887
1888     // the derived class must implement this method to return the height of the
1889     // specified item
1890     // virtual wxCoord OnMeasureItem(size_t n) const = 0;
1891     DEC_PYCALLBACK_COORD_SIZET_constpure(OnMeasureItem);
1892
1893
1894     // this method may be used to draw separators between the lines; note that
1895     // the rectangle may be modified, typically to deflate it a bit before
1896     // passing to OnDrawItem()
1897     //
1898     // the base class version doesn't do anything
1899     //    virtual void OnDrawSeparator(wxDC& dc, wxRect& rect, size_t n) const;
1900     DEC_PYCALLBACK__DCRECTSIZET_constpure(OnDrawSeparator);
1901
1902
1903     // this method is used to draw the items background and, maybe, a border
1904     // around it
1905     //
1906     // the base class version implements a reasonable default behaviour which
1907     // consists in drawing the selected item with the standard background
1908     // colour and drawing a border around the item if it is either selected or
1909     // current
1910     //     virtual void OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const;
1911     DEC_PYCALLBACK__DCRECTSIZET_const(OnDrawBackground);
1912
1913
1914     PYPRIVATE;
1915 };
1916
1917 IMPLEMENT_ABSTRACT_CLASS(wxPyVListBox, wxVListBox);
1918
1919 IMP_PYCALLBACK__DCRECTSIZET_constpure(wxPyVListBox, wxVListBox, OnDrawItem);
1920 IMP_PYCALLBACK_COORD_SIZET_constpure (wxPyVListBox, wxVListBox, OnMeasureItem);
1921 IMP_PYCALLBACK__DCRECTSIZET_constpure(wxPyVListBox, wxVListBox, OnDrawSeparator);
1922 IMP_PYCALLBACK__DCRECTSIZET_const    (wxPyVListBox, wxVListBox, OnDrawBackground);
1923
1924
1925 static PyObject *wxPyVListBox_GetFirstSelected(wxPyVListBox *self){
1926             unsigned long cookie = 0;
1927             int selected = self->GetFirstSelected(cookie);
1928             wxPyBlock_t blocked = wxPyBeginBlockThreads();
1929             PyObject* tup = PyTuple_New(2);
1930             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(selected));
1931             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(cookie));
1932             wxPyEndBlockThreads(blocked);
1933             return tup;
1934         }
1935 static PyObject *wxPyVListBox_GetNextSelected(wxPyVListBox *self,unsigned long cookie){
1936             int selected = self->GetNextSelected(cookie);
1937             wxPyBlock_t blocked = wxPyBeginBlockThreads();
1938             PyObject* tup = PyTuple_New(2);
1939             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(selected));
1940             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(cookie));
1941             wxPyEndBlockThreads(blocked);
1942             return tup;
1943         }
1944
1945 #include <wx/htmllbox.h>
1946
1947
1948 class wxPyHtmlListBox  : public wxHtmlListBox
1949 {
1950     DECLARE_ABSTRACT_CLASS(wxPyHtmlListBox);
1951 public:
1952     wxPyHtmlListBox() : wxHtmlListBox() {}
1953
1954     wxPyHtmlListBox(wxWindow *parent,
1955                     wxWindowID id = wxID_ANY,
1956                     const wxPoint& pos = wxDefaultPosition,
1957                     const wxSize& size = wxDefaultSize,
1958                     long style = 0,
1959                     const wxString& name = wxPyVListBoxNameStr)
1960         : wxHtmlListBox(parent, id, pos, size, style, name)
1961     {}
1962
1963     // Overridable virtuals
1964
1965     // this method must be implemented in the derived class and should return
1966     // the body (i.e. without <html>) of the HTML for the given item
1967     DEC_PYCALLBACK_STRING_SIZET_pure(OnGetItem);
1968
1969     // this function may be overridden to decorate HTML returned by OnGetItem()
1970     DEC_PYCALLBACK_STRING_SIZET(OnGetItemMarkup);
1971
1972 // TODO:
1973 //     // this method allows to customize the selection appearance: it may be used
1974 //     // to specify the colour of the text which normally has the given colour
1975 //     // colFg when it is inside the selection
1976 //     //
1977 //     // by default, the original colour is not used at all and all text has the
1978 //     // same (default for this system) colour inside selection
1979 //     virtual wxColour GetSelectedTextColour(const wxColour& colFg) const;
1980
1981 //     // this is the same as GetSelectedTextColour() but allows to customize the
1982 //     // background colour -- this is even more rarely used as you can change it
1983 //     // globally using SetSelectionBackground()
1984 //     virtual wxColour GetSelectedTextBgColour(const wxColour& colBg) const;
1985
1986
1987     PYPRIVATE;
1988 };
1989
1990
1991 IMPLEMENT_ABSTRACT_CLASS(wxPyHtmlListBox, wxHtmlListBox)
1992
1993 IMP_PYCALLBACK_STRING_SIZET_pure(wxPyHtmlListBox, wxHtmlListBox, OnGetItem);
1994 IMP_PYCALLBACK_STRING_SIZET     (wxPyHtmlListBox, wxHtmlListBox, OnGetItemMarkup);
1995
1996
1997
1998
1999
2000 #ifndef wxHAS_TASK_BAR_ICON
2001 // implement dummy classes for platforms that don't have it
2002
2003 class wxTaskBarIcon : public wxEvtHandler
2004 {
2005 public:
2006     wxTaskBarIcon()  { wxPyRaiseNotImplemented(); }
2007 };
2008
2009
2010 class wxTaskBarIconEvent : public wxEvent
2011 {
2012 public:
2013     wxTaskBarIconEvent(wxEventType, wxTaskBarIcon *)
2014         { wxPyRaiseNotImplemented(); }
2015     virtual wxEvent* Clone() const { return NULL; }
2016     bool IsOk() const { return false; }
2017     bool IsIconInstalled() const { return false; }
2018     bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxPyEmptyString) { return false; }
2019     bool RemoveIcon() { return false; }
2020     bool PopupMenu(wxMenu *menu) { return false; }
2021 };
2022
2023 enum {
2024     wxEVT_TASKBAR_MOVE = 0,
2025     wxEVT_TASKBAR_LEFT_DOWN = 0,
2026     wxEVT_TASKBAR_LEFT_UP = 0,
2027     wxEVT_TASKBAR_RIGHT_DOWN = 0,
2028     wxEVT_TASKBAR_RIGHT_UP = 0,
2029     wxEVT_TASKBAR_LEFT_DCLICK = 0,
2030     wxEVT_TASKBAR_RIGHT_DCLICK = 0,
2031 };
2032
2033
2034 #else
2035 // Otherwise make a class that can virtualize CreatePopupMenu
2036 class wxPyTaskBarIcon : public wxTaskBarIcon
2037 {
2038     DECLARE_ABSTRACT_CLASS(wxPyTaskBarIcon);
2039 public:
2040     wxPyTaskBarIcon() : wxTaskBarIcon()
2041     {}
2042
2043     wxMenu* CreatePopupMenu() {
2044         wxMenu *rval = NULL;
2045         bool found;
2046         wxPyBlock_t blocked = wxPyBeginBlockThreads();
2047         if ((found = wxPyCBH_findCallback(m_myInst, "CreatePopupMenu"))) {
2048             PyObject* ro;
2049             wxMenu* ptr;
2050             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2051             if (ro) {
2052                 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxMenu")))
2053                     rval = ptr;
2054                 Py_DECREF(ro);
2055             }
2056         }
2057         wxPyEndBlockThreads(blocked);
2058         if (! found)
2059             rval = wxTaskBarIcon::CreatePopupMenu();
2060         return rval;
2061     }
2062
2063     PYPRIVATE;
2064 };
2065
2066 IMPLEMENT_ABSTRACT_CLASS(wxPyTaskBarIcon, wxTaskBarIcon);
2067
2068 #endif
2069
2070 static void wxPyTaskBarIcon_Destroy(wxPyTaskBarIcon *self){
2071             self->RemoveIcon();
2072             delete self;
2073         }
2074  static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2075  static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2076  static const wxString wxPyDirDialogNameStr(wxDirDialogNameStr);
2077  static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2078  static const wxString wxPyGetTextFromUserPromptStr(wxGetTextFromUserPromptStr);
2079  static const wxString wxPyMessageBoxCaptionStr(wxMessageBoxCaptionStr);
2080 static PyObject *wxFileDialog_GetFilenames(wxFileDialog *self){
2081             wxArrayString arr;
2082             self->GetFilenames(arr);
2083             return wxArrayString2PyList_helper(arr);
2084         }
2085 static PyObject *wxFileDialog_GetPaths(wxFileDialog *self){
2086             wxArrayString arr;
2087             self->GetPaths(arr);
2088             return wxArrayString2PyList_helper(arr);
2089         }
2090 static PyObject *wxMultiChoiceDialog_GetSelections(wxMultiChoiceDialog *self){
2091             return wxArrayInt2PyList_helper(self->GetSelections());
2092         }
2093 static wxSingleChoiceDialog *new_wxSingleChoiceDialog(wxWindow *parent,wxString const &message,wxString const &caption,int choices,wxString *choices_array,long style=wxCHOICEDLG_STYLE,wxPoint const &pos=wxDefaultPosition){
2094             return new wxSingleChoiceDialog(parent, message, caption,
2095                                             choices, choices_array, NULL, style, pos);
2096         }
2097  static const wxString wxPyGetPasswordFromUserPromptStr(wxGetPasswordFromUserPromptStr);
2098
2099 #include <wx/mdi.h>
2100
2101  // C++ version of Python aware wxWindow
2102 class wxPyWindow : public wxWindow
2103 {
2104     DECLARE_DYNAMIC_CLASS(wxPyWindow)
2105 public:
2106     wxPyWindow() : wxWindow() {}
2107     wxPyWindow(wxWindow* parent, const wxWindowID id,
2108                const wxPoint& pos = wxDefaultPosition,
2109                const wxSize& size = wxDefaultSize,
2110                long style = 0,
2111                const wxString& name = wxPyPanelNameStr)
2112         : wxWindow(parent, id, pos, size, style, name) {}
2113
2114     void SetBestSize(const wxSize& size) { wxWindow::SetBestSize(size); }
2115
2116     DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
2117     DEC_PYCALLBACK_VOID_INT5(DoSetSize);
2118     DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
2119     DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
2120
2121     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
2122     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
2123     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
2124
2125     DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
2126     DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
2127
2128     DEC_PYCALLBACK__(InitDialog);
2129     DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
2130     DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
2131     DEC_PYCALLBACK_BOOL_(Validate);
2132
2133     DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
2134     DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
2135     DEC_PYCALLBACK_SIZE_const(GetMaxSize);
2136
2137     DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
2138     DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
2139
2140     DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
2141     DEC_PYCALLBACK__COLOUR(ApplyParentThemeBackground);
2142     DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
2143
2144     DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
2145
2146     PYPRIVATE;
2147 };
2148
2149 IMPLEMENT_DYNAMIC_CLASS(wxPyWindow, wxWindow);
2150
2151 IMP_PYCALLBACK_VOID_INT4(wxPyWindow, wxWindow, DoMoveWindow);
2152 IMP_PYCALLBACK_VOID_INT5(wxPyWindow, wxWindow, DoSetSize);
2153 IMP_PYCALLBACK_VOID_INTINT(wxPyWindow, wxWindow, DoSetClientSize);
2154 IMP_PYCALLBACK_VOID_INTINT(wxPyWindow, wxWindow, DoSetVirtualSize);
2155
2156 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetSize);
2157 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetClientSize);
2158 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetPosition);
2159
2160 IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetVirtualSize);
2161 IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetBestSize);
2162
2163 IMP_PYCALLBACK__(wxPyWindow, wxWindow, InitDialog);
2164 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, TransferDataFromWindow);
2165 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, TransferDataToWindow);
2166 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, Validate);
2167
2168 IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, AcceptsFocus);
2169 IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, AcceptsFocusFromKeyboard);
2170 IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, GetMaxSize);
2171
2172 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWindow, wxWindow, AddChild);
2173 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWindow, wxWindow, RemoveChild);
2174
2175 IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, ShouldInheritColours);
2176 IMP_PYCALLBACK__COLOUR(wxPyWindow, wxWindow, ApplyParentThemeBackground);
2177 IMP_PYCALLBACK_VIZATTR_(wxPyWindow, wxWindow, GetDefaultAttributes);
2178
2179 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, HasTransparentBackground);
2180
2181  // C++ version of Python aware wxPanel
2182 class wxPyPanel : public wxPanel
2183 {
2184     DECLARE_DYNAMIC_CLASS(wxPyPanel)
2185 public:
2186     wxPyPanel() : wxPanel() {}
2187     wxPyPanel(wxWindow* parent, const wxWindowID id,
2188                const wxPoint& pos = wxDefaultPosition,
2189                const wxSize& size = wxDefaultSize,
2190                long style = 0,
2191                const wxString& name = wxPyPanelNameStr)
2192         : wxPanel(parent, id, pos, size, style, name) {}
2193
2194     void SetBestSize(const wxSize& size) { wxPanel::SetBestSize(size); }
2195
2196
2197     DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
2198     DEC_PYCALLBACK_VOID_INT5(DoSetSize);
2199     DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
2200     DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
2201
2202     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
2203     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
2204     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
2205
2206     DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
2207     DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
2208
2209     DEC_PYCALLBACK__(InitDialog);
2210     DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
2211     DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
2212     DEC_PYCALLBACK_BOOL_(Validate);
2213
2214     DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
2215     DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
2216     DEC_PYCALLBACK_SIZE_const(GetMaxSize);
2217
2218     DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
2219     DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
2220
2221     DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
2222     DEC_PYCALLBACK__COLOUR(ApplyParentThemeBackground);
2223     DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
2224
2225     DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
2226
2227     PYPRIVATE;
2228 };
2229
2230 IMPLEMENT_DYNAMIC_CLASS(wxPyPanel, wxPanel);
2231
2232 IMP_PYCALLBACK_VOID_INT4(wxPyPanel, wxPanel, DoMoveWindow);
2233 IMP_PYCALLBACK_VOID_INT5(wxPyPanel, wxPanel, DoSetSize);
2234 IMP_PYCALLBACK_VOID_INTINT(wxPyPanel, wxPanel, DoSetClientSize);
2235 IMP_PYCALLBACK_VOID_INTINT(wxPyPanel, wxPanel, DoSetVirtualSize);
2236
2237 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyPanel, wxPanel, DoGetSize);
2238 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyPanel, wxPanel, DoGetClientSize);
2239 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyPanel, wxPanel, DoGetPosition);
2240
2241 IMP_PYCALLBACK_SIZE_const(wxPyPanel, wxPanel, DoGetVirtualSize);
2242 IMP_PYCALLBACK_SIZE_const(wxPyPanel, wxPanel, DoGetBestSize);
2243
2244 IMP_PYCALLBACK__(wxPyPanel, wxPanel, InitDialog);
2245 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, TransferDataFromWindow);
2246 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, TransferDataToWindow);
2247 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, Validate);
2248
2249 IMP_PYCALLBACK_BOOL_const(wxPyPanel, wxPanel, AcceptsFocus);
2250 IMP_PYCALLBACK_BOOL_const(wxPyPanel, wxPanel, AcceptsFocusFromKeyboard);
2251 IMP_PYCALLBACK_SIZE_const(wxPyPanel, wxPanel, GetMaxSize);
2252
2253 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyPanel, wxPanel, AddChild);
2254 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyPanel, wxPanel, RemoveChild);
2255
2256 IMP_PYCALLBACK_BOOL_const(wxPyPanel, wxPanel, ShouldInheritColours);
2257 IMP_PYCALLBACK__COLOUR(wxPyPanel, wxPanel, ApplyParentThemeBackground);
2258 IMP_PYCALLBACK_VIZATTR_(wxPyPanel, wxPanel, GetDefaultAttributes);
2259
2260 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, HasTransparentBackground);
2261
2262  // C++ version of Python aware wxScrolledWindow
2263 class wxPyScrolledWindow : public wxScrolledWindow
2264 {
2265     DECLARE_DYNAMIC_CLASS(wxPyScrolledWindow)
2266 public:
2267     wxPyScrolledWindow() : wxScrolledWindow() {}
2268     wxPyScrolledWindow(wxWindow* parent, const wxWindowID id,
2269                const wxPoint& pos = wxDefaultPosition,
2270                const wxSize& size = wxDefaultSize,
2271                long style = 0,
2272                const wxString& name = wxPyPanelNameStr)
2273         : wxScrolledWindow(parent, id, pos, size, style, name) {}
2274
2275     void SetBestSize(const wxSize& size) { wxScrolledWindow::SetBestSize(size); }
2276
2277     DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
2278     DEC_PYCALLBACK_VOID_INT5(DoSetSize);
2279     DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
2280     DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
2281
2282     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
2283     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
2284     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
2285
2286     DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
2287     DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
2288
2289     DEC_PYCALLBACK__(InitDialog);
2290     DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
2291     DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
2292     DEC_PYCALLBACK_BOOL_(Validate);
2293
2294     DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
2295     DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
2296     DEC_PYCALLBACK_SIZE_const(GetMaxSize);
2297
2298     DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
2299     DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
2300
2301     DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
2302     DEC_PYCALLBACK__COLOUR(ApplyParentThemeBackground);
2303     DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
2304
2305     DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
2306
2307     PYPRIVATE;
2308 };
2309
2310 IMPLEMENT_DYNAMIC_CLASS(wxPyScrolledWindow, wxScrolledWindow);
2311
2312 IMP_PYCALLBACK_VOID_INT4(wxPyScrolledWindow, wxScrolledWindow, DoMoveWindow);
2313 IMP_PYCALLBACK_VOID_INT5(wxPyScrolledWindow, wxScrolledWindow, DoSetSize);
2314 IMP_PYCALLBACK_VOID_INTINT(wxPyScrolledWindow, wxScrolledWindow, DoSetClientSize);
2315 IMP_PYCALLBACK_VOID_INTINT(wxPyScrolledWindow, wxScrolledWindow, DoSetVirtualSize);
2316
2317 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyScrolledWindow, wxScrolledWindow, DoGetSize);
2318 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyScrolledWindow, wxScrolledWindow, DoGetClientSize);
2319 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyScrolledWindow, wxScrolledWindow, DoGetPosition);
2320
2321 IMP_PYCALLBACK_SIZE_const(wxPyScrolledWindow, wxScrolledWindow, DoGetVirtualSize);
2322 IMP_PYCALLBACK_SIZE_const(wxPyScrolledWindow, wxScrolledWindow, DoGetBestSize);
2323
2324 IMP_PYCALLBACK__(wxPyScrolledWindow, wxScrolledWindow, InitDialog);
2325 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, TransferDataFromWindow);
2326 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, TransferDataToWindow);
2327 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, Validate);
2328
2329 IMP_PYCALLBACK_BOOL_const(wxPyScrolledWindow, wxScrolledWindow, AcceptsFocus);
2330 IMP_PYCALLBACK_BOOL_const(wxPyScrolledWindow, wxScrolledWindow, AcceptsFocusFromKeyboard);
2331 IMP_PYCALLBACK_SIZE_const(wxPyScrolledWindow, wxScrolledWindow, GetMaxSize);
2332
2333 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyScrolledWindow, wxScrolledWindow, AddChild);
2334 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyScrolledWindow, wxScrolledWindow, RemoveChild);
2335
2336 IMP_PYCALLBACK_BOOL_const(wxPyScrolledWindow, wxScrolledWindow, ShouldInheritColours);
2337 IMP_PYCALLBACK__COLOUR(wxPyScrolledWindow, wxScrolledWindow, ApplyParentThemeBackground);
2338 IMP_PYCALLBACK_VIZATTR_(wxPyScrolledWindow, wxScrolledWindow, GetDefaultAttributes);
2339
2340 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, HasTransparentBackground);
2341
2342
2343 #include "wx/wxPython/printfw.h"
2344
2345
2346  static const wxString wxPyPrintoutTitleStr(wxT("Printout"));
2347  static const wxString wxPyPreviewCanvasNameStr(wxT("previewcanvas"));
2348 static PyObject *wxPrintData_GetPrivData(wxPrintData *self){
2349             PyObject* data;
2350             wxPyBlock_t blocked = wxPyBeginBlockThreads();
2351             data = PyString_FromStringAndSize(self->GetPrivData(),
2352                                               self->GetPrivDataLen());
2353             wxPyEndBlockThreads(blocked);
2354             return data;
2355         }
2356 static void wxPrintData_SetPrivData(wxPrintData *self,PyObject *data){
2357             if (! PyString_Check(data)) {
2358                 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2359                                                   "Expected string object"));
2360                 return /* NULL */ ;
2361             }
2362
2363             wxPyBlock_t blocked = wxPyBeginBlockThreads();
2364             self->SetPrivData(PyString_AS_STRING(data), PyString_GET_SIZE(data));
2365             wxPyEndBlockThreads(blocked);
2366         }
2367
2368
2369 IMPLEMENT_ABSTRACT_CLASS(wxPyPrintout, wxPrintout);
2370
2371 // Since this one would be tough and ugly to do with the Macros...
2372 void wxPyPrintout::GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo) {
2373     bool hadErr = false;
2374     bool found;
2375
2376     wxPyBlock_t blocked = wxPyBeginBlockThreads();
2377     if ((found = wxPyCBH_findCallback(m_myInst, "GetPageInfo"))) {
2378         PyObject* result = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2379         if (result && PyTuple_Check(result) && PyTuple_Size(result) == 4) {
2380             PyObject* val;
2381
2382             val = PyTuple_GetItem(result, 0);
2383             if (PyInt_Check(val))    *minPage = PyInt_AsLong(val);
2384             else hadErr = true;
2385
2386             val = PyTuple_GetItem(result, 1);
2387             if (PyInt_Check(val))    *maxPage = PyInt_AsLong(val);
2388             else hadErr = true;
2389
2390             val = PyTuple_GetItem(result, 2);
2391             if (PyInt_Check(val))    *pageFrom = PyInt_AsLong(val);
2392             else hadErr = true;
2393
2394             val = PyTuple_GetItem(result, 3);
2395             if (PyInt_Check(val))    *pageTo = PyInt_AsLong(val);
2396             else hadErr = true;
2397         }
2398         else
2399             hadErr = true;
2400
2401         if (hadErr) {
2402             PyErr_SetString(PyExc_TypeError, "GetPageInfo should return a tuple of 4 integers.");
2403             PyErr_Print();
2404         }
2405         Py_DECREF(result);
2406     }
2407     wxPyEndBlockThreads(blocked);
2408     if (! found)
2409         wxPrintout::GetPageInfo(minPage, maxPage, pageFrom, pageTo);
2410 }
2411
2412 void wxPyPrintout::base_GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo) {
2413     wxPrintout::GetPageInfo(minPage, maxPage, pageFrom, pageTo);
2414 }
2415
2416
2417 IMP_PYCALLBACK_BOOL_INTINT(wxPyPrintout, wxPrintout, OnBeginDocument);
2418 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnEndDocument);
2419 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnBeginPrinting);
2420 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnEndPrinting);
2421 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnPreparePrinting);
2422 IMP_PYCALLBACK_BOOL_INT_pure(wxPyPrintout, wxPrintout, OnPrintPage);
2423 IMP_PYCALLBACK_BOOL_INT(wxPyPrintout, wxPrintout, HasPage);
2424
2425
2426
2427
2428
2429 #define DEC_PYCALLBACK_BOOL_PREWINDC(CBNAME)                                            \
2430     bool CBNAME(wxPreviewCanvas* a, wxDC& b);                                           \
2431     bool base_##CBNAME(wxPreviewCanvas* a, wxDC& b)
2432
2433
2434 #define IMP_PYCALLBACK_BOOL_PREWINDC(CLASS, PCLASS, CBNAME)                             \
2435     bool CLASS::CBNAME(wxPreviewCanvas* a, wxDC& b) {                                   \
2436         bool rval=false;                                                                \
2437         bool found;                                                                     \
2438         wxPyBlock_t blocked = wxPyBeginBlockThreads();                                         \
2439         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
2440             PyObject* win = wxPyMake_wxObject(a,false);                                 \
2441             PyObject* dc  = wxPyMake_wxObject(&b,false);                                \
2442             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", win, dc));      \
2443             Py_DECREF(win);                                                             \
2444             Py_DECREF(dc);                                                              \
2445         }                                                                               \
2446         wxPyEndBlockThreads(blocked);                                                   \
2447         if (! found)                                                                    \
2448             rval = PCLASS::CBNAME(a, b);                                                \
2449         return rval;                                                                    \
2450     }                                                                                   \
2451     bool CLASS::base_##CBNAME(wxPreviewCanvas* a, wxDC& b) {                            \
2452         return PCLASS::CBNAME(a, b);                                                    \
2453     }
2454
2455
2456
2457
2458 class wxPyPrintPreview : public wxPrintPreview
2459 {
2460     DECLARE_CLASS(wxPyPrintPreview)
2461 public:
2462     wxPyPrintPreview(wxPyPrintout* printout,
2463                      wxPyPrintout* printoutForPrinting,
2464                      wxPrintDialogData* data=NULL)
2465         : wxPrintPreview(printout, printoutForPrinting, data)
2466     {}
2467     wxPyPrintPreview(wxPyPrintout* printout,
2468                      wxPyPrintout* printoutForPrinting,
2469                      wxPrintData* data=NULL)
2470         : wxPrintPreview(printout, printoutForPrinting, data)
2471     {}
2472
2473     DEC_PYCALLBACK_BOOL_INT(SetCurrentPage);
2474     DEC_PYCALLBACK_BOOL_PREWINDC(PaintPage);
2475     DEC_PYCALLBACK_BOOL_PREWINDC(DrawBlankPage);
2476     DEC_PYCALLBACK_BOOL_INT(RenderPage);
2477     DEC_PYCALLBACK_VOID_INT(SetZoom);
2478     DEC_PYCALLBACK_BOOL_BOOL(Print);
2479     DEC_PYCALLBACK_VOID_(DetermineScaling);
2480
2481     PYPRIVATE;
2482 };
2483
2484 // Stupid renamed classes...  Fix this in 2.5...
2485 #if defined(__WXMSW__)
2486 IMPLEMENT_CLASS( wxPyPrintPreview, wxWindowsPrintPreview );
2487 #elif defined(__WXMAC__)
2488 IMPLEMENT_CLASS( wxPyPrintPreview, wxMacPrintPreview );
2489 #else
2490 IMPLEMENT_CLASS( wxPyPrintPreview, wxPostScriptPrintPreview );
2491 #endif
2492
2493 IMP_PYCALLBACK_BOOL_INT     (wxPyPrintPreview, wxPrintPreview, SetCurrentPage);
2494 IMP_PYCALLBACK_BOOL_PREWINDC(wxPyPrintPreview, wxPrintPreview, PaintPage);
2495 IMP_PYCALLBACK_BOOL_PREWINDC(wxPyPrintPreview, wxPrintPreview, DrawBlankPage);
2496 IMP_PYCALLBACK_BOOL_INT     (wxPyPrintPreview, wxPrintPreview, RenderPage);
2497 IMP_PYCALLBACK_VOID_INT     (wxPyPrintPreview, wxPrintPreview, SetZoom);
2498 IMP_PYCALLBACK_BOOL_BOOL    (wxPyPrintPreview, wxPrintPreview, Print);
2499 IMP_PYCALLBACK_VOID_        (wxPyPrintPreview, wxPrintPreview, DetermineScaling);
2500
2501
2502 class wxPyPreviewFrame : public wxPreviewFrame
2503 {
2504     DECLARE_CLASS(wxPyPreviewFrame);
2505 public:
2506     wxPyPreviewFrame(wxPrintPreview* preview, wxFrame* parent,
2507                      const wxString& title,
2508                      const wxPoint& pos = wxDefaultPosition,
2509                      const wxSize&  size = wxDefaultSize,
2510                      long style = wxDEFAULT_FRAME_STYLE,
2511                      const wxString& name = wxPyFrameNameStr)
2512         : wxPreviewFrame(preview, parent, title, pos, size, style, name)
2513     {}
2514
2515     void SetPreviewCanvas(wxPreviewCanvas* canvas) { m_previewCanvas = canvas; }
2516     void SetControlBar(wxPreviewControlBar* bar) { m_controlBar = bar; }
2517
2518     DEC_PYCALLBACK_VOID_(Initialize);
2519     DEC_PYCALLBACK_VOID_(CreateCanvas);
2520     DEC_PYCALLBACK_VOID_(CreateControlBar);
2521
2522     PYPRIVATE;
2523 };
2524
2525 IMPLEMENT_CLASS(wxPyPreviewFrame, wxPreviewFrame);
2526
2527 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, Initialize);
2528 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, CreateCanvas);
2529 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, CreateControlBar);
2530
2531
2532 class wxPyPreviewControlBar : public wxPreviewControlBar
2533 {
2534     DECLARE_CLASS(wxPyPreviewControlBar);
2535 public:
2536     wxPyPreviewControlBar(wxPrintPreview *preview,
2537                           long buttons,
2538                           wxWindow *parent,
2539                           const wxPoint& pos = wxDefaultPosition,
2540                           const wxSize& size = wxDefaultSize,
2541                           long style = 0,
2542                           const wxString& name = wxPyPanelNameStr)
2543         : wxPreviewControlBar(preview, buttons, parent, pos, size, style, name)
2544     {}
2545
2546     void SetPrintPreview(wxPrintPreview* preview) { m_printPreview = preview; }
2547
2548     DEC_PYCALLBACK_VOID_(CreateButtons);
2549     DEC_PYCALLBACK_VOID_INT(SetZoomControl);
2550
2551     PYPRIVATE;
2552 };
2553
2554 IMPLEMENT_CLASS(wxPyPreviewControlBar, wxPreviewControlBar);
2555 IMP_PYCALLBACK_VOID_(wxPyPreviewControlBar, wxPreviewControlBar, CreateButtons);
2556 IMP_PYCALLBACK_VOID_INT(wxPyPreviewControlBar, wxPreviewControlBar, SetZoomControl);
2557
2558 #ifdef __cplusplus
2559 extern "C" {
2560 #endif
2561 static PyObject *_wrap_new_Panel(PyObject *, PyObject *args, PyObject *kwargs) {
2562     PyObject *resultobj;
2563     wxWindow *arg1 = (wxWindow *) 0 ;
2564     int arg2 = (int) (int)-1 ;
2565     wxPoint const &arg3_defvalue = wxDefaultPosition ;
2566     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
2567     wxSize const &arg4_defvalue = wxDefaultSize ;
2568     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
2569     long arg5 = (long) wxTAB_TRAVERSAL|wxNO_BORDER ;
2570     wxString const &arg6_defvalue = wxPyPanelNameStr ;
2571     wxString *arg6 = (wxString *) &arg6_defvalue ;
2572     wxPanel *result;
2573     wxPoint temp3 ;
2574     wxSize temp4 ;
2575     bool temp6 = false ;
2576     PyObject * obj0 = 0 ;
2577     PyObject * obj1 = 0 ;
2578     PyObject * obj2 = 0 ;
2579     PyObject * obj3 = 0 ;
2580     PyObject * obj4 = 0 ;
2581     PyObject * obj5 = 0 ;
2582     char *kwnames[] = {
2583         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
2584     };
2585
2586     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Panel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2587     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2588     if (SWIG_arg_fail(1)) SWIG_fail;
2589     if (obj1) {
2590         {
2591             arg2 = (int const)(SWIG_As_int(obj1));
2592             if (SWIG_arg_fail(2)) SWIG_fail;
2593         }
2594     }
2595     if (obj2) {
2596         {
2597             arg3 = &temp3;
2598             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
2599         }
2600     }
2601     if (obj3) {
2602         {
2603             arg4 = &temp4;
2604             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
2605         }
2606     }
2607     if (obj4) {
2608         {
2609             arg5 = (long)(SWIG_As_long(obj4));
2610             if (SWIG_arg_fail(5)) SWIG_fail;
2611         }
2612     }
2613     if (obj5) {
2614         {
2615             arg6 = wxString_in_helper(obj5);
2616             if (arg6 == NULL) SWIG_fail;
2617             temp6 = true;
2618         }
2619     }
2620     {
2621         if (!wxPyCheckForApp()) SWIG_fail;
2622         PyThreadState* __tstate = wxPyBeginAllowThreads();
2623         result = (wxPanel *)new wxPanel(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
2624
2625         wxPyEndAllowThreads(__tstate);
2626         if (PyErr_Occurred()) SWIG_fail;
2627     }
2628     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPanel, 1);
2629     {
2630         if (temp6)
2631         delete arg6;
2632     }
2633     return resultobj;
2634     fail:
2635     {
2636         if (temp6)
2637         delete arg6;
2638     }
2639     return NULL;
2640 }
2641
2642
2643 static PyObject *_wrap_new_PrePanel(PyObject *, PyObject *args, PyObject *kwargs) {
2644     PyObject *resultobj;
2645     wxPanel *result;
2646     char *kwnames[] = {
2647         NULL
2648     };
2649
2650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePanel",kwnames)) goto fail;
2651     {
2652         if (!wxPyCheckForApp()) SWIG_fail;
2653         PyThreadState* __tstate = wxPyBeginAllowThreads();
2654         result = (wxPanel *)new wxPanel();
2655
2656         wxPyEndAllowThreads(__tstate);
2657         if (PyErr_Occurred()) SWIG_fail;
2658     }
2659     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPanel, 1);
2660     return resultobj;
2661     fail:
2662     return NULL;
2663 }
2664
2665
2666 static PyObject *_wrap_Panel_Create(PyObject *, PyObject *args, PyObject *kwargs) {
2667     PyObject *resultobj;
2668     wxPanel *arg1 = (wxPanel *) 0 ;
2669     wxWindow *arg2 = (wxWindow *) 0 ;
2670     int arg3 = (int) (int)-1 ;
2671     wxPoint const &arg4_defvalue = wxDefaultPosition ;
2672     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
2673     wxSize const &arg5_defvalue = wxDefaultSize ;
2674     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
2675     long arg6 = (long) wxTAB_TRAVERSAL|wxNO_BORDER ;
2676     wxString const &arg7_defvalue = wxPyPanelNameStr ;
2677     wxString *arg7 = (wxString *) &arg7_defvalue ;
2678     bool result;
2679     wxPoint temp4 ;
2680     wxSize temp5 ;
2681     bool temp7 = false ;
2682     PyObject * obj0 = 0 ;
2683     PyObject * obj1 = 0 ;
2684     PyObject * obj2 = 0 ;
2685     PyObject * obj3 = 0 ;
2686     PyObject * obj4 = 0 ;
2687     PyObject * obj5 = 0 ;
2688     PyObject * obj6 = 0 ;
2689     char *kwnames[] = {
2690         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
2691     };
2692
2693     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Panel_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2694     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2695     if (SWIG_arg_fail(1)) SWIG_fail;
2696     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2697     if (SWIG_arg_fail(2)) SWIG_fail;
2698     if (obj2) {
2699         {
2700             arg3 = (int const)(SWIG_As_int(obj2));
2701             if (SWIG_arg_fail(3)) SWIG_fail;
2702         }
2703     }
2704     if (obj3) {
2705         {
2706             arg4 = &temp4;
2707             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
2708         }
2709     }
2710     if (obj4) {
2711         {
2712             arg5 = &temp5;
2713             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
2714         }
2715     }
2716     if (obj5) {
2717         {
2718             arg6 = (long)(SWIG_As_long(obj5));
2719             if (SWIG_arg_fail(6)) SWIG_fail;
2720         }
2721     }
2722     if (obj6) {
2723         {
2724             arg7 = wxString_in_helper(obj6);
2725             if (arg7 == NULL) SWIG_fail;
2726             temp7 = true;
2727         }
2728     }
2729     {
2730         PyThreadState* __tstate = wxPyBeginAllowThreads();
2731         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
2732
2733         wxPyEndAllowThreads(__tstate);
2734         if (PyErr_Occurred()) SWIG_fail;
2735     }
2736     {
2737         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2738     }
2739     {
2740         if (temp7)
2741         delete arg7;
2742     }
2743     return resultobj;
2744     fail:
2745     {
2746         if (temp7)
2747         delete arg7;
2748     }
2749     return NULL;
2750 }
2751
2752
2753 static PyObject *_wrap_Panel_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
2754     PyObject *resultobj;
2755     wxPanel *arg1 = (wxPanel *) 0 ;
2756     PyObject * obj0 = 0 ;
2757     char *kwnames[] = {
2758         (char *) "self", NULL
2759     };
2760
2761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Panel_InitDialog",kwnames,&obj0)) goto fail;
2762     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2763     if (SWIG_arg_fail(1)) SWIG_fail;
2764     {
2765         PyThreadState* __tstate = wxPyBeginAllowThreads();
2766         (arg1)->InitDialog();
2767
2768         wxPyEndAllowThreads(__tstate);
2769         if (PyErr_Occurred()) SWIG_fail;
2770     }
2771     Py_INCREF(Py_None); resultobj = Py_None;
2772     return resultobj;
2773     fail:
2774     return NULL;
2775 }
2776
2777
2778 static PyObject *_wrap_Panel_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
2779     PyObject *resultobj;
2780     wxPanel *arg1 = (wxPanel *) 0 ;
2781     PyObject * obj0 = 0 ;
2782     char *kwnames[] = {
2783         (char *) "self", NULL
2784     };
2785
2786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Panel_SetFocus",kwnames,&obj0)) goto fail;
2787     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2788     if (SWIG_arg_fail(1)) SWIG_fail;
2789     {
2790         PyThreadState* __tstate = wxPyBeginAllowThreads();
2791         (arg1)->SetFocus();
2792
2793         wxPyEndAllowThreads(__tstate);
2794         if (PyErr_Occurred()) SWIG_fail;
2795     }
2796     Py_INCREF(Py_None); resultobj = Py_None;
2797     return resultobj;
2798     fail:
2799     return NULL;
2800 }
2801
2802
2803 static PyObject *_wrap_Panel_SetFocusIgnoringChildren(PyObject *, PyObject *args, PyObject *kwargs) {
2804     PyObject *resultobj;
2805     wxPanel *arg1 = (wxPanel *) 0 ;
2806     PyObject * obj0 = 0 ;
2807     char *kwnames[] = {
2808         (char *) "self", NULL
2809     };
2810
2811     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Panel_SetFocusIgnoringChildren",kwnames,&obj0)) goto fail;
2812     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2813     if (SWIG_arg_fail(1)) SWIG_fail;
2814     {
2815         PyThreadState* __tstate = wxPyBeginAllowThreads();
2816         (arg1)->SetFocusIgnoringChildren();
2817
2818         wxPyEndAllowThreads(__tstate);
2819         if (PyErr_Occurred()) SWIG_fail;
2820     }
2821     Py_INCREF(Py_None); resultobj = Py_None;
2822     return resultobj;
2823     fail:
2824     return NULL;
2825 }
2826
2827
2828 static PyObject *_wrap_Panel_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
2829     PyObject *resultobj;
2830     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
2831     wxVisualAttributes result;
2832     PyObject * obj0 = 0 ;
2833     char *kwnames[] = {
2834         (char *) "variant", NULL
2835     };
2836
2837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Panel_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
2838     if (obj0) {
2839         {
2840             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
2841             if (SWIG_arg_fail(1)) SWIG_fail;
2842         }
2843     }
2844     {
2845         if (!wxPyCheckForApp()) SWIG_fail;
2846         PyThreadState* __tstate = wxPyBeginAllowThreads();
2847         result = wxPanel::GetClassDefaultAttributes((wxWindowVariant )arg1);
2848
2849         wxPyEndAllowThreads(__tstate);
2850         if (PyErr_Occurred()) SWIG_fail;
2851     }
2852     {
2853         wxVisualAttributes * resultptr;
2854         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
2855         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
2856     }
2857     return resultobj;
2858     fail:
2859     return NULL;
2860 }
2861
2862
2863 static PyObject * Panel_swigregister(PyObject *, PyObject *args) {
2864     PyObject *obj;
2865     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2866     SWIG_TypeClientData(SWIGTYPE_p_wxPanel, obj);
2867     Py_INCREF(obj);
2868     return Py_BuildValue((char *)"");
2869 }
2870 static PyObject *_wrap_new_ScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
2871     PyObject *resultobj;
2872     wxWindow *arg1 = (wxWindow *) 0 ;
2873     int arg2 = (int) (int)-1 ;
2874     wxPoint const &arg3_defvalue = wxDefaultPosition ;
2875     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
2876     wxSize const &arg4_defvalue = wxDefaultSize ;
2877     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
2878     long arg5 = (long) wxHSCROLL|wxVSCROLL ;
2879     wxString const &arg6_defvalue = wxPyPanelNameStr ;
2880     wxString *arg6 = (wxString *) &arg6_defvalue ;
2881     wxScrolledWindow *result;
2882     wxPoint temp3 ;
2883     wxSize temp4 ;
2884     bool temp6 = false ;
2885     PyObject * obj0 = 0 ;
2886     PyObject * obj1 = 0 ;
2887     PyObject * obj2 = 0 ;
2888     PyObject * obj3 = 0 ;
2889     PyObject * obj4 = 0 ;
2890     PyObject * obj5 = 0 ;
2891     char *kwnames[] = {
2892         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
2893     };
2894
2895     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_ScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2896     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2897     if (SWIG_arg_fail(1)) SWIG_fail;
2898     if (obj1) {
2899         {
2900             arg2 = (int const)(SWIG_As_int(obj1));
2901             if (SWIG_arg_fail(2)) SWIG_fail;
2902         }
2903     }
2904     if (obj2) {
2905         {
2906             arg3 = &temp3;
2907             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
2908         }
2909     }
2910     if (obj3) {
2911         {
2912             arg4 = &temp4;
2913             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
2914         }
2915     }
2916     if (obj4) {
2917         {
2918             arg5 = (long)(SWIG_As_long(obj4));
2919             if (SWIG_arg_fail(5)) SWIG_fail;
2920         }
2921     }
2922     if (obj5) {
2923         {
2924             arg6 = wxString_in_helper(obj5);
2925             if (arg6 == NULL) SWIG_fail;
2926             temp6 = true;
2927         }
2928     }
2929     {
2930         if (!wxPyCheckForApp()) SWIG_fail;
2931         PyThreadState* __tstate = wxPyBeginAllowThreads();
2932         result = (wxScrolledWindow *)new wxScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
2933
2934         wxPyEndAllowThreads(__tstate);
2935         if (PyErr_Occurred()) SWIG_fail;
2936     }
2937     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrolledWindow, 1);
2938     {
2939         if (temp6)
2940         delete arg6;
2941     }
2942     return resultobj;
2943     fail:
2944     {
2945         if (temp6)
2946         delete arg6;
2947     }
2948     return NULL;
2949 }
2950
2951
2952 static PyObject *_wrap_new_PreScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
2953     PyObject *resultobj;
2954     wxScrolledWindow *result;
2955     char *kwnames[] = {
2956         NULL
2957     };
2958
2959     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreScrolledWindow",kwnames)) goto fail;
2960     {
2961         if (!wxPyCheckForApp()) SWIG_fail;
2962         PyThreadState* __tstate = wxPyBeginAllowThreads();
2963         result = (wxScrolledWindow *)new wxScrolledWindow();
2964
2965         wxPyEndAllowThreads(__tstate);
2966         if (PyErr_Occurred()) SWIG_fail;
2967     }
2968     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrolledWindow, 1);
2969     return resultobj;
2970     fail:
2971     return NULL;
2972 }
2973
2974
2975 static PyObject *_wrap_ScrolledWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
2976     PyObject *resultobj;
2977     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
2978     wxWindow *arg2 = (wxWindow *) 0 ;
2979     int arg3 = (int) (int)-1 ;
2980     wxPoint const &arg4_defvalue = wxDefaultPosition ;
2981     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
2982     wxSize const &arg5_defvalue = wxDefaultSize ;
2983     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
2984     long arg6 = (long) wxHSCROLL|wxVSCROLL ;
2985     wxString const &arg7_defvalue = wxPyPanelNameStr ;
2986     wxString *arg7 = (wxString *) &arg7_defvalue ;
2987     bool result;
2988     wxPoint temp4 ;
2989     wxSize temp5 ;
2990     bool temp7 = false ;
2991     PyObject * obj0 = 0 ;
2992     PyObject * obj1 = 0 ;
2993     PyObject * obj2 = 0 ;
2994     PyObject * obj3 = 0 ;
2995     PyObject * obj4 = 0 ;
2996     PyObject * obj5 = 0 ;
2997     PyObject * obj6 = 0 ;
2998     char *kwnames[] = {
2999         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
3000     };
3001
3002     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:ScrolledWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3003     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3004     if (SWIG_arg_fail(1)) SWIG_fail;
3005     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3006     if (SWIG_arg_fail(2)) SWIG_fail;
3007     if (obj2) {
3008         {
3009             arg3 = (int const)(SWIG_As_int(obj2));
3010             if (SWIG_arg_fail(3)) SWIG_fail;
3011         }
3012     }
3013     if (obj3) {
3014         {
3015             arg4 = &temp4;
3016             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
3017         }
3018     }
3019     if (obj4) {
3020         {
3021             arg5 = &temp5;
3022             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
3023         }
3024     }
3025     if (obj5) {
3026         {
3027             arg6 = (long)(SWIG_As_long(obj5));
3028             if (SWIG_arg_fail(6)) SWIG_fail;
3029         }
3030     }
3031     if (obj6) {
3032         {
3033             arg7 = wxString_in_helper(obj6);
3034             if (arg7 == NULL) SWIG_fail;
3035             temp7 = true;
3036         }
3037     }
3038     {
3039         PyThreadState* __tstate = wxPyBeginAllowThreads();
3040         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
3041
3042         wxPyEndAllowThreads(__tstate);
3043         if (PyErr_Occurred()) SWIG_fail;
3044     }
3045     {
3046         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3047     }
3048     {
3049         if (temp7)
3050         delete arg7;
3051     }
3052     return resultobj;
3053     fail:
3054     {
3055         if (temp7)
3056         delete arg7;
3057     }
3058     return NULL;
3059 }
3060
3061
3062 static PyObject *_wrap_ScrolledWindow_SetScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
3063     PyObject *resultobj;
3064     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3065     int arg2 ;
3066     int arg3 ;
3067     int arg4 ;
3068     int arg5 ;
3069     int arg6 = (int) 0 ;
3070     int arg7 = (int) 0 ;
3071     bool arg8 = (bool) false ;
3072     PyObject * obj0 = 0 ;
3073     PyObject * obj1 = 0 ;
3074     PyObject * obj2 = 0 ;
3075     PyObject * obj3 = 0 ;
3076     PyObject * obj4 = 0 ;
3077     PyObject * obj5 = 0 ;
3078     PyObject * obj6 = 0 ;
3079     PyObject * obj7 = 0 ;
3080     char *kwnames[] = {
3081         (char *) "self",(char *) "pixelsPerUnitX",(char *) "pixelsPerUnitY",(char *) "noUnitsX",(char *) "noUnitsY",(char *) "xPos",(char *) "yPos",(char *) "noRefresh", NULL
3082     };
3083
3084     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:ScrolledWindow_SetScrollbars",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
3085     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3086     if (SWIG_arg_fail(1)) SWIG_fail;
3087     {
3088         arg2 = (int)(SWIG_As_int(obj1));
3089         if (SWIG_arg_fail(2)) SWIG_fail;
3090     }
3091     {
3092         arg3 = (int)(SWIG_As_int(obj2));
3093         if (SWIG_arg_fail(3)) SWIG_fail;
3094     }
3095     {
3096         arg4 = (int)(SWIG_As_int(obj3));
3097         if (SWIG_arg_fail(4)) SWIG_fail;
3098     }
3099     {
3100         arg5 = (int)(SWIG_As_int(obj4));
3101         if (SWIG_arg_fail(5)) SWIG_fail;
3102     }
3103     if (obj5) {
3104         {
3105             arg6 = (int)(SWIG_As_int(obj5));
3106             if (SWIG_arg_fail(6)) SWIG_fail;
3107         }
3108     }
3109     if (obj6) {
3110         {
3111             arg7 = (int)(SWIG_As_int(obj6));
3112             if (SWIG_arg_fail(7)) SWIG_fail;
3113         }
3114     }
3115     if (obj7) {
3116         {
3117             arg8 = (bool)(SWIG_As_bool(obj7));
3118             if (SWIG_arg_fail(8)) SWIG_fail;
3119         }
3120     }
3121     {
3122         PyThreadState* __tstate = wxPyBeginAllowThreads();
3123         (arg1)->SetScrollbars(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
3124
3125         wxPyEndAllowThreads(__tstate);
3126         if (PyErr_Occurred()) SWIG_fail;
3127     }
3128     Py_INCREF(Py_None); resultobj = Py_None;
3129     return resultobj;
3130     fail:
3131     return NULL;
3132 }
3133
3134
3135 static PyObject *_wrap_ScrolledWindow_Scroll(PyObject *, PyObject *args, PyObject *kwargs) {
3136     PyObject *resultobj;
3137     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3138     int arg2 ;
3139     int arg3 ;
3140     PyObject * obj0 = 0 ;
3141     PyObject * obj1 = 0 ;
3142     PyObject * obj2 = 0 ;
3143     char *kwnames[] = {
3144         (char *) "self",(char *) "x",(char *) "y", NULL
3145     };
3146
3147     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_Scroll",kwnames,&obj0,&obj1,&obj2)) goto fail;
3148     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3149     if (SWIG_arg_fail(1)) SWIG_fail;
3150     {
3151         arg2 = (int)(SWIG_As_int(obj1));
3152         if (SWIG_arg_fail(2)) SWIG_fail;
3153     }
3154     {
3155         arg3 = (int)(SWIG_As_int(obj2));
3156         if (SWIG_arg_fail(3)) SWIG_fail;
3157     }
3158     {
3159         PyThreadState* __tstate = wxPyBeginAllowThreads();
3160         (arg1)->Scroll(arg2,arg3);
3161
3162         wxPyEndAllowThreads(__tstate);
3163         if (PyErr_Occurred()) SWIG_fail;
3164     }
3165     Py_INCREF(Py_None); resultobj = Py_None;
3166     return resultobj;
3167     fail:
3168     return NULL;
3169 }
3170
3171
3172 static PyObject *_wrap_ScrolledWindow_GetScrollPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
3173     PyObject *resultobj;
3174     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3175     int arg2 ;
3176     int result;
3177     PyObject * obj0 = 0 ;
3178     PyObject * obj1 = 0 ;
3179     char *kwnames[] = {
3180         (char *) "self",(char *) "orient", NULL
3181     };
3182
3183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_GetScrollPageSize",kwnames,&obj0,&obj1)) goto fail;
3184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3185     if (SWIG_arg_fail(1)) SWIG_fail;
3186     {
3187         arg2 = (int)(SWIG_As_int(obj1));
3188         if (SWIG_arg_fail(2)) SWIG_fail;
3189     }
3190     {
3191         PyThreadState* __tstate = wxPyBeginAllowThreads();
3192         result = (int)((wxScrolledWindow const *)arg1)->GetScrollPageSize(arg2);
3193
3194         wxPyEndAllowThreads(__tstate);
3195         if (PyErr_Occurred()) SWIG_fail;
3196     }
3197     {
3198         resultobj = SWIG_From_int((int)(result));
3199     }
3200     return resultobj;
3201     fail:
3202     return NULL;
3203 }
3204
3205
3206 static PyObject *_wrap_ScrolledWindow_SetScrollPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
3207     PyObject *resultobj;
3208     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3209     int arg2 ;
3210     int arg3 ;
3211     PyObject * obj0 = 0 ;
3212     PyObject * obj1 = 0 ;
3213     PyObject * obj2 = 0 ;
3214     char *kwnames[] = {
3215         (char *) "self",(char *) "orient",(char *) "pageSize", NULL
3216     };
3217
3218     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_SetScrollPageSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
3219     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3220     if (SWIG_arg_fail(1)) SWIG_fail;
3221     {
3222         arg2 = (int)(SWIG_As_int(obj1));
3223         if (SWIG_arg_fail(2)) SWIG_fail;
3224     }
3225     {
3226         arg3 = (int)(SWIG_As_int(obj2));
3227         if (SWIG_arg_fail(3)) SWIG_fail;
3228     }
3229     {
3230         PyThreadState* __tstate = wxPyBeginAllowThreads();
3231         (arg1)->SetScrollPageSize(arg2,arg3);
3232
3233         wxPyEndAllowThreads(__tstate);
3234         if (PyErr_Occurred()) SWIG_fail;
3235     }
3236     Py_INCREF(Py_None); resultobj = Py_None;
3237     return resultobj;
3238     fail:
3239     return NULL;
3240 }
3241
3242
3243 static PyObject *_wrap_ScrolledWindow_SetScrollRate(PyObject *, PyObject *args, PyObject *kwargs) {
3244     PyObject *resultobj;
3245     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3246     int arg2 ;
3247     int arg3 ;
3248     PyObject * obj0 = 0 ;
3249     PyObject * obj1 = 0 ;
3250     PyObject * obj2 = 0 ;
3251     char *kwnames[] = {
3252         (char *) "self",(char *) "xstep",(char *) "ystep", NULL
3253     };
3254
3255     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_SetScrollRate",kwnames,&obj0,&obj1,&obj2)) goto fail;
3256     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3257     if (SWIG_arg_fail(1)) SWIG_fail;
3258     {
3259         arg2 = (int)(SWIG_As_int(obj1));
3260         if (SWIG_arg_fail(2)) SWIG_fail;
3261     }
3262     {
3263         arg3 = (int)(SWIG_As_int(obj2));
3264         if (SWIG_arg_fail(3)) SWIG_fail;
3265     }
3266     {
3267         PyThreadState* __tstate = wxPyBeginAllowThreads();
3268         (arg1)->SetScrollRate(arg2,arg3);
3269
3270         wxPyEndAllowThreads(__tstate);
3271         if (PyErr_Occurred()) SWIG_fail;
3272     }
3273     Py_INCREF(Py_None); resultobj = Py_None;
3274     return resultobj;
3275     fail:
3276     return NULL;
3277 }
3278
3279
3280 static PyObject *_wrap_ScrolledWindow_GetScrollPixelsPerUnit(PyObject *, PyObject *args, PyObject *kwargs) {
3281     PyObject *resultobj;
3282     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3283     int *arg2 = (int *) 0 ;
3284     int *arg3 = (int *) 0 ;
3285     int temp2 ;
3286     int res2 = 0 ;
3287     int temp3 ;
3288     int res3 = 0 ;
3289     PyObject * obj0 = 0 ;
3290     char *kwnames[] = {
3291         (char *) "self", NULL
3292     };
3293
3294     arg2 = &temp2; res2 = SWIG_NEWOBJ;
3295     arg3 = &temp3; res3 = SWIG_NEWOBJ;
3296     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetScrollPixelsPerUnit",kwnames,&obj0)) goto fail;
3297     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3298     if (SWIG_arg_fail(1)) SWIG_fail;
3299     {
3300         PyThreadState* __tstate = wxPyBeginAllowThreads();
3301         ((wxScrolledWindow const *)arg1)->GetScrollPixelsPerUnit(arg2,arg3);
3302
3303         wxPyEndAllowThreads(__tstate);
3304         if (PyErr_Occurred()) SWIG_fail;
3305     }
3306     Py_INCREF(Py_None); resultobj = Py_None;
3307     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3308     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3309     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
3310     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
3311     return resultobj;
3312     fail:
3313     return NULL;
3314 }
3315
3316
3317 static PyObject *_wrap_ScrolledWindow_EnableScrolling(PyObject *, PyObject *args, PyObject *kwargs) {
3318     PyObject *resultobj;
3319     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3320     bool arg2 ;
3321     bool arg3 ;
3322     PyObject * obj0 = 0 ;
3323     PyObject * obj1 = 0 ;
3324     PyObject * obj2 = 0 ;
3325     char *kwnames[] = {
3326         (char *) "self",(char *) "x_scrolling",(char *) "y_scrolling", NULL
3327     };
3328
3329     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_EnableScrolling",kwnames,&obj0,&obj1,&obj2)) goto fail;
3330     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3331     if (SWIG_arg_fail(1)) SWIG_fail;
3332     {
3333         arg2 = (bool)(SWIG_As_bool(obj1));
3334         if (SWIG_arg_fail(2)) SWIG_fail;
3335     }
3336     {
3337         arg3 = (bool)(SWIG_As_bool(obj2));
3338         if (SWIG_arg_fail(3)) SWIG_fail;
3339     }
3340     {
3341         PyThreadState* __tstate = wxPyBeginAllowThreads();
3342         (arg1)->EnableScrolling(arg2,arg3);
3343
3344         wxPyEndAllowThreads(__tstate);
3345         if (PyErr_Occurred()) SWIG_fail;
3346     }
3347     Py_INCREF(Py_None); resultobj = Py_None;
3348     return resultobj;
3349     fail:
3350     return NULL;
3351 }
3352
3353
3354 static PyObject *_wrap_ScrolledWindow_GetViewStart(PyObject *, PyObject *args, PyObject *kwargs) {
3355     PyObject *resultobj;
3356     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3357     int *arg2 = (int *) 0 ;
3358     int *arg3 = (int *) 0 ;
3359     int temp2 ;
3360     int res2 = 0 ;
3361     int temp3 ;
3362     int res3 = 0 ;
3363     PyObject * obj0 = 0 ;
3364     char *kwnames[] = {
3365         (char *) "self", NULL
3366     };
3367
3368     arg2 = &temp2; res2 = SWIG_NEWOBJ;
3369     arg3 = &temp3; res3 = SWIG_NEWOBJ;
3370     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetViewStart",kwnames,&obj0)) goto fail;
3371     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3372     if (SWIG_arg_fail(1)) SWIG_fail;
3373     {
3374         PyThreadState* __tstate = wxPyBeginAllowThreads();
3375         ((wxScrolledWindow const *)arg1)->GetViewStart(arg2,arg3);
3376
3377         wxPyEndAllowThreads(__tstate);
3378         if (PyErr_Occurred()) SWIG_fail;
3379     }
3380     Py_INCREF(Py_None); resultobj = Py_None;
3381     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3382     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3383     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
3384     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
3385     return resultobj;
3386     fail:
3387     return NULL;
3388 }
3389
3390
3391 static PyObject *_wrap_ScrolledWindow_SetScale(PyObject *, PyObject *args, PyObject *kwargs) {
3392     PyObject *resultobj;
3393     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3394     double arg2 ;
3395     double arg3 ;
3396     PyObject * obj0 = 0 ;
3397     PyObject * obj1 = 0 ;
3398     PyObject * obj2 = 0 ;
3399     char *kwnames[] = {
3400         (char *) "self",(char *) "xs",(char *) "ys", NULL
3401     };
3402
3403     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_SetScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
3404     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3405     if (SWIG_arg_fail(1)) SWIG_fail;
3406     {
3407         arg2 = (double)(SWIG_As_double(obj1));
3408         if (SWIG_arg_fail(2)) SWIG_fail;
3409     }
3410     {
3411         arg3 = (double)(SWIG_As_double(obj2));
3412         if (SWIG_arg_fail(3)) SWIG_fail;
3413     }
3414     {
3415         PyThreadState* __tstate = wxPyBeginAllowThreads();
3416         (arg1)->SetScale(arg2,arg3);
3417
3418         wxPyEndAllowThreads(__tstate);
3419         if (PyErr_Occurred()) SWIG_fail;
3420     }
3421     Py_INCREF(Py_None); resultobj = Py_None;
3422     return resultobj;
3423     fail:
3424     return NULL;
3425 }
3426
3427
3428 static PyObject *_wrap_ScrolledWindow_GetScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
3429     PyObject *resultobj;
3430     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3431     double result;
3432     PyObject * obj0 = 0 ;
3433     char *kwnames[] = {
3434         (char *) "self", NULL
3435     };
3436
3437     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetScaleX",kwnames,&obj0)) goto fail;
3438     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3439     if (SWIG_arg_fail(1)) SWIG_fail;
3440     {
3441         PyThreadState* __tstate = wxPyBeginAllowThreads();
3442         result = (double)((wxScrolledWindow const *)arg1)->GetScaleX();
3443
3444         wxPyEndAllowThreads(__tstate);
3445         if (PyErr_Occurred()) SWIG_fail;
3446     }
3447     {
3448         resultobj = SWIG_From_double((double)(result));
3449     }
3450     return resultobj;
3451     fail:
3452     return NULL;
3453 }
3454
3455
3456 static PyObject *_wrap_ScrolledWindow_GetScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
3457     PyObject *resultobj;
3458     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3459     double result;
3460     PyObject * obj0 = 0 ;
3461     char *kwnames[] = {
3462         (char *) "self", NULL
3463     };
3464
3465     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetScaleY",kwnames,&obj0)) goto fail;
3466     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3467     if (SWIG_arg_fail(1)) SWIG_fail;
3468     {
3469         PyThreadState* __tstate = wxPyBeginAllowThreads();
3470         result = (double)((wxScrolledWindow const *)arg1)->GetScaleY();
3471
3472         wxPyEndAllowThreads(__tstate);
3473         if (PyErr_Occurred()) SWIG_fail;
3474     }
3475     {
3476         resultobj = SWIG_From_double((double)(result));
3477     }
3478     return resultobj;
3479     fail:
3480     return NULL;
3481 }
3482
3483
3484 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(PyObject *, PyObject *args) {
3485     PyObject *resultobj;
3486     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3487     wxPoint *arg2 = 0 ;
3488     wxPoint result;
3489     wxPoint temp2 ;
3490     PyObject * obj0 = 0 ;
3491     PyObject * obj1 = 0 ;
3492
3493     if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcScrolledPosition",&obj0,&obj1)) goto fail;
3494     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3495     if (SWIG_arg_fail(1)) SWIG_fail;
3496     {
3497         arg2 = &temp2;
3498         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
3499     }
3500     {
3501         PyThreadState* __tstate = wxPyBeginAllowThreads();
3502         result = ((wxScrolledWindow const *)arg1)->CalcScrolledPosition((wxPoint const &)*arg2);
3503
3504         wxPyEndAllowThreads(__tstate);
3505         if (PyErr_Occurred()) SWIG_fail;
3506     }
3507     {
3508         wxPoint * resultptr;
3509         resultptr = new wxPoint((wxPoint &)(result));
3510         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
3511     }
3512     return resultobj;
3513     fail:
3514     return NULL;
3515 }
3516
3517
3518 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(PyObject *, PyObject *args) {
3519     PyObject *resultobj;
3520     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3521     int arg2 ;
3522     int arg3 ;
3523     int *arg4 = (int *) 0 ;
3524     int *arg5 = (int *) 0 ;
3525     int temp4 ;
3526     int res4 = 0 ;
3527     int temp5 ;
3528     int res5 = 0 ;
3529     PyObject * obj0 = 0 ;
3530     PyObject * obj1 = 0 ;
3531     PyObject * obj2 = 0 ;
3532
3533     arg4 = &temp4; res4 = SWIG_NEWOBJ;
3534     arg5 = &temp5; res5 = SWIG_NEWOBJ;
3535     if(!PyArg_ParseTuple(args,(char *)"OOO:ScrolledWindow_CalcScrolledPosition",&obj0,&obj1,&obj2)) goto fail;
3536     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3537     if (SWIG_arg_fail(1)) SWIG_fail;
3538     {
3539         arg2 = (int)(SWIG_As_int(obj1));
3540         if (SWIG_arg_fail(2)) SWIG_fail;
3541     }
3542     {
3543         arg3 = (int)(SWIG_As_int(obj2));
3544         if (SWIG_arg_fail(3)) SWIG_fail;
3545     }
3546     {
3547         PyThreadState* __tstate = wxPyBeginAllowThreads();
3548         ((wxScrolledWindow const *)arg1)->CalcScrolledPosition(arg2,arg3,arg4,arg5);
3549
3550         wxPyEndAllowThreads(__tstate);
3551         if (PyErr_Occurred()) SWIG_fail;
3552     }
3553     Py_INCREF(Py_None); resultobj = Py_None;
3554     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
3555     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
3556     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
3557     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
3558     return resultobj;
3559     fail:
3560     return NULL;
3561 }
3562
3563
3564 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObject *args) {
3565     int argc;
3566     PyObject *argv[4];
3567     int ii;
3568
3569     argc = PyObject_Length(args);
3570     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3571         argv[ii] = PyTuple_GetItem(args,ii);
3572     }
3573     if (argc == 2) {
3574         int _v;
3575         {
3576             void *ptr;
3577             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3578                 _v = 0;
3579                 PyErr_Clear();
3580             } else {
3581                 _v = 1;
3582             }
3583         }
3584         if (_v) {
3585             {
3586                 _v = wxPySimple_typecheck(argv[1], wxT("wxPoint"), 2);
3587             }
3588             if (_v) {
3589                 return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(self,args);
3590             }
3591         }
3592     }
3593     if (argc == 3) {
3594         int _v;
3595         {
3596             void *ptr;
3597             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3598                 _v = 0;
3599                 PyErr_Clear();
3600             } else {
3601                 _v = 1;
3602             }
3603         }
3604         if (_v) {
3605             _v = SWIG_Check_int(argv[1]);
3606             if (_v) {
3607                 _v = SWIG_Check_int(argv[2]);
3608                 if (_v) {
3609                     return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(self,args);
3610                 }
3611             }
3612         }
3613     }
3614
3615     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'ScrolledWindow_CalcScrolledPosition'");
3616     return NULL;
3617 }
3618
3619
3620 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(PyObject *, PyObject *args) {
3621     PyObject *resultobj;
3622     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3623     wxPoint *arg2 = 0 ;
3624     wxPoint result;
3625     wxPoint temp2 ;
3626     PyObject * obj0 = 0 ;
3627     PyObject * obj1 = 0 ;
3628
3629     if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcUnscrolledPosition",&obj0,&obj1)) goto fail;
3630     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3631     if (SWIG_arg_fail(1)) SWIG_fail;
3632     {
3633         arg2 = &temp2;
3634         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
3635     }
3636     {
3637         PyThreadState* __tstate = wxPyBeginAllowThreads();
3638         result = ((wxScrolledWindow const *)arg1)->CalcUnscrolledPosition((wxPoint const &)*arg2);
3639
3640         wxPyEndAllowThreads(__tstate);
3641         if (PyErr_Occurred()) SWIG_fail;
3642     }
3643     {
3644         wxPoint * resultptr;
3645         resultptr = new wxPoint((wxPoint &)(result));
3646         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
3647     }
3648     return resultobj;
3649     fail:
3650     return NULL;
3651 }
3652
3653
3654 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(PyObject *, PyObject *args) {
3655     PyObject *resultobj;
3656     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3657     int arg2 ;
3658     int arg3 ;
3659     int *arg4 = (int *) 0 ;
3660     int *arg5 = (int *) 0 ;
3661     int temp4 ;
3662     int res4 = 0 ;
3663     int temp5 ;
3664     int res5 = 0 ;
3665     PyObject * obj0 = 0 ;
3666     PyObject * obj1 = 0 ;
3667     PyObject * obj2 = 0 ;
3668
3669     arg4 = &temp4; res4 = SWIG_NEWOBJ;
3670     arg5 = &temp5; res5 = SWIG_NEWOBJ;
3671     if(!PyArg_ParseTuple(args,(char *)"OOO:ScrolledWindow_CalcUnscrolledPosition",&obj0,&obj1,&obj2)) goto fail;
3672     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3673     if (SWIG_arg_fail(1)) SWIG_fail;
3674     {
3675         arg2 = (int)(SWIG_As_int(obj1));
3676         if (SWIG_arg_fail(2)) SWIG_fail;
3677     }
3678     {
3679         arg3 = (int)(SWIG_As_int(obj2));
3680         if (SWIG_arg_fail(3)) SWIG_fail;
3681     }
3682     {
3683         PyThreadState* __tstate = wxPyBeginAllowThreads();
3684         ((wxScrolledWindow const *)arg1)->CalcUnscrolledPosition(arg2,arg3,arg4,arg5);
3685
3686         wxPyEndAllowThreads(__tstate);
3687         if (PyErr_Occurred()) SWIG_fail;
3688     }
3689     Py_INCREF(Py_None); resultobj = Py_None;
3690     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
3691     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
3692     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
3693     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
3694     return resultobj;
3695     fail:
3696     return NULL;
3697 }
3698
3699
3700 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition(PyObject *self, PyObject *args) {
3701     int argc;
3702     PyObject *argv[4];
3703     int ii;
3704
3705     argc = PyObject_Length(args);
3706     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3707         argv[ii] = PyTuple_GetItem(args,ii);
3708     }
3709     if (argc == 2) {
3710         int _v;
3711         {
3712             void *ptr;
3713             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3714                 _v = 0;
3715                 PyErr_Clear();
3716             } else {
3717                 _v = 1;
3718             }
3719         }
3720         if (_v) {
3721             {
3722                 _v = wxPySimple_typecheck(argv[1], wxT("wxPoint"), 2);
3723             }
3724             if (_v) {
3725                 return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(self,args);
3726             }
3727         }
3728     }
3729     if (argc == 3) {
3730         int _v;
3731         {
3732             void *ptr;
3733             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3734                 _v = 0;
3735                 PyErr_Clear();
3736             } else {
3737                 _v = 1;
3738             }
3739         }
3740         if (_v) {
3741             _v = SWIG_Check_int(argv[1]);
3742             if (_v) {
3743                 _v = SWIG_Check_int(argv[2]);
3744                 if (_v) {
3745                     return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(self,args);
3746                 }
3747             }
3748         }
3749     }
3750
3751     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'ScrolledWindow_CalcUnscrolledPosition'");
3752     return NULL;
3753 }
3754
3755
3756 static PyObject *_wrap_ScrolledWindow_AdjustScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
3757     PyObject *resultobj;
3758     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3759     PyObject * obj0 = 0 ;
3760     char *kwnames[] = {
3761         (char *) "self", NULL
3762     };
3763
3764     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_AdjustScrollbars",kwnames,&obj0)) goto fail;
3765     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3766     if (SWIG_arg_fail(1)) SWIG_fail;
3767     {
3768         PyThreadState* __tstate = wxPyBeginAllowThreads();
3769         (arg1)->AdjustScrollbars();
3770
3771         wxPyEndAllowThreads(__tstate);
3772         if (PyErr_Occurred()) SWIG_fail;
3773     }
3774     Py_INCREF(Py_None); resultobj = Py_None;
3775     return resultobj;
3776     fail:
3777     return NULL;
3778 }
3779
3780
3781 static PyObject *_wrap_ScrolledWindow_CalcScrollInc(PyObject *, PyObject *args, PyObject *kwargs) {
3782     PyObject *resultobj;
3783     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3784     wxScrollWinEvent *arg2 = 0 ;
3785     int result;
3786     PyObject * obj0 = 0 ;
3787     PyObject * obj1 = 0 ;
3788     char *kwnames[] = {
3789         (char *) "self",(char *) "event", NULL
3790     };
3791
3792     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_CalcScrollInc",kwnames,&obj0,&obj1)) goto fail;
3793     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3794     if (SWIG_arg_fail(1)) SWIG_fail;
3795     {
3796         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
3797         if (SWIG_arg_fail(2)) SWIG_fail;
3798         if (arg2 == NULL) {
3799             SWIG_null_ref("wxScrollWinEvent");
3800         }
3801         if (SWIG_arg_fail(2)) SWIG_fail;
3802     }
3803     {
3804         PyThreadState* __tstate = wxPyBeginAllowThreads();
3805         result = (int)(arg1)->CalcScrollInc(*arg2);
3806
3807         wxPyEndAllowThreads(__tstate);
3808         if (PyErr_Occurred()) SWIG_fail;
3809     }
3810     {
3811         resultobj = SWIG_From_int((int)(result));
3812     }
3813     return resultobj;
3814     fail:
3815     return NULL;
3816 }
3817
3818
3819 static PyObject *_wrap_ScrolledWindow_SetTargetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
3820     PyObject *resultobj;
3821     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3822     wxWindow *arg2 = (wxWindow *) 0 ;
3823     PyObject * obj0 = 0 ;
3824     PyObject * obj1 = 0 ;
3825     char *kwnames[] = {
3826         (char *) "self",(char *) "target", NULL
3827     };
3828
3829     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_SetTargetWindow",kwnames,&obj0,&obj1)) goto fail;
3830     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3831     if (SWIG_arg_fail(1)) SWIG_fail;
3832     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3833     if (SWIG_arg_fail(2)) SWIG_fail;
3834     {
3835         PyThreadState* __tstate = wxPyBeginAllowThreads();
3836         (arg1)->SetTargetWindow(arg2);
3837
3838         wxPyEndAllowThreads(__tstate);
3839         if (PyErr_Occurred()) SWIG_fail;
3840     }
3841     Py_INCREF(Py_None); resultobj = Py_None;
3842     return resultobj;
3843     fail:
3844     return NULL;
3845 }
3846
3847
3848 static PyObject *_wrap_ScrolledWindow_GetTargetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
3849     PyObject *resultobj;
3850     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3851     wxWindow *result;
3852     PyObject * obj0 = 0 ;
3853     char *kwnames[] = {
3854         (char *) "self", NULL
3855     };
3856
3857     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetTargetWindow",kwnames,&obj0)) goto fail;
3858     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3859     if (SWIG_arg_fail(1)) SWIG_fail;
3860     {
3861         PyThreadState* __tstate = wxPyBeginAllowThreads();
3862         result = (wxWindow *)((wxScrolledWindow const *)arg1)->GetTargetWindow();
3863
3864         wxPyEndAllowThreads(__tstate);
3865         if (PyErr_Occurred()) SWIG_fail;
3866     }
3867     {
3868         resultobj = wxPyMake_wxObject(result, 0);
3869     }
3870     return resultobj;
3871     fail:
3872     return NULL;
3873 }
3874
3875
3876 static PyObject *_wrap_ScrolledWindow_SetTargetRect(PyObject *, PyObject *args, PyObject *kwargs) {
3877     PyObject *resultobj;
3878     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3879     wxRect *arg2 = 0 ;
3880     wxRect temp2 ;
3881     PyObject * obj0 = 0 ;
3882     PyObject * obj1 = 0 ;
3883     char *kwnames[] = {
3884         (char *) "self",(char *) "rect", NULL
3885     };
3886
3887     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_SetTargetRect",kwnames,&obj0,&obj1)) goto fail;
3888     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3889     if (SWIG_arg_fail(1)) SWIG_fail;
3890     {
3891         arg2 = &temp2;
3892         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3893     }
3894     {
3895         PyThreadState* __tstate = wxPyBeginAllowThreads();
3896         (arg1)->SetTargetRect((wxRect const &)*arg2);
3897
3898         wxPyEndAllowThreads(__tstate);
3899         if (PyErr_Occurred()) SWIG_fail;
3900     }
3901     Py_INCREF(Py_None); resultobj = Py_None;
3902     return resultobj;
3903     fail:
3904     return NULL;
3905 }
3906
3907
3908 static PyObject *_wrap_ScrolledWindow_GetTargetRect(PyObject *, PyObject *args, PyObject *kwargs) {
3909     PyObject *resultobj;
3910     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3911     wxRect result;
3912     PyObject * obj0 = 0 ;
3913     char *kwnames[] = {
3914         (char *) "self", NULL
3915     };
3916
3917     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetTargetRect",kwnames,&obj0)) goto fail;
3918     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3919     if (SWIG_arg_fail(1)) SWIG_fail;
3920     {
3921         PyThreadState* __tstate = wxPyBeginAllowThreads();
3922         result = ((wxScrolledWindow const *)arg1)->GetTargetRect();
3923
3924         wxPyEndAllowThreads(__tstate);
3925         if (PyErr_Occurred()) SWIG_fail;
3926     }
3927     {
3928         wxRect * resultptr;
3929         resultptr = new wxRect((wxRect &)(result));
3930         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
3931     }
3932     return resultobj;
3933     fail:
3934     return NULL;
3935 }
3936
3937
3938 static PyObject *_wrap_ScrolledWindow_DoPrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
3939     PyObject *resultobj;
3940     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3941     wxDC *arg2 = 0 ;
3942     PyObject * obj0 = 0 ;
3943     PyObject * obj1 = 0 ;
3944     char *kwnames[] = {
3945         (char *) "self",(char *) "dc", NULL
3946     };
3947
3948     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_DoPrepareDC",kwnames,&obj0,&obj1)) goto fail;
3949     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3950     if (SWIG_arg_fail(1)) SWIG_fail;
3951     {
3952         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
3953         if (SWIG_arg_fail(2)) SWIG_fail;
3954         if (arg2 == NULL) {
3955             SWIG_null_ref("wxDC");
3956         }
3957         if (SWIG_arg_fail(2)) SWIG_fail;
3958     }
3959     {
3960         PyThreadState* __tstate = wxPyBeginAllowThreads();
3961         (arg1)->DoPrepareDC(*arg2);
3962
3963         wxPyEndAllowThreads(__tstate);
3964         if (PyErr_Occurred()) SWIG_fail;
3965     }
3966     Py_INCREF(Py_None); resultobj = Py_None;
3967     return resultobj;
3968     fail:
3969     return NULL;
3970 }
3971
3972
3973 static PyObject *_wrap_ScrolledWindow_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
3974     PyObject *resultobj;
3975     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
3976     wxVisualAttributes result;
3977     PyObject * obj0 = 0 ;
3978     char *kwnames[] = {
3979         (char *) "variant", NULL
3980     };
3981
3982     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ScrolledWindow_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
3983     if (obj0) {
3984         {
3985             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
3986             if (SWIG_arg_fail(1)) SWIG_fail;
3987         }
3988     }
3989     {
3990         if (!wxPyCheckForApp()) SWIG_fail;
3991         PyThreadState* __tstate = wxPyBeginAllowThreads();
3992         result = wxScrolledWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
3993
3994         wxPyEndAllowThreads(__tstate);
3995         if (PyErr_Occurred()) SWIG_fail;
3996     }
3997     {
3998         wxVisualAttributes * resultptr;
3999         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
4000         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
4001     }
4002     return resultobj;
4003     fail:
4004     return NULL;
4005 }
4006
4007
4008 static PyObject * ScrolledWindow_swigregister(PyObject *, PyObject *args) {
4009     PyObject *obj;
4010     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4011     SWIG_TypeClientData(SWIGTYPE_p_wxScrolledWindow, obj);
4012     Py_INCREF(obj);
4013     return Py_BuildValue((char *)"");
4014 }
4015 static int _wrap_FrameNameStr_set(PyObject *) {
4016     PyErr_SetString(PyExc_TypeError,"Variable FrameNameStr is read-only.");
4017     return 1;
4018 }
4019
4020
4021 static PyObject *_wrap_FrameNameStr_get(void) {
4022     PyObject *pyobj;
4023
4024     {
4025 #if wxUSE_UNICODE
4026         pyobj = PyUnicode_FromWideChar((&wxPyFrameNameStr)->c_str(), (&wxPyFrameNameStr)->Len());
4027 #else
4028         pyobj = PyString_FromStringAndSize((&wxPyFrameNameStr)->c_str(), (&wxPyFrameNameStr)->Len());
4029 #endif
4030     }
4031     return pyobj;
4032 }
4033
4034
4035 static int _wrap_DialogNameStr_set(PyObject *) {
4036     PyErr_SetString(PyExc_TypeError,"Variable DialogNameStr is read-only.");
4037     return 1;
4038 }
4039
4040
4041 static PyObject *_wrap_DialogNameStr_get(void) {
4042     PyObject *pyobj;
4043
4044     {
4045 #if wxUSE_UNICODE
4046         pyobj = PyUnicode_FromWideChar((&wxPyDialogNameStr)->c_str(), (&wxPyDialogNameStr)->Len());
4047 #else
4048         pyobj = PyString_FromStringAndSize((&wxPyDialogNameStr)->c_str(), (&wxPyDialogNameStr)->Len());
4049 #endif
4050     }
4051     return pyobj;
4052 }
4053
4054
4055 static int _wrap_StatusLineNameStr_set(PyObject *) {
4056     PyErr_SetString(PyExc_TypeError,"Variable StatusLineNameStr is read-only.");
4057     return 1;
4058 }
4059
4060
4061 static PyObject *_wrap_StatusLineNameStr_get(void) {
4062     PyObject *pyobj;
4063
4064     {
4065 #if wxUSE_UNICODE
4066         pyobj = PyUnicode_FromWideChar((&wxPyStatusLineNameStr)->c_str(), (&wxPyStatusLineNameStr)->Len());
4067 #else
4068         pyobj = PyString_FromStringAndSize((&wxPyStatusLineNameStr)->c_str(), (&wxPyStatusLineNameStr)->Len());
4069 #endif
4070     }
4071     return pyobj;
4072 }
4073
4074
4075 static int _wrap_ToolBarNameStr_set(PyObject *) {
4076     PyErr_SetString(PyExc_TypeError,"Variable ToolBarNameStr is read-only.");
4077     return 1;
4078 }
4079
4080
4081 static PyObject *_wrap_ToolBarNameStr_get(void) {
4082     PyObject *pyobj;
4083
4084     {
4085 #if wxUSE_UNICODE
4086         pyobj = PyUnicode_FromWideChar((&wxPyToolBarNameStr)->c_str(), (&wxPyToolBarNameStr)->Len());
4087 #else
4088         pyobj = PyString_FromStringAndSize((&wxPyToolBarNameStr)->c_str(), (&wxPyToolBarNameStr)->Len());
4089 #endif
4090     }
4091     return pyobj;
4092 }
4093
4094
4095 static PyObject *_wrap_TopLevelWindow_Maximize(PyObject *, PyObject *args, PyObject *kwargs) {
4096     PyObject *resultobj;
4097     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4098     bool arg2 = (bool) true ;
4099     PyObject * obj0 = 0 ;
4100     PyObject * obj1 = 0 ;
4101     char *kwnames[] = {
4102         (char *) "self",(char *) "maximize", NULL
4103     };
4104
4105     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_Maximize",kwnames,&obj0,&obj1)) goto fail;
4106     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4107     if (SWIG_arg_fail(1)) SWIG_fail;
4108     if (obj1) {
4109         {
4110             arg2 = (bool)(SWIG_As_bool(obj1));
4111             if (SWIG_arg_fail(2)) SWIG_fail;
4112         }
4113     }
4114     {
4115         PyThreadState* __tstate = wxPyBeginAllowThreads();
4116         (arg1)->Maximize(arg2);
4117
4118         wxPyEndAllowThreads(__tstate);
4119         if (PyErr_Occurred()) SWIG_fail;
4120     }
4121     Py_INCREF(Py_None); resultobj = Py_None;
4122     return resultobj;
4123     fail:
4124     return NULL;
4125 }
4126
4127
4128 static PyObject *_wrap_TopLevelWindow_Restore(PyObject *, PyObject *args, PyObject *kwargs) {
4129     PyObject *resultobj;
4130     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4131     PyObject * obj0 = 0 ;
4132     char *kwnames[] = {
4133         (char *) "self", NULL
4134     };
4135
4136     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_Restore",kwnames,&obj0)) goto fail;
4137     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4138     if (SWIG_arg_fail(1)) SWIG_fail;
4139     {
4140         PyThreadState* __tstate = wxPyBeginAllowThreads();
4141         (arg1)->Restore();
4142
4143         wxPyEndAllowThreads(__tstate);
4144         if (PyErr_Occurred()) SWIG_fail;
4145     }
4146     Py_INCREF(Py_None); resultobj = Py_None;
4147     return resultobj;
4148     fail:
4149     return NULL;
4150 }
4151
4152
4153 static PyObject *_wrap_TopLevelWindow_Iconize(PyObject *, PyObject *args, PyObject *kwargs) {
4154     PyObject *resultobj;
4155     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4156     bool arg2 = (bool) true ;
4157     PyObject * obj0 = 0 ;
4158     PyObject * obj1 = 0 ;
4159     char *kwnames[] = {
4160         (char *) "self",(char *) "iconize", NULL
4161     };
4162
4163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_Iconize",kwnames,&obj0,&obj1)) goto fail;
4164     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4165     if (SWIG_arg_fail(1)) SWIG_fail;
4166     if (obj1) {
4167         {
4168             arg2 = (bool)(SWIG_As_bool(obj1));
4169             if (SWIG_arg_fail(2)) SWIG_fail;
4170         }
4171     }
4172     {
4173         PyThreadState* __tstate = wxPyBeginAllowThreads();
4174         (arg1)->Iconize(arg2);
4175
4176         wxPyEndAllowThreads(__tstate);
4177         if (PyErr_Occurred()) SWIG_fail;
4178     }
4179     Py_INCREF(Py_None); resultobj = Py_None;
4180     return resultobj;
4181     fail:
4182     return NULL;
4183 }
4184
4185
4186 static PyObject *_wrap_TopLevelWindow_IsMaximized(PyObject *, PyObject *args, PyObject *kwargs) {
4187     PyObject *resultobj;
4188     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4189     bool result;
4190     PyObject * obj0 = 0 ;
4191     char *kwnames[] = {
4192         (char *) "self", NULL
4193     };
4194
4195     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsMaximized",kwnames,&obj0)) goto fail;
4196     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4197     if (SWIG_arg_fail(1)) SWIG_fail;
4198     {
4199         PyThreadState* __tstate = wxPyBeginAllowThreads();
4200         result = (bool)((wxTopLevelWindow const *)arg1)->IsMaximized();
4201
4202         wxPyEndAllowThreads(__tstate);
4203         if (PyErr_Occurred()) SWIG_fail;
4204     }
4205     {
4206         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4207     }
4208     return resultobj;
4209     fail:
4210     return NULL;
4211 }
4212
4213
4214 static PyObject *_wrap_TopLevelWindow_IsIconized(PyObject *, PyObject *args, PyObject *kwargs) {
4215     PyObject *resultobj;
4216     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4217     bool result;
4218     PyObject * obj0 = 0 ;
4219     char *kwnames[] = {
4220         (char *) "self", NULL
4221     };
4222
4223     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsIconized",kwnames,&obj0)) goto fail;
4224     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4225     if (SWIG_arg_fail(1)) SWIG_fail;
4226     {
4227         PyThreadState* __tstate = wxPyBeginAllowThreads();
4228         result = (bool)((wxTopLevelWindow const *)arg1)->IsIconized();
4229
4230         wxPyEndAllowThreads(__tstate);
4231         if (PyErr_Occurred()) SWIG_fail;
4232     }
4233     {
4234         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4235     }
4236     return resultobj;
4237     fail:
4238     return NULL;
4239 }
4240
4241
4242 static PyObject *_wrap_TopLevelWindow_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4243     PyObject *resultobj;
4244     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4245     wxIcon result;
4246     PyObject * obj0 = 0 ;
4247     char *kwnames[] = {
4248         (char *) "self", NULL
4249     };
4250
4251     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_GetIcon",kwnames,&obj0)) goto fail;
4252     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4253     if (SWIG_arg_fail(1)) SWIG_fail;
4254     {
4255         PyThreadState* __tstate = wxPyBeginAllowThreads();
4256         result = ((wxTopLevelWindow const *)arg1)->GetIcon();
4257
4258         wxPyEndAllowThreads(__tstate);
4259         if (PyErr_Occurred()) SWIG_fail;
4260     }
4261     {
4262         wxIcon * resultptr;
4263         resultptr = new wxIcon((wxIcon &)(result));
4264         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
4265     }
4266     return resultobj;
4267     fail:
4268     return NULL;
4269 }
4270
4271
4272 static PyObject *_wrap_TopLevelWindow_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4273     PyObject *resultobj;
4274     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4275     wxIcon *arg2 = 0 ;
4276     PyObject * obj0 = 0 ;
4277     PyObject * obj1 = 0 ;
4278     char *kwnames[] = {
4279         (char *) "self",(char *) "icon", NULL
4280     };
4281
4282     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetIcon",kwnames,&obj0,&obj1)) goto fail;
4283     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4284     if (SWIG_arg_fail(1)) SWIG_fail;
4285     {
4286         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4287         if (SWIG_arg_fail(2)) SWIG_fail;
4288         if (arg2 == NULL) {
4289             SWIG_null_ref("wxIcon");
4290         }
4291         if (SWIG_arg_fail(2)) SWIG_fail;
4292     }
4293     {
4294         PyThreadState* __tstate = wxPyBeginAllowThreads();
4295         (arg1)->SetIcon((wxIcon const &)*arg2);
4296
4297         wxPyEndAllowThreads(__tstate);
4298         if (PyErr_Occurred()) SWIG_fail;
4299     }
4300     Py_INCREF(Py_None); resultobj = Py_None;
4301     return resultobj;
4302     fail:
4303     return NULL;
4304 }
4305
4306
4307 static PyObject *_wrap_TopLevelWindow_SetIcons(PyObject *, PyObject *args, PyObject *kwargs) {
4308     PyObject *resultobj;
4309     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4310     wxIconBundle *arg2 = 0 ;
4311     PyObject * obj0 = 0 ;
4312     PyObject * obj1 = 0 ;
4313     char *kwnames[] = {
4314         (char *) "self",(char *) "icons", NULL
4315     };
4316
4317     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetIcons",kwnames,&obj0,&obj1)) goto fail;
4318     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4319     if (SWIG_arg_fail(1)) SWIG_fail;
4320     {
4321         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
4322         if (SWIG_arg_fail(2)) SWIG_fail;
4323         if (arg2 == NULL) {
4324             SWIG_null_ref("wxIconBundle");
4325         }
4326         if (SWIG_arg_fail(2)) SWIG_fail;
4327     }
4328     {
4329         PyThreadState* __tstate = wxPyBeginAllowThreads();
4330         (arg1)->SetIcons((wxIconBundle const &)*arg2);
4331
4332         wxPyEndAllowThreads(__tstate);
4333         if (PyErr_Occurred()) SWIG_fail;
4334     }
4335     Py_INCREF(Py_None); resultobj = Py_None;
4336     return resultobj;
4337     fail:
4338     return NULL;
4339 }
4340
4341
4342 static PyObject *_wrap_TopLevelWindow_ShowFullScreen(PyObject *, PyObject *args, PyObject *kwargs) {
4343     PyObject *resultobj;
4344     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4345     bool arg2 ;
4346     long arg3 = (long) wxFULLSCREEN_ALL ;
4347     bool result;
4348     PyObject * obj0 = 0 ;
4349     PyObject * obj1 = 0 ;
4350     PyObject * obj2 = 0 ;
4351     char *kwnames[] = {
4352         (char *) "self",(char *) "show",(char *) "style", NULL
4353     };
4354
4355     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TopLevelWindow_ShowFullScreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
4356     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4357     if (SWIG_arg_fail(1)) SWIG_fail;
4358     {
4359         arg2 = (bool)(SWIG_As_bool(obj1));
4360         if (SWIG_arg_fail(2)) SWIG_fail;
4361     }
4362     if (obj2) {
4363         {
4364             arg3 = (long)(SWIG_As_long(obj2));
4365             if (SWIG_arg_fail(3)) SWIG_fail;
4366         }
4367     }
4368     {
4369         PyThreadState* __tstate = wxPyBeginAllowThreads();
4370         result = (bool)(arg1)->ShowFullScreen(arg2,arg3);
4371
4372         wxPyEndAllowThreads(__tstate);
4373         if (PyErr_Occurred()) SWIG_fail;
4374     }
4375     {
4376         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4377     }
4378     return resultobj;
4379     fail:
4380     return NULL;
4381 }
4382
4383
4384 static PyObject *_wrap_TopLevelWindow_IsFullScreen(PyObject *, PyObject *args, PyObject *kwargs) {
4385     PyObject *resultobj;
4386     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4387     bool result;
4388     PyObject * obj0 = 0 ;
4389     char *kwnames[] = {
4390         (char *) "self", NULL
4391     };
4392
4393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsFullScreen",kwnames,&obj0)) goto fail;
4394     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4395     if (SWIG_arg_fail(1)) SWIG_fail;
4396     {
4397         PyThreadState* __tstate = wxPyBeginAllowThreads();
4398         result = (bool)((wxTopLevelWindow const *)arg1)->IsFullScreen();
4399
4400         wxPyEndAllowThreads(__tstate);
4401         if (PyErr_Occurred()) SWIG_fail;
4402     }
4403     {
4404         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4405     }
4406     return resultobj;
4407     fail:
4408     return NULL;
4409 }
4410
4411
4412 static PyObject *_wrap_TopLevelWindow_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
4413     PyObject *resultobj;
4414     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4415     wxString *arg2 = 0 ;
4416     bool temp2 = false ;
4417     PyObject * obj0 = 0 ;
4418     PyObject * obj1 = 0 ;
4419     char *kwnames[] = {
4420         (char *) "self",(char *) "title", NULL
4421     };
4422
4423     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetTitle",kwnames,&obj0,&obj1)) goto fail;
4424     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4425     if (SWIG_arg_fail(1)) SWIG_fail;
4426     {
4427         arg2 = wxString_in_helper(obj1);
4428         if (arg2 == NULL) SWIG_fail;
4429         temp2 = true;
4430     }
4431     {
4432         PyThreadState* __tstate = wxPyBeginAllowThreads();
4433         (arg1)->SetTitle((wxString const &)*arg2);
4434
4435         wxPyEndAllowThreads(__tstate);
4436         if (PyErr_Occurred()) SWIG_fail;
4437     }
4438     Py_INCREF(Py_None); resultobj = Py_None;
4439     {
4440         if (temp2)
4441         delete arg2;
4442     }
4443     return resultobj;
4444     fail:
4445     {
4446         if (temp2)
4447         delete arg2;
4448     }
4449     return NULL;
4450 }
4451
4452
4453 static PyObject *_wrap_TopLevelWindow_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
4454     PyObject *resultobj;
4455     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4456     wxString result;
4457     PyObject * obj0 = 0 ;
4458     char *kwnames[] = {
4459         (char *) "self", NULL
4460     };
4461
4462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_GetTitle",kwnames,&obj0)) goto fail;
4463     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4464     if (SWIG_arg_fail(1)) SWIG_fail;
4465     {
4466         PyThreadState* __tstate = wxPyBeginAllowThreads();
4467         result = ((wxTopLevelWindow const *)arg1)->GetTitle();
4468
4469         wxPyEndAllowThreads(__tstate);
4470         if (PyErr_Occurred()) SWIG_fail;
4471     }
4472     {
4473 #if wxUSE_UNICODE
4474         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4475 #else
4476         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4477 #endif
4478     }
4479     return resultobj;
4480     fail:
4481     return NULL;
4482 }
4483
4484
4485 static PyObject *_wrap_TopLevelWindow_SetShape(PyObject *, PyObject *args, PyObject *kwargs) {
4486     PyObject *resultobj;
4487     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4488     wxRegion *arg2 = 0 ;
4489     bool result;
4490     PyObject * obj0 = 0 ;
4491     PyObject * obj1 = 0 ;
4492     char *kwnames[] = {
4493         (char *) "self",(char *) "region", NULL
4494     };
4495
4496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetShape",kwnames,&obj0,&obj1)) goto fail;
4497     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4498     if (SWIG_arg_fail(1)) SWIG_fail;
4499     {
4500         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
4501         if (SWIG_arg_fail(2)) SWIG_fail;
4502         if (arg2 == NULL) {
4503             SWIG_null_ref("wxRegion");
4504         }
4505         if (SWIG_arg_fail(2)) SWIG_fail;
4506     }
4507     {
4508         PyThreadState* __tstate = wxPyBeginAllowThreads();
4509         result = (bool)(arg1)->SetShape((wxRegion const &)*arg2);
4510
4511         wxPyEndAllowThreads(__tstate);
4512         if (PyErr_Occurred()) SWIG_fail;
4513     }
4514     {
4515         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4516     }
4517     return resultobj;
4518     fail:
4519     return NULL;
4520 }
4521
4522
4523 static PyObject *_wrap_TopLevelWindow_RequestUserAttention(PyObject *, PyObject *args, PyObject *kwargs) {
4524     PyObject *resultobj;
4525     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4526     int arg2 = (int) wxUSER_ATTENTION_INFO ;
4527     PyObject * obj0 = 0 ;
4528     PyObject * obj1 = 0 ;
4529     char *kwnames[] = {
4530         (char *) "self",(char *) "flags", NULL
4531     };
4532
4533     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_RequestUserAttention",kwnames,&obj0,&obj1)) goto fail;
4534     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4535     if (SWIG_arg_fail(1)) SWIG_fail;
4536     if (obj1) {
4537         {
4538             arg2 = (int)(SWIG_As_int(obj1));
4539             if (SWIG_arg_fail(2)) SWIG_fail;
4540         }
4541     }
4542     {
4543         PyThreadState* __tstate = wxPyBeginAllowThreads();
4544         (arg1)->RequestUserAttention(arg2);
4545
4546         wxPyEndAllowThreads(__tstate);
4547         if (PyErr_Occurred()) SWIG_fail;
4548     }
4549     Py_INCREF(Py_None); resultobj = Py_None;
4550     return resultobj;
4551     fail:
4552     return NULL;
4553 }
4554
4555
4556 static PyObject *_wrap_TopLevelWindow_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
4557     PyObject *resultobj;
4558     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4559     bool result;
4560     PyObject * obj0 = 0 ;
4561     char *kwnames[] = {
4562         (char *) "self", NULL
4563     };
4564
4565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsActive",kwnames,&obj0)) goto fail;
4566     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4567     if (SWIG_arg_fail(1)) SWIG_fail;
4568     {
4569         PyThreadState* __tstate = wxPyBeginAllowThreads();
4570         result = (bool)(arg1)->IsActive();
4571
4572         wxPyEndAllowThreads(__tstate);
4573         if (PyErr_Occurred()) SWIG_fail;
4574     }
4575     {
4576         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4577     }
4578     return resultobj;
4579     fail:
4580     return NULL;
4581 }
4582
4583
4584 static PyObject *_wrap_TopLevelWindow_MacSetMetalAppearance(PyObject *, PyObject *args, PyObject *kwargs) {
4585     PyObject *resultobj;
4586     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4587     bool arg2 ;
4588     PyObject * obj0 = 0 ;
4589     PyObject * obj1 = 0 ;
4590     char *kwnames[] = {
4591         (char *) "self",(char *) "on", NULL
4592     };
4593
4594     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_MacSetMetalAppearance",kwnames,&obj0,&obj1)) goto fail;
4595     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4596     if (SWIG_arg_fail(1)) SWIG_fail;
4597     {
4598         arg2 = (bool)(SWIG_As_bool(obj1));
4599         if (SWIG_arg_fail(2)) SWIG_fail;
4600     }
4601     {
4602         PyThreadState* __tstate = wxPyBeginAllowThreads();
4603         wxTopLevelWindow_MacSetMetalAppearance(arg1,arg2);
4604
4605         wxPyEndAllowThreads(__tstate);
4606         if (PyErr_Occurred()) SWIG_fail;
4607     }
4608     Py_INCREF(Py_None); resultobj = Py_None;
4609     return resultobj;
4610     fail:
4611     return NULL;
4612 }
4613
4614
4615 static PyObject *_wrap_TopLevelWindow_MacGetMetalAppearance(PyObject *, PyObject *args, PyObject *kwargs) {
4616     PyObject *resultobj;
4617     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4618     bool result;
4619     PyObject * obj0 = 0 ;
4620     char *kwnames[] = {
4621         (char *) "self", NULL
4622     };
4623
4624     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_MacGetMetalAppearance",kwnames,&obj0)) goto fail;
4625     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4626     if (SWIG_arg_fail(1)) SWIG_fail;
4627     {
4628         PyThreadState* __tstate = wxPyBeginAllowThreads();
4629         result = (bool)wxTopLevelWindow_MacGetMetalAppearance((wxTopLevelWindow const *)arg1);
4630
4631         wxPyEndAllowThreads(__tstate);
4632         if (PyErr_Occurred()) SWIG_fail;
4633     }
4634     {
4635         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4636     }
4637     return resultobj;
4638     fail:
4639     return NULL;
4640 }
4641
4642
4643 static PyObject * TopLevelWindow_swigregister(PyObject *, PyObject *args) {
4644     PyObject *obj;
4645     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4646     SWIG_TypeClientData(SWIGTYPE_p_wxTopLevelWindow, obj);
4647     Py_INCREF(obj);
4648     return Py_BuildValue((char *)"");
4649 }
4650 static PyObject *_wrap_new_Frame(PyObject *, PyObject *args, PyObject *kwargs) {
4651     PyObject *resultobj;
4652     wxWindow *arg1 = (wxWindow *) 0 ;
4653     int arg2 = (int) (int)-1 ;
4654     wxString const &arg3_defvalue = wxPyEmptyString ;
4655     wxString *arg3 = (wxString *) &arg3_defvalue ;
4656     wxPoint const &arg4_defvalue = wxDefaultPosition ;
4657     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4658     wxSize const &arg5_defvalue = wxDefaultSize ;
4659     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
4660     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
4661     wxString const &arg7_defvalue = wxPyFrameNameStr ;
4662     wxString *arg7 = (wxString *) &arg7_defvalue ;
4663     wxFrame *result;
4664     bool temp3 = false ;
4665     wxPoint temp4 ;
4666     wxSize temp5 ;
4667     bool temp7 = false ;
4668     PyObject * obj0 = 0 ;
4669     PyObject * obj1 = 0 ;
4670     PyObject * obj2 = 0 ;
4671     PyObject * obj3 = 0 ;
4672     PyObject * obj4 = 0 ;
4673     PyObject * obj5 = 0 ;
4674     PyObject * obj6 = 0 ;
4675     char *kwnames[] = {
4676         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
4677     };
4678
4679     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Frame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4680     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4681     if (SWIG_arg_fail(1)) SWIG_fail;
4682     if (obj1) {
4683         {
4684             arg2 = (int const)(SWIG_As_int(obj1));
4685             if (SWIG_arg_fail(2)) SWIG_fail;
4686         }
4687     }
4688     if (obj2) {
4689         {
4690             arg3 = wxString_in_helper(obj2);
4691             if (arg3 == NULL) SWIG_fail;
4692             temp3 = true;
4693         }
4694     }
4695     if (obj3) {
4696         {
4697             arg4 = &temp4;
4698             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4699         }
4700     }
4701     if (obj4) {
4702         {
4703             arg5 = &temp5;
4704             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
4705         }
4706     }
4707     if (obj5) {
4708         {
4709             arg6 = (long)(SWIG_As_long(obj5));
4710             if (SWIG_arg_fail(6)) SWIG_fail;
4711         }
4712     }
4713     if (obj6) {
4714         {
4715             arg7 = wxString_in_helper(obj6);
4716             if (arg7 == NULL) SWIG_fail;
4717             temp7 = true;
4718         }
4719     }
4720     {
4721         if (!wxPyCheckForApp()) SWIG_fail;
4722         PyThreadState* __tstate = wxPyBeginAllowThreads();
4723         result = (wxFrame *)new wxFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
4724
4725         wxPyEndAllowThreads(__tstate);
4726         if (PyErr_Occurred()) SWIG_fail;
4727     }
4728     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFrame, 1);
4729     {
4730         if (temp3)
4731         delete arg3;
4732     }
4733     {
4734         if (temp7)
4735         delete arg7;
4736     }
4737     return resultobj;
4738     fail:
4739     {
4740         if (temp3)
4741         delete arg3;
4742     }
4743     {
4744         if (temp7)
4745         delete arg7;
4746     }
4747     return NULL;
4748 }
4749
4750
4751 static PyObject *_wrap_new_PreFrame(PyObject *, PyObject *args, PyObject *kwargs) {
4752     PyObject *resultobj;
4753     wxFrame *result;
4754     char *kwnames[] = {
4755         NULL
4756     };
4757
4758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreFrame",kwnames)) goto fail;
4759     {
4760         if (!wxPyCheckForApp()) SWIG_fail;
4761         PyThreadState* __tstate = wxPyBeginAllowThreads();
4762         result = (wxFrame *)new wxFrame();
4763
4764         wxPyEndAllowThreads(__tstate);
4765         if (PyErr_Occurred()) SWIG_fail;
4766     }
4767     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFrame, 1);
4768     return resultobj;
4769     fail:
4770     return NULL;
4771 }
4772
4773
4774 static PyObject *_wrap_Frame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
4775     PyObject *resultobj;
4776     wxFrame *arg1 = (wxFrame *) 0 ;
4777     wxWindow *arg2 = (wxWindow *) 0 ;
4778     int arg3 = (int) (int)-1 ;
4779     wxString const &arg4_defvalue = wxPyEmptyString ;
4780     wxString *arg4 = (wxString *) &arg4_defvalue ;
4781     wxPoint const &arg5_defvalue = wxDefaultPosition ;
4782     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
4783     wxSize const &arg6_defvalue = wxDefaultSize ;
4784     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
4785     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
4786     wxString const &arg8_defvalue = wxPyFrameNameStr ;
4787     wxString *arg8 = (wxString *) &arg8_defvalue ;
4788     bool result;
4789     bool temp4 = false ;
4790     wxPoint temp5 ;
4791     wxSize temp6 ;
4792     bool temp8 = false ;
4793     PyObject * obj0 = 0 ;
4794     PyObject * obj1 = 0 ;
4795     PyObject * obj2 = 0 ;
4796     PyObject * obj3 = 0 ;
4797     PyObject * obj4 = 0 ;
4798     PyObject * obj5 = 0 ;
4799     PyObject * obj6 = 0 ;
4800     PyObject * obj7 = 0 ;
4801     char *kwnames[] = {
4802         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
4803     };
4804
4805     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Frame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4806     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4807     if (SWIG_arg_fail(1)) SWIG_fail;
4808     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4809     if (SWIG_arg_fail(2)) SWIG_fail;
4810     if (obj2) {
4811         {
4812             arg3 = (int const)(SWIG_As_int(obj2));
4813             if (SWIG_arg_fail(3)) SWIG_fail;
4814         }
4815     }
4816     if (obj3) {
4817         {
4818             arg4 = wxString_in_helper(obj3);
4819             if (arg4 == NULL) SWIG_fail;
4820             temp4 = true;
4821         }
4822     }
4823     if (obj4) {
4824         {
4825             arg5 = &temp5;
4826             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
4827         }
4828     }
4829     if (obj5) {
4830         {
4831             arg6 = &temp6;
4832             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
4833         }
4834     }
4835     if (obj6) {
4836         {
4837             arg7 = (long)(SWIG_As_long(obj6));
4838             if (SWIG_arg_fail(7)) SWIG_fail;
4839         }
4840     }
4841     if (obj7) {
4842         {
4843             arg8 = wxString_in_helper(obj7);
4844             if (arg8 == NULL) SWIG_fail;
4845             temp8 = true;
4846         }
4847     }
4848     {
4849         PyThreadState* __tstate = wxPyBeginAllowThreads();
4850         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
4851
4852         wxPyEndAllowThreads(__tstate);
4853         if (PyErr_Occurred()) SWIG_fail;
4854     }
4855     {
4856         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4857     }
4858     {
4859         if (temp4)
4860         delete arg4;
4861     }
4862     {
4863         if (temp8)
4864         delete arg8;
4865     }
4866     return resultobj;
4867     fail:
4868     {
4869         if (temp4)
4870         delete arg4;
4871     }
4872     {
4873         if (temp8)
4874         delete arg8;
4875     }
4876     return NULL;
4877 }
4878
4879
4880 static PyObject *_wrap_Frame_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
4881     PyObject *resultobj;
4882     wxFrame *arg1 = (wxFrame *) 0 ;
4883     wxPoint result;
4884     PyObject * obj0 = 0 ;
4885     char *kwnames[] = {
4886         (char *) "self", NULL
4887     };
4888
4889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
4890     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4891     if (SWIG_arg_fail(1)) SWIG_fail;
4892     {
4893         PyThreadState* __tstate = wxPyBeginAllowThreads();
4894         result = ((wxFrame const *)arg1)->GetClientAreaOrigin();
4895
4896         wxPyEndAllowThreads(__tstate);
4897         if (PyErr_Occurred()) SWIG_fail;
4898     }
4899     {
4900         wxPoint * resultptr;
4901         resultptr = new wxPoint((wxPoint &)(result));
4902         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4903     }
4904     return resultobj;
4905     fail:
4906     return NULL;
4907 }
4908
4909
4910 static PyObject *_wrap_Frame_SendSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
4911     PyObject *resultobj;
4912     wxFrame *arg1 = (wxFrame *) 0 ;
4913     PyObject * obj0 = 0 ;
4914     char *kwnames[] = {
4915         (char *) "self", NULL
4916     };
4917
4918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_SendSizeEvent",kwnames,&obj0)) goto fail;
4919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4920     if (SWIG_arg_fail(1)) SWIG_fail;
4921     {
4922         PyThreadState* __tstate = wxPyBeginAllowThreads();
4923         (arg1)->SendSizeEvent();
4924
4925         wxPyEndAllowThreads(__tstate);
4926         if (PyErr_Occurred()) SWIG_fail;
4927     }
4928     Py_INCREF(Py_None); resultobj = Py_None;
4929     return resultobj;
4930     fail:
4931     return NULL;
4932 }
4933
4934
4935 static PyObject *_wrap_Frame_SetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
4936     PyObject *resultobj;
4937     wxFrame *arg1 = (wxFrame *) 0 ;
4938     wxMenuBar *arg2 = (wxMenuBar *) 0 ;
4939     PyObject * obj0 = 0 ;
4940     PyObject * obj1 = 0 ;
4941     char *kwnames[] = {
4942         (char *) "self",(char *) "menubar", NULL
4943     };
4944
4945     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetMenuBar",kwnames,&obj0,&obj1)) goto fail;
4946     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4947     if (SWIG_arg_fail(1)) SWIG_fail;
4948     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
4949     if (SWIG_arg_fail(2)) SWIG_fail;
4950     {
4951         PyThreadState* __tstate = wxPyBeginAllowThreads();
4952         (arg1)->SetMenuBar(arg2);
4953
4954         wxPyEndAllowThreads(__tstate);
4955         if (PyErr_Occurred()) SWIG_fail;
4956     }
4957     Py_INCREF(Py_None); resultobj = Py_None;
4958     return resultobj;
4959     fail:
4960     return NULL;
4961 }
4962
4963
4964 static PyObject *_wrap_Frame_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
4965     PyObject *resultobj;
4966     wxFrame *arg1 = (wxFrame *) 0 ;
4967     wxMenuBar *result;
4968     PyObject * obj0 = 0 ;
4969     char *kwnames[] = {
4970         (char *) "self", NULL
4971     };
4972
4973     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetMenuBar",kwnames,&obj0)) goto fail;
4974     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4975     if (SWIG_arg_fail(1)) SWIG_fail;
4976     {
4977         PyThreadState* __tstate = wxPyBeginAllowThreads();
4978         result = (wxMenuBar *)((wxFrame const *)arg1)->GetMenuBar();
4979
4980         wxPyEndAllowThreads(__tstate);
4981         if (PyErr_Occurred()) SWIG_fail;
4982     }
4983     {
4984         resultobj = wxPyMake_wxObject(result, 0);
4985     }
4986     return resultobj;
4987     fail:
4988     return NULL;
4989 }
4990
4991
4992 static PyObject *_wrap_Frame_ProcessCommand(PyObject *, PyObject *args, PyObject *kwargs) {
4993     PyObject *resultobj;
4994     wxFrame *arg1 = (wxFrame *) 0 ;
4995     int arg2 ;
4996     bool result;
4997     PyObject * obj0 = 0 ;
4998     PyObject * obj1 = 0 ;
4999     char *kwnames[] = {
5000         (char *) "self",(char *) "winid", NULL
5001     };
5002
5003     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_ProcessCommand",kwnames,&obj0,&obj1)) goto fail;
5004     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5005     if (SWIG_arg_fail(1)) SWIG_fail;
5006     {
5007         arg2 = (int)(SWIG_As_int(obj1));
5008         if (SWIG_arg_fail(2)) SWIG_fail;
5009     }
5010     {
5011         PyThreadState* __tstate = wxPyBeginAllowThreads();
5012         result = (bool)(arg1)->ProcessCommand(arg2);
5013
5014         wxPyEndAllowThreads(__tstate);
5015         if (PyErr_Occurred()) SWIG_fail;
5016     }
5017     {
5018         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5019     }
5020     return resultobj;
5021     fail:
5022     return NULL;
5023 }
5024
5025
5026 static PyObject *_wrap_Frame_CreateStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5027     PyObject *resultobj;
5028     wxFrame *arg1 = (wxFrame *) 0 ;
5029     int arg2 = (int) 1 ;
5030     long arg3 = (long) wxST_SIZEGRIP ;
5031     int arg4 = (int) 0 ;
5032     wxString const &arg5_defvalue = wxPyStatusLineNameStr ;
5033     wxString *arg5 = (wxString *) &arg5_defvalue ;
5034     wxStatusBar *result;
5035     bool temp5 = false ;
5036     PyObject * obj0 = 0 ;
5037     PyObject * obj1 = 0 ;
5038     PyObject * obj2 = 0 ;
5039     PyObject * obj3 = 0 ;
5040     PyObject * obj4 = 0 ;
5041     char *kwnames[] = {
5042         (char *) "self",(char *) "number",(char *) "style",(char *) "winid",(char *) "name", NULL
5043     };
5044
5045     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Frame_CreateStatusBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5046     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5047     if (SWIG_arg_fail(1)) SWIG_fail;
5048     if (obj1) {
5049         {
5050             arg2 = (int)(SWIG_As_int(obj1));
5051             if (SWIG_arg_fail(2)) SWIG_fail;
5052         }
5053     }
5054     if (obj2) {
5055         {
5056             arg3 = (long)(SWIG_As_long(obj2));
5057             if (SWIG_arg_fail(3)) SWIG_fail;
5058         }
5059     }
5060     if (obj3) {
5061         {
5062             arg4 = (int)(SWIG_As_int(obj3));
5063             if (SWIG_arg_fail(4)) SWIG_fail;
5064         }
5065     }
5066     if (obj4) {
5067         {
5068             arg5 = wxString_in_helper(obj4);
5069             if (arg5 == NULL) SWIG_fail;
5070             temp5 = true;
5071         }
5072     }
5073     {
5074         PyThreadState* __tstate = wxPyBeginAllowThreads();
5075         result = (wxStatusBar *)(arg1)->CreateStatusBar(arg2,arg3,arg4,(wxString const &)*arg5);
5076
5077         wxPyEndAllowThreads(__tstate);
5078         if (PyErr_Occurred()) SWIG_fail;
5079     }
5080     {
5081         resultobj = wxPyMake_wxObject(result, 0);
5082     }
5083     {
5084         if (temp5)
5085         delete arg5;
5086     }
5087     return resultobj;
5088     fail:
5089     {
5090         if (temp5)
5091         delete arg5;
5092     }
5093     return NULL;
5094 }
5095
5096
5097 static PyObject *_wrap_Frame_GetStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5098     PyObject *resultobj;
5099     wxFrame *arg1 = (wxFrame *) 0 ;
5100     wxStatusBar *result;
5101     PyObject * obj0 = 0 ;
5102     char *kwnames[] = {
5103         (char *) "self", NULL
5104     };
5105
5106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetStatusBar",kwnames,&obj0)) goto fail;
5107     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5108     if (SWIG_arg_fail(1)) SWIG_fail;
5109     {
5110         PyThreadState* __tstate = wxPyBeginAllowThreads();
5111         result = (wxStatusBar *)((wxFrame const *)arg1)->GetStatusBar();
5112
5113         wxPyEndAllowThreads(__tstate);
5114         if (PyErr_Occurred()) SWIG_fail;
5115     }
5116     {
5117         resultobj = wxPyMake_wxObject(result, 0);
5118     }
5119     return resultobj;
5120     fail:
5121     return NULL;
5122 }
5123
5124
5125 static PyObject *_wrap_Frame_SetStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5126     PyObject *resultobj;
5127     wxFrame *arg1 = (wxFrame *) 0 ;
5128     wxStatusBar *arg2 = (wxStatusBar *) 0 ;
5129     PyObject * obj0 = 0 ;
5130     PyObject * obj1 = 0 ;
5131     char *kwnames[] = {
5132         (char *) "self",(char *) "statBar", NULL
5133     };
5134
5135     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusBar",kwnames,&obj0,&obj1)) goto fail;
5136     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5137     if (SWIG_arg_fail(1)) SWIG_fail;
5138     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
5139     if (SWIG_arg_fail(2)) SWIG_fail;
5140     {
5141         PyThreadState* __tstate = wxPyBeginAllowThreads();
5142         (arg1)->SetStatusBar(arg2);
5143
5144         wxPyEndAllowThreads(__tstate);
5145         if (PyErr_Occurred()) SWIG_fail;
5146     }
5147     Py_INCREF(Py_None); resultobj = Py_None;
5148     return resultobj;
5149     fail:
5150     return NULL;
5151 }
5152
5153
5154 static PyObject *_wrap_Frame_SetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5155     PyObject *resultobj;
5156     wxFrame *arg1 = (wxFrame *) 0 ;
5157     wxString *arg2 = 0 ;
5158     int arg3 = (int) 0 ;
5159     bool temp2 = false ;
5160     PyObject * obj0 = 0 ;
5161     PyObject * obj1 = 0 ;
5162     PyObject * obj2 = 0 ;
5163     char *kwnames[] = {
5164         (char *) "self",(char *) "text",(char *) "number", NULL
5165     };
5166
5167     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Frame_SetStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
5168     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5169     if (SWIG_arg_fail(1)) SWIG_fail;
5170     {
5171         arg2 = wxString_in_helper(obj1);
5172         if (arg2 == NULL) SWIG_fail;
5173         temp2 = true;
5174     }
5175     if (obj2) {
5176         {
5177             arg3 = (int)(SWIG_As_int(obj2));
5178             if (SWIG_arg_fail(3)) SWIG_fail;
5179         }
5180     }
5181     {
5182         PyThreadState* __tstate = wxPyBeginAllowThreads();
5183         (arg1)->SetStatusText((wxString const &)*arg2,arg3);
5184
5185         wxPyEndAllowThreads(__tstate);
5186         if (PyErr_Occurred()) SWIG_fail;
5187     }
5188     Py_INCREF(Py_None); resultobj = Py_None;
5189     {
5190         if (temp2)
5191         delete arg2;
5192     }
5193     return resultobj;
5194     fail:
5195     {
5196         if (temp2)
5197         delete arg2;
5198     }
5199     return NULL;
5200 }
5201
5202
5203 static PyObject *_wrap_Frame_SetStatusWidths(PyObject *, PyObject *args, PyObject *kwargs) {
5204     PyObject *resultobj;
5205     wxFrame *arg1 = (wxFrame *) 0 ;
5206     int arg2 ;
5207     int *arg3 = (int *) 0 ;
5208     PyObject * obj0 = 0 ;
5209     PyObject * obj1 = 0 ;
5210     char *kwnames[] = {
5211         (char *) "self",(char *) "widths", NULL
5212     };
5213
5214     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusWidths",kwnames,&obj0,&obj1)) goto fail;
5215     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5216     if (SWIG_arg_fail(1)) SWIG_fail;
5217     {
5218         arg2 = PyList_Size(obj1);
5219         arg3 =  int_LIST_helper(obj1);
5220         if (arg3 == NULL) SWIG_fail;
5221     }
5222     {
5223         PyThreadState* __tstate = wxPyBeginAllowThreads();
5224         (arg1)->SetStatusWidths(arg2,(int const *)arg3);
5225
5226         wxPyEndAllowThreads(__tstate);
5227         if (PyErr_Occurred()) SWIG_fail;
5228     }
5229     Py_INCREF(Py_None); resultobj = Py_None;
5230     {
5231         if (arg3) delete [] arg3;
5232     }
5233     return resultobj;
5234     fail:
5235     {
5236         if (arg3) delete [] arg3;
5237     }
5238     return NULL;
5239 }
5240
5241
5242 static PyObject *_wrap_Frame_PushStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5243     PyObject *resultobj;
5244     wxFrame *arg1 = (wxFrame *) 0 ;
5245     wxString *arg2 = 0 ;
5246     int arg3 = (int) 0 ;
5247     bool temp2 = false ;
5248     PyObject * obj0 = 0 ;
5249     PyObject * obj1 = 0 ;
5250     PyObject * obj2 = 0 ;
5251     char *kwnames[] = {
5252         (char *) "self",(char *) "text",(char *) "number", NULL
5253     };
5254
5255     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Frame_PushStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
5256     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5257     if (SWIG_arg_fail(1)) SWIG_fail;
5258     {
5259         arg2 = wxString_in_helper(obj1);
5260         if (arg2 == NULL) SWIG_fail;
5261         temp2 = true;
5262     }
5263     if (obj2) {
5264         {
5265             arg3 = (int)(SWIG_As_int(obj2));
5266             if (SWIG_arg_fail(3)) SWIG_fail;
5267         }
5268     }
5269     {
5270         PyThreadState* __tstate = wxPyBeginAllowThreads();
5271         (arg1)->PushStatusText((wxString const &)*arg2,arg3);
5272
5273         wxPyEndAllowThreads(__tstate);
5274         if (PyErr_Occurred()) SWIG_fail;
5275     }
5276     Py_INCREF(Py_None); resultobj = Py_None;
5277     {
5278         if (temp2)
5279         delete arg2;
5280     }
5281     return resultobj;
5282     fail:
5283     {
5284         if (temp2)
5285         delete arg2;
5286     }
5287     return NULL;
5288 }
5289
5290
5291 static PyObject *_wrap_Frame_PopStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5292     PyObject *resultobj;
5293     wxFrame *arg1 = (wxFrame *) 0 ;
5294     int arg2 = (int) 0 ;
5295     PyObject * obj0 = 0 ;
5296     PyObject * obj1 = 0 ;
5297     char *kwnames[] = {
5298         (char *) "self",(char *) "number", NULL
5299     };
5300
5301     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Frame_PopStatusText",kwnames,&obj0,&obj1)) goto fail;
5302     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5303     if (SWIG_arg_fail(1)) SWIG_fail;
5304     if (obj1) {
5305         {
5306             arg2 = (int)(SWIG_As_int(obj1));
5307             if (SWIG_arg_fail(2)) SWIG_fail;
5308         }
5309     }
5310     {
5311         PyThreadState* __tstate = wxPyBeginAllowThreads();
5312         (arg1)->PopStatusText(arg2);
5313
5314         wxPyEndAllowThreads(__tstate);
5315         if (PyErr_Occurred()) SWIG_fail;
5316     }
5317     Py_INCREF(Py_None); resultobj = Py_None;
5318     return resultobj;
5319     fail:
5320     return NULL;
5321 }
5322
5323
5324 static PyObject *_wrap_Frame_SetStatusBarPane(PyObject *, PyObject *args, PyObject *kwargs) {
5325     PyObject *resultobj;
5326     wxFrame *arg1 = (wxFrame *) 0 ;
5327     int arg2 ;
5328     PyObject * obj0 = 0 ;
5329     PyObject * obj1 = 0 ;
5330     char *kwnames[] = {
5331         (char *) "self",(char *) "n", NULL
5332     };
5333
5334     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusBarPane",kwnames,&obj0,&obj1)) goto fail;
5335     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5336     if (SWIG_arg_fail(1)) SWIG_fail;
5337     {
5338         arg2 = (int)(SWIG_As_int(obj1));
5339         if (SWIG_arg_fail(2)) SWIG_fail;
5340     }
5341     {
5342         PyThreadState* __tstate = wxPyBeginAllowThreads();
5343         (arg1)->SetStatusBarPane(arg2);
5344
5345         wxPyEndAllowThreads(__tstate);
5346         if (PyErr_Occurred()) SWIG_fail;
5347     }
5348     Py_INCREF(Py_None); resultobj = Py_None;
5349     return resultobj;
5350     fail:
5351     return NULL;
5352 }
5353
5354
5355 static PyObject *_wrap_Frame_GetStatusBarPane(PyObject *, PyObject *args, PyObject *kwargs) {
5356     PyObject *resultobj;
5357     wxFrame *arg1 = (wxFrame *) 0 ;
5358     int result;
5359     PyObject * obj0 = 0 ;
5360     char *kwnames[] = {
5361         (char *) "self", NULL
5362     };
5363
5364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetStatusBarPane",kwnames,&obj0)) goto fail;
5365     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5366     if (SWIG_arg_fail(1)) SWIG_fail;
5367     {
5368         PyThreadState* __tstate = wxPyBeginAllowThreads();
5369         result = (int)((wxFrame const *)arg1)->GetStatusBarPane();
5370
5371         wxPyEndAllowThreads(__tstate);
5372         if (PyErr_Occurred()) SWIG_fail;
5373     }
5374     {
5375         resultobj = SWIG_From_int((int)(result));
5376     }
5377     return resultobj;
5378     fail:
5379     return NULL;
5380 }
5381
5382
5383 static PyObject *_wrap_Frame_CreateToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5384     PyObject *resultobj;
5385     wxFrame *arg1 = (wxFrame *) 0 ;
5386     long arg2 = (long) -1 ;
5387     int arg3 = (int) -1 ;
5388     wxString const &arg4_defvalue = wxPyToolBarNameStr ;
5389     wxString *arg4 = (wxString *) &arg4_defvalue ;
5390     wxToolBar *result;
5391     bool temp4 = false ;
5392     PyObject * obj0 = 0 ;
5393     PyObject * obj1 = 0 ;
5394     PyObject * obj2 = 0 ;
5395     PyObject * obj3 = 0 ;
5396     char *kwnames[] = {
5397         (char *) "self",(char *) "style",(char *) "winid",(char *) "name", NULL
5398     };
5399
5400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Frame_CreateToolBar",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5401     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5402     if (SWIG_arg_fail(1)) SWIG_fail;
5403     if (obj1) {
5404         {
5405             arg2 = (long)(SWIG_As_long(obj1));
5406             if (SWIG_arg_fail(2)) SWIG_fail;
5407         }
5408     }
5409     if (obj2) {
5410         {
5411             arg3 = (int)(SWIG_As_int(obj2));
5412             if (SWIG_arg_fail(3)) SWIG_fail;
5413         }
5414     }
5415     if (obj3) {
5416         {
5417             arg4 = wxString_in_helper(obj3);
5418             if (arg4 == NULL) SWIG_fail;
5419             temp4 = true;
5420         }
5421     }
5422     {
5423         PyThreadState* __tstate = wxPyBeginAllowThreads();
5424         result = (wxToolBar *)(arg1)->CreateToolBar(arg2,arg3,(wxString const &)*arg4);
5425
5426         wxPyEndAllowThreads(__tstate);
5427         if (PyErr_Occurred()) SWIG_fail;
5428     }
5429     {
5430         resultobj = wxPyMake_wxObject(result, 0);
5431     }
5432     {
5433         if (temp4)
5434         delete arg4;
5435     }
5436     return resultobj;
5437     fail:
5438     {
5439         if (temp4)
5440         delete arg4;
5441     }
5442     return NULL;
5443 }
5444
5445
5446 static PyObject *_wrap_Frame_GetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5447     PyObject *resultobj;
5448     wxFrame *arg1 = (wxFrame *) 0 ;
5449     wxToolBar *result;
5450     PyObject * obj0 = 0 ;
5451     char *kwnames[] = {
5452         (char *) "self", NULL
5453     };
5454
5455     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetToolBar",kwnames,&obj0)) goto fail;
5456     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5457     if (SWIG_arg_fail(1)) SWIG_fail;
5458     {
5459         PyThreadState* __tstate = wxPyBeginAllowThreads();
5460         result = (wxToolBar *)((wxFrame const *)arg1)->GetToolBar();
5461
5462         wxPyEndAllowThreads(__tstate);
5463         if (PyErr_Occurred()) SWIG_fail;
5464     }
5465     {
5466         resultobj = wxPyMake_wxObject(result, 0);
5467     }
5468     return resultobj;
5469     fail:
5470     return NULL;
5471 }
5472
5473
5474 static PyObject *_wrap_Frame_SetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5475     PyObject *resultobj;
5476     wxFrame *arg1 = (wxFrame *) 0 ;
5477     wxToolBar *arg2 = (wxToolBar *) 0 ;
5478     PyObject * obj0 = 0 ;
5479     PyObject * obj1 = 0 ;
5480     char *kwnames[] = {
5481         (char *) "self",(char *) "toolbar", NULL
5482     };
5483
5484     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetToolBar",kwnames,&obj0,&obj1)) goto fail;
5485     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5486     if (SWIG_arg_fail(1)) SWIG_fail;
5487     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolBar, SWIG_POINTER_EXCEPTION | 0);
5488     if (SWIG_arg_fail(2)) SWIG_fail;
5489     {
5490         PyThreadState* __tstate = wxPyBeginAllowThreads();
5491         (arg1)->SetToolBar(arg2);
5492
5493         wxPyEndAllowThreads(__tstate);
5494         if (PyErr_Occurred()) SWIG_fail;
5495     }
5496     Py_INCREF(Py_None); resultobj = Py_None;
5497     return resultobj;
5498     fail:
5499     return NULL;
5500 }
5501
5502
5503 static PyObject *_wrap_Frame_DoGiveHelp(PyObject *, PyObject *args, PyObject *kwargs) {
5504     PyObject *resultobj;
5505     wxFrame *arg1 = (wxFrame *) 0 ;
5506     wxString *arg2 = 0 ;
5507     bool arg3 ;
5508     bool temp2 = false ;
5509     PyObject * obj0 = 0 ;
5510     PyObject * obj1 = 0 ;
5511     PyObject * obj2 = 0 ;
5512     char *kwnames[] = {
5513         (char *) "self",(char *) "text",(char *) "show", NULL
5514     };
5515
5516     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Frame_DoGiveHelp",kwnames,&obj0,&obj1,&obj2)) goto fail;
5517     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5518     if (SWIG_arg_fail(1)) SWIG_fail;
5519     {
5520         arg2 = wxString_in_helper(obj1);
5521         if (arg2 == NULL) SWIG_fail;
5522         temp2 = true;
5523     }
5524     {
5525         arg3 = (bool)(SWIG_As_bool(obj2));
5526         if (SWIG_arg_fail(3)) SWIG_fail;
5527     }
5528     {
5529         PyThreadState* __tstate = wxPyBeginAllowThreads();
5530         (arg1)->DoGiveHelp((wxString const &)*arg2,arg3);
5531
5532         wxPyEndAllowThreads(__tstate);
5533         if (PyErr_Occurred()) SWIG_fail;
5534     }
5535     Py_INCREF(Py_None); resultobj = Py_None;
5536     {
5537         if (temp2)
5538         delete arg2;
5539     }
5540     return resultobj;
5541     fail:
5542     {
5543         if (temp2)
5544         delete arg2;
5545     }
5546     return NULL;
5547 }
5548
5549
5550 static PyObject *_wrap_Frame_DoMenuUpdates(PyObject *, PyObject *args, PyObject *kwargs) {
5551     PyObject *resultobj;
5552     wxFrame *arg1 = (wxFrame *) 0 ;
5553     wxMenu *arg2 = (wxMenu *) NULL ;
5554     PyObject * obj0 = 0 ;
5555     PyObject * obj1 = 0 ;
5556     char *kwnames[] = {
5557         (char *) "self",(char *) "menu", NULL
5558     };
5559
5560     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Frame_DoMenuUpdates",kwnames,&obj0,&obj1)) goto fail;
5561     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5562     if (SWIG_arg_fail(1)) SWIG_fail;
5563     if (obj1) {
5564         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
5565         if (SWIG_arg_fail(2)) SWIG_fail;
5566     }
5567     {
5568         PyThreadState* __tstate = wxPyBeginAllowThreads();
5569         (arg1)->DoMenuUpdates(arg2);
5570
5571         wxPyEndAllowThreads(__tstate);
5572         if (PyErr_Occurred()) SWIG_fail;
5573     }
5574     Py_INCREF(Py_None); resultobj = Py_None;
5575     return resultobj;
5576     fail:
5577     return NULL;
5578 }
5579
5580
5581 static PyObject *_wrap_Frame_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
5582     PyObject *resultobj;
5583     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
5584     wxVisualAttributes result;
5585     PyObject * obj0 = 0 ;
5586     char *kwnames[] = {
5587         (char *) "variant", NULL
5588     };
5589
5590     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Frame_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
5591     if (obj0) {
5592         {
5593             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
5594             if (SWIG_arg_fail(1)) SWIG_fail;
5595         }
5596     }
5597     {
5598         if (!wxPyCheckForApp()) SWIG_fail;
5599         PyThreadState* __tstate = wxPyBeginAllowThreads();
5600         result = wxFrame::GetClassDefaultAttributes((wxWindowVariant )arg1);
5601
5602         wxPyEndAllowThreads(__tstate);
5603         if (PyErr_Occurred()) SWIG_fail;
5604     }
5605     {
5606         wxVisualAttributes * resultptr;
5607         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
5608         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
5609     }
5610     return resultobj;
5611     fail:
5612     return NULL;
5613 }
5614
5615
5616 static PyObject * Frame_swigregister(PyObject *, PyObject *args) {
5617     PyObject *obj;
5618     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5619     SWIG_TypeClientData(SWIGTYPE_p_wxFrame, obj);
5620     Py_INCREF(obj);
5621     return Py_BuildValue((char *)"");
5622 }
5623 static PyObject *_wrap_new_Dialog(PyObject *, PyObject *args, PyObject *kwargs) {
5624     PyObject *resultobj;
5625     wxWindow *arg1 = (wxWindow *) 0 ;
5626     int arg2 = (int) (int)-1 ;
5627     wxString const &arg3_defvalue = wxPyEmptyString ;
5628     wxString *arg3 = (wxString *) &arg3_defvalue ;
5629     wxPoint const &arg4_defvalue = wxDefaultPosition ;
5630     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5631     wxSize const &arg5_defvalue = wxDefaultSize ;
5632     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
5633     long arg6 = (long) wxDEFAULT_DIALOG_STYLE ;
5634     wxString const &arg7_defvalue = wxPyDialogNameStr ;
5635     wxString *arg7 = (wxString *) &arg7_defvalue ;
5636     wxDialog *result;
5637     bool temp3 = false ;
5638     wxPoint temp4 ;
5639     wxSize temp5 ;
5640     bool temp7 = false ;
5641     PyObject * obj0 = 0 ;
5642     PyObject * obj1 = 0 ;
5643     PyObject * obj2 = 0 ;
5644     PyObject * obj3 = 0 ;
5645     PyObject * obj4 = 0 ;
5646     PyObject * obj5 = 0 ;
5647     PyObject * obj6 = 0 ;
5648     char *kwnames[] = {
5649         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
5650     };
5651
5652     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Dialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5653     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5654     if (SWIG_arg_fail(1)) SWIG_fail;
5655     if (obj1) {
5656         {
5657             arg2 = (int const)(SWIG_As_int(obj1));
5658             if (SWIG_arg_fail(2)) SWIG_fail;
5659         }
5660     }
5661     if (obj2) {
5662         {
5663             arg3 = wxString_in_helper(obj2);
5664             if (arg3 == NULL) SWIG_fail;
5665             temp3 = true;
5666         }
5667     }
5668     if (obj3) {
5669         {
5670             arg4 = &temp4;
5671             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5672         }
5673     }
5674     if (obj4) {
5675         {
5676             arg5 = &temp5;
5677             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
5678         }
5679     }
5680     if (obj5) {
5681         {
5682             arg6 = (long)(SWIG_As_long(obj5));
5683             if (SWIG_arg_fail(6)) SWIG_fail;
5684         }
5685     }
5686     if (obj6) {
5687         {
5688             arg7 = wxString_in_helper(obj6);
5689             if (arg7 == NULL) SWIG_fail;
5690             temp7 = true;
5691         }
5692     }
5693     {
5694         if (!wxPyCheckForApp()) SWIG_fail;
5695         PyThreadState* __tstate = wxPyBeginAllowThreads();
5696         result = (wxDialog *)new wxDialog(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
5697
5698         wxPyEndAllowThreads(__tstate);
5699         if (PyErr_Occurred()) SWIG_fail;
5700     }
5701     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDialog, 1);
5702     {
5703         if (temp3)
5704         delete arg3;
5705     }
5706     {
5707         if (temp7)
5708         delete arg7;
5709     }
5710     return resultobj;
5711     fail:
5712     {
5713         if (temp3)
5714         delete arg3;
5715     }
5716     {
5717         if (temp7)
5718         delete arg7;
5719     }
5720     return NULL;
5721 }
5722
5723
5724 static PyObject *_wrap_new_PreDialog(PyObject *, PyObject *args, PyObject *kwargs) {
5725     PyObject *resultobj;
5726     wxDialog *result;
5727     char *kwnames[] = {
5728         NULL
5729     };
5730
5731     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreDialog",kwnames)) goto fail;
5732     {
5733         if (!wxPyCheckForApp()) SWIG_fail;
5734         PyThreadState* __tstate = wxPyBeginAllowThreads();
5735         result = (wxDialog *)new wxDialog();
5736
5737         wxPyEndAllowThreads(__tstate);
5738         if (PyErr_Occurred()) SWIG_fail;
5739     }
5740     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDialog, 1);
5741     return resultobj;
5742     fail:
5743     return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_Dialog_Create(PyObject *, PyObject *args, PyObject *kwargs) {
5748     PyObject *resultobj;
5749     wxDialog *arg1 = (wxDialog *) 0 ;
5750     wxWindow *arg2 = (wxWindow *) 0 ;
5751     int arg3 = (int) (int)-1 ;
5752     wxString const &arg4_defvalue = wxPyEmptyString ;
5753     wxString *arg4 = (wxString *) &arg4_defvalue ;
5754     wxPoint const &arg5_defvalue = wxDefaultPosition ;
5755     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
5756     wxSize const &arg6_defvalue = wxDefaultSize ;
5757     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
5758     long arg7 = (long) wxDEFAULT_DIALOG_STYLE ;
5759     wxString const &arg8_defvalue = wxPyDialogNameStr ;
5760     wxString *arg8 = (wxString *) &arg8_defvalue ;
5761     bool result;
5762     bool temp4 = false ;
5763     wxPoint temp5 ;
5764     wxSize temp6 ;
5765     bool temp8 = false ;
5766     PyObject * obj0 = 0 ;
5767     PyObject * obj1 = 0 ;
5768     PyObject * obj2 = 0 ;
5769     PyObject * obj3 = 0 ;
5770     PyObject * obj4 = 0 ;
5771     PyObject * obj5 = 0 ;
5772     PyObject * obj6 = 0 ;
5773     PyObject * obj7 = 0 ;
5774     char *kwnames[] = {
5775         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
5776     };
5777
5778     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Dialog_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5779     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5780     if (SWIG_arg_fail(1)) SWIG_fail;
5781     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5782     if (SWIG_arg_fail(2)) SWIG_fail;
5783     if (obj2) {
5784         {
5785             arg3 = (int const)(SWIG_As_int(obj2));
5786             if (SWIG_arg_fail(3)) SWIG_fail;
5787         }
5788     }
5789     if (obj3) {
5790         {
5791             arg4 = wxString_in_helper(obj3);
5792             if (arg4 == NULL) SWIG_fail;
5793             temp4 = true;
5794         }
5795     }
5796     if (obj4) {
5797         {
5798             arg5 = &temp5;
5799             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
5800         }
5801     }
5802     if (obj5) {
5803         {
5804             arg6 = &temp6;
5805             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
5806         }
5807     }
5808     if (obj6) {
5809         {
5810             arg7 = (long)(SWIG_As_long(obj6));
5811             if (SWIG_arg_fail(7)) SWIG_fail;
5812         }
5813     }
5814     if (obj7) {
5815         {
5816             arg8 = wxString_in_helper(obj7);
5817             if (arg8 == NULL) SWIG_fail;
5818             temp8 = true;
5819         }
5820     }
5821     {
5822         PyThreadState* __tstate = wxPyBeginAllowThreads();
5823         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
5824
5825         wxPyEndAllowThreads(__tstate);
5826         if (PyErr_Occurred()) SWIG_fail;
5827     }
5828     {
5829         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5830     }
5831     {
5832         if (temp4)
5833         delete arg4;
5834     }
5835     {
5836         if (temp8)
5837         delete arg8;
5838     }
5839     return resultobj;
5840     fail:
5841     {
5842         if (temp4)
5843         delete arg4;
5844     }
5845     {
5846         if (temp8)
5847         delete arg8;
5848     }
5849     return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_Dialog_SetReturnCode(PyObject *, PyObject *args, PyObject *kwargs) {
5854     PyObject *resultobj;
5855     wxDialog *arg1 = (wxDialog *) 0 ;
5856     int arg2 ;
5857     PyObject * obj0 = 0 ;
5858     PyObject * obj1 = 0 ;
5859     char *kwnames[] = {
5860         (char *) "self",(char *) "returnCode", NULL
5861     };
5862
5863     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_SetReturnCode",kwnames,&obj0,&obj1)) goto fail;
5864     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5865     if (SWIG_arg_fail(1)) SWIG_fail;
5866     {
5867         arg2 = (int)(SWIG_As_int(obj1));
5868         if (SWIG_arg_fail(2)) SWIG_fail;
5869     }
5870     {
5871         PyThreadState* __tstate = wxPyBeginAllowThreads();
5872         (arg1)->SetReturnCode(arg2);
5873
5874         wxPyEndAllowThreads(__tstate);
5875         if (PyErr_Occurred()) SWIG_fail;
5876     }
5877     Py_INCREF(Py_None); resultobj = Py_None;
5878     return resultobj;
5879     fail:
5880     return NULL;
5881 }
5882
5883
5884 static PyObject *_wrap_Dialog_GetReturnCode(PyObject *, PyObject *args, PyObject *kwargs) {
5885     PyObject *resultobj;
5886     wxDialog *arg1 = (wxDialog *) 0 ;
5887     int result;
5888     PyObject * obj0 = 0 ;
5889     char *kwnames[] = {
5890         (char *) "self", NULL
5891     };
5892
5893     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_GetReturnCode",kwnames,&obj0)) goto fail;
5894     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5895     if (SWIG_arg_fail(1)) SWIG_fail;
5896     {
5897         PyThreadState* __tstate = wxPyBeginAllowThreads();
5898         result = (int)((wxDialog const *)arg1)->GetReturnCode();
5899
5900         wxPyEndAllowThreads(__tstate);
5901         if (PyErr_Occurred()) SWIG_fail;
5902     }
5903     {
5904         resultobj = SWIG_From_int((int)(result));
5905     }
5906     return resultobj;
5907     fail:
5908     return NULL;
5909 }
5910
5911
5912 static PyObject *_wrap_Dialog_CreateTextSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5913     PyObject *resultobj;
5914     wxDialog *arg1 = (wxDialog *) 0 ;
5915     wxString *arg2 = 0 ;
5916     wxSizer *result;
5917     bool temp2 = false ;
5918     PyObject * obj0 = 0 ;
5919     PyObject * obj1 = 0 ;
5920     char *kwnames[] = {
5921         (char *) "self",(char *) "message", NULL
5922     };
5923
5924     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateTextSizer",kwnames,&obj0,&obj1)) goto fail;
5925     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5926     if (SWIG_arg_fail(1)) SWIG_fail;
5927     {
5928         arg2 = wxString_in_helper(obj1);
5929         if (arg2 == NULL) SWIG_fail;
5930         temp2 = true;
5931     }
5932     {
5933         PyThreadState* __tstate = wxPyBeginAllowThreads();
5934         result = (wxSizer *)(arg1)->CreateTextSizer((wxString const &)*arg2);
5935
5936         wxPyEndAllowThreads(__tstate);
5937         if (PyErr_Occurred()) SWIG_fail;
5938     }
5939     {
5940         resultobj = wxPyMake_wxSizer(result, 0);
5941     }
5942     {
5943         if (temp2)
5944         delete arg2;
5945     }
5946     return resultobj;
5947     fail:
5948     {
5949         if (temp2)
5950         delete arg2;
5951     }
5952     return NULL;
5953 }
5954
5955
5956 static PyObject *_wrap_Dialog_CreateButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5957     PyObject *resultobj;
5958     wxDialog *arg1 = (wxDialog *) 0 ;
5959     long arg2 ;
5960     wxSizer *result;
5961     PyObject * obj0 = 0 ;
5962     PyObject * obj1 = 0 ;
5963     char *kwnames[] = {
5964         (char *) "self",(char *) "flags", NULL
5965     };
5966
5967     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateButtonSizer",kwnames,&obj0,&obj1)) goto fail;
5968     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5969     if (SWIG_arg_fail(1)) SWIG_fail;
5970     {
5971         arg2 = (long)(SWIG_As_long(obj1));
5972         if (SWIG_arg_fail(2)) SWIG_fail;
5973     }
5974     {
5975         PyThreadState* __tstate = wxPyBeginAllowThreads();
5976         result = (wxSizer *)(arg1)->CreateButtonSizer(arg2);
5977
5978         wxPyEndAllowThreads(__tstate);
5979         if (PyErr_Occurred()) SWIG_fail;
5980     }
5981     {
5982         resultobj = wxPyMake_wxSizer(result, 0);
5983     }
5984     return resultobj;
5985     fail:
5986     return NULL;
5987 }
5988
5989
5990 static PyObject *_wrap_Dialog_CreateStdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5991     PyObject *resultobj;
5992     wxDialog *arg1 = (wxDialog *) 0 ;
5993     long arg2 ;
5994     wxStdDialogButtonSizer *result;
5995     PyObject * obj0 = 0 ;
5996     PyObject * obj1 = 0 ;
5997     char *kwnames[] = {
5998         (char *) "self",(char *) "flags", NULL
5999     };
6000
6001     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateStdDialogButtonSizer",kwnames,&obj0,&obj1)) goto fail;
6002     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6003     if (SWIG_arg_fail(1)) SWIG_fail;
6004     {
6005         arg2 = (long)(SWIG_As_long(obj1));
6006         if (SWIG_arg_fail(2)) SWIG_fail;
6007     }
6008     {
6009         PyThreadState* __tstate = wxPyBeginAllowThreads();
6010         result = (wxStdDialogButtonSizer *)(arg1)->CreateStdDialogButtonSizer(arg2);
6011
6012         wxPyEndAllowThreads(__tstate);
6013         if (PyErr_Occurred()) SWIG_fail;
6014     }
6015     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 0);
6016     return resultobj;
6017     fail:
6018     return NULL;
6019 }
6020
6021
6022 static PyObject *_wrap_Dialog_IsModal(PyObject *, PyObject *args, PyObject *kwargs) {
6023     PyObject *resultobj;
6024     wxDialog *arg1 = (wxDialog *) 0 ;
6025     bool result;
6026     PyObject * obj0 = 0 ;
6027     char *kwnames[] = {
6028         (char *) "self", NULL
6029     };
6030
6031     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_IsModal",kwnames,&obj0)) goto fail;
6032     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6033     if (SWIG_arg_fail(1)) SWIG_fail;
6034     {
6035         PyThreadState* __tstate = wxPyBeginAllowThreads();
6036         result = (bool)((wxDialog const *)arg1)->IsModal();
6037
6038         wxPyEndAllowThreads(__tstate);
6039         if (PyErr_Occurred()) SWIG_fail;
6040     }
6041     {
6042         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6043     }
6044     return resultobj;
6045     fail:
6046     return NULL;
6047 }
6048
6049
6050 static PyObject *_wrap_Dialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
6051     PyObject *resultobj;
6052     wxDialog *arg1 = (wxDialog *) 0 ;
6053     int result;
6054     PyObject * obj0 = 0 ;
6055     char *kwnames[] = {
6056         (char *) "self", NULL
6057     };
6058
6059     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_ShowModal",kwnames,&obj0)) goto fail;
6060     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6061     if (SWIG_arg_fail(1)) SWIG_fail;
6062     {
6063         PyThreadState* __tstate = wxPyBeginAllowThreads();
6064         result = (int)(arg1)->ShowModal();
6065
6066         wxPyEndAllowThreads(__tstate);
6067         if (PyErr_Occurred()) SWIG_fail;
6068     }
6069     {
6070         resultobj = SWIG_From_int((int)(result));
6071     }
6072     return resultobj;
6073     fail:
6074     return NULL;
6075 }
6076
6077
6078 static PyObject *_wrap_Dialog_EndModal(PyObject *, PyObject *args, PyObject *kwargs) {
6079     PyObject *resultobj;
6080     wxDialog *arg1 = (wxDialog *) 0 ;
6081     int arg2 ;
6082     PyObject * obj0 = 0 ;
6083     PyObject * obj1 = 0 ;
6084     char *kwnames[] = {
6085         (char *) "self",(char *) "retCode", NULL
6086     };
6087
6088     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_EndModal",kwnames,&obj0,&obj1)) goto fail;
6089     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6090     if (SWIG_arg_fail(1)) SWIG_fail;
6091     {
6092         arg2 = (int)(SWIG_As_int(obj1));
6093         if (SWIG_arg_fail(2)) SWIG_fail;
6094     }
6095     {
6096         PyThreadState* __tstate = wxPyBeginAllowThreads();
6097         (arg1)->EndModal(arg2);
6098
6099         wxPyEndAllowThreads(__tstate);
6100         if (PyErr_Occurred()) SWIG_fail;
6101     }
6102     Py_INCREF(Py_None); resultobj = Py_None;
6103     return resultobj;
6104     fail:
6105     return NULL;
6106 }
6107
6108
6109 static PyObject *_wrap_Dialog_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
6110     PyObject *resultobj;
6111     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
6112     wxVisualAttributes result;
6113     PyObject * obj0 = 0 ;
6114     char *kwnames[] = {
6115         (char *) "variant", NULL
6116     };
6117
6118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Dialog_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
6119     if (obj0) {
6120         {
6121             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
6122             if (SWIG_arg_fail(1)) SWIG_fail;
6123         }
6124     }
6125     {
6126         if (!wxPyCheckForApp()) SWIG_fail;
6127         PyThreadState* __tstate = wxPyBeginAllowThreads();
6128         result = wxDialog::GetClassDefaultAttributes((wxWindowVariant )arg1);
6129
6130         wxPyEndAllowThreads(__tstate);
6131         if (PyErr_Occurred()) SWIG_fail;
6132     }
6133     {
6134         wxVisualAttributes * resultptr;
6135         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
6136         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
6137     }
6138     return resultobj;
6139     fail:
6140     return NULL;
6141 }
6142
6143
6144 static PyObject * Dialog_swigregister(PyObject *, PyObject *args) {
6145     PyObject *obj;
6146     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6147     SWIG_TypeClientData(SWIGTYPE_p_wxDialog, obj);
6148     Py_INCREF(obj);
6149     return Py_BuildValue((char *)"");
6150 }
6151 static PyObject *_wrap_new_MiniFrame(PyObject *, PyObject *args, PyObject *kwargs) {
6152     PyObject *resultobj;
6153     wxWindow *arg1 = (wxWindow *) 0 ;
6154     int arg2 = (int) (int)-1 ;
6155     wxString const &arg3_defvalue = wxPyEmptyString ;
6156     wxString *arg3 = (wxString *) &arg3_defvalue ;
6157     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6158     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6159     wxSize const &arg5_defvalue = wxDefaultSize ;
6160     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6161     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
6162     wxString const &arg7_defvalue = wxPyFrameNameStr ;
6163     wxString *arg7 = (wxString *) &arg7_defvalue ;
6164     wxMiniFrame *result;
6165     bool temp3 = false ;
6166     wxPoint temp4 ;
6167     wxSize temp5 ;
6168     bool temp7 = false ;
6169     PyObject * obj0 = 0 ;
6170     PyObject * obj1 = 0 ;
6171     PyObject * obj2 = 0 ;
6172     PyObject * obj3 = 0 ;
6173     PyObject * obj4 = 0 ;
6174     PyObject * obj5 = 0 ;
6175     PyObject * obj6 = 0 ;
6176     char *kwnames[] = {
6177         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6178     };
6179
6180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MiniFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6182     if (SWIG_arg_fail(1)) SWIG_fail;
6183     if (obj1) {
6184         {
6185             arg2 = (int const)(SWIG_As_int(obj1));
6186             if (SWIG_arg_fail(2)) SWIG_fail;
6187         }
6188     }
6189     if (obj2) {
6190         {
6191             arg3 = wxString_in_helper(obj2);
6192             if (arg3 == NULL) SWIG_fail;
6193             temp3 = true;
6194         }
6195     }
6196     if (obj3) {
6197         {
6198             arg4 = &temp4;
6199             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6200         }
6201     }
6202     if (obj4) {
6203         {
6204             arg5 = &temp5;
6205             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6206         }
6207     }
6208     if (obj5) {
6209         {
6210             arg6 = (long)(SWIG_As_long(obj5));
6211             if (SWIG_arg_fail(6)) SWIG_fail;
6212         }
6213     }
6214     if (obj6) {
6215         {
6216             arg7 = wxString_in_helper(obj6);
6217             if (arg7 == NULL) SWIG_fail;
6218             temp7 = true;
6219         }
6220     }
6221     {
6222         if (!wxPyCheckForApp()) SWIG_fail;
6223         PyThreadState* __tstate = wxPyBeginAllowThreads();
6224         result = (wxMiniFrame *)new wxMiniFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6225
6226         wxPyEndAllowThreads(__tstate);
6227         if (PyErr_Occurred()) SWIG_fail;
6228     }
6229     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMiniFrame, 1);
6230     {
6231         if (temp3)
6232         delete arg3;
6233     }
6234     {
6235         if (temp7)
6236         delete arg7;
6237     }
6238     return resultobj;
6239     fail:
6240     {
6241         if (temp3)
6242         delete arg3;
6243     }
6244     {
6245         if (temp7)
6246         delete arg7;
6247     }
6248     return NULL;
6249 }
6250
6251
6252 static PyObject *_wrap_new_PreMiniFrame(PyObject *, PyObject *args, PyObject *kwargs) {
6253     PyObject *resultobj;
6254     wxMiniFrame *result;
6255     char *kwnames[] = {
6256         NULL
6257     };
6258
6259     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMiniFrame",kwnames)) goto fail;
6260     {
6261         if (!wxPyCheckForApp()) SWIG_fail;
6262         PyThreadState* __tstate = wxPyBeginAllowThreads();
6263         result = (wxMiniFrame *)new wxMiniFrame();
6264
6265         wxPyEndAllowThreads(__tstate);
6266         if (PyErr_Occurred()) SWIG_fail;
6267     }
6268     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMiniFrame, 1);
6269     return resultobj;
6270     fail:
6271     return NULL;
6272 }
6273
6274
6275 static PyObject *_wrap_MiniFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6276     PyObject *resultobj;
6277     wxMiniFrame *arg1 = (wxMiniFrame *) 0 ;
6278     wxWindow *arg2 = (wxWindow *) 0 ;
6279     int arg3 = (int) (int)-1 ;
6280     wxString const &arg4_defvalue = wxPyEmptyString ;
6281     wxString *arg4 = (wxString *) &arg4_defvalue ;
6282     wxPoint const &arg5_defvalue = wxDefaultPosition ;
6283     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
6284     wxSize const &arg6_defvalue = wxDefaultSize ;
6285     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
6286     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
6287     wxString const &arg8_defvalue = wxPyFrameNameStr ;
6288     wxString *arg8 = (wxString *) &arg8_defvalue ;
6289     bool result;
6290     bool temp4 = false ;
6291     wxPoint temp5 ;
6292     wxSize temp6 ;
6293     bool temp8 = false ;
6294     PyObject * obj0 = 0 ;
6295     PyObject * obj1 = 0 ;
6296     PyObject * obj2 = 0 ;
6297     PyObject * obj3 = 0 ;
6298     PyObject * obj4 = 0 ;
6299     PyObject * obj5 = 0 ;
6300     PyObject * obj6 = 0 ;
6301     PyObject * obj7 = 0 ;
6302     char *kwnames[] = {
6303         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6304     };
6305
6306     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MiniFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6307     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMiniFrame, SWIG_POINTER_EXCEPTION | 0);
6308     if (SWIG_arg_fail(1)) SWIG_fail;
6309     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6310     if (SWIG_arg_fail(2)) SWIG_fail;
6311     if (obj2) {
6312         {
6313             arg3 = (int const)(SWIG_As_int(obj2));
6314             if (SWIG_arg_fail(3)) SWIG_fail;
6315         }
6316     }
6317     if (obj3) {
6318         {
6319             arg4 = wxString_in_helper(obj3);
6320             if (arg4 == NULL) SWIG_fail;
6321             temp4 = true;
6322         }
6323     }
6324     if (obj4) {
6325         {
6326             arg5 = &temp5;
6327             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
6328         }
6329     }
6330     if (obj5) {
6331         {
6332             arg6 = &temp6;
6333             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
6334         }
6335     }
6336     if (obj6) {
6337         {
6338             arg7 = (long)(SWIG_As_long(obj6));
6339             if (SWIG_arg_fail(7)) SWIG_fail;
6340         }
6341     }
6342     if (obj7) {
6343         {
6344             arg8 = wxString_in_helper(obj7);
6345             if (arg8 == NULL) SWIG_fail;
6346             temp8 = true;
6347         }
6348     }
6349     {
6350         PyThreadState* __tstate = wxPyBeginAllowThreads();
6351         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
6352
6353         wxPyEndAllowThreads(__tstate);
6354         if (PyErr_Occurred()) SWIG_fail;
6355     }
6356     {
6357         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6358     }
6359     {
6360         if (temp4)
6361         delete arg4;
6362     }
6363     {
6364         if (temp8)
6365         delete arg8;
6366     }
6367     return resultobj;
6368     fail:
6369     {
6370         if (temp4)
6371         delete arg4;
6372     }
6373     {
6374         if (temp8)
6375         delete arg8;
6376     }
6377     return NULL;
6378 }
6379
6380
6381 static PyObject * MiniFrame_swigregister(PyObject *, PyObject *args) {
6382     PyObject *obj;
6383     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6384     SWIG_TypeClientData(SWIGTYPE_p_wxMiniFrame, obj);
6385     Py_INCREF(obj);
6386     return Py_BuildValue((char *)"");
6387 }
6388 static PyObject *_wrap_new_SplashScreenWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6389     PyObject *resultobj;
6390     wxBitmap *arg1 = 0 ;
6391     wxWindow *arg2 = (wxWindow *) 0 ;
6392     int arg3 ;
6393     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6394     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6395     wxSize const &arg5_defvalue = wxDefaultSize ;
6396     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6397     long arg6 = (long) wxNO_BORDER ;
6398     wxSplashScreenWindow *result;
6399     wxPoint temp4 ;
6400     wxSize temp5 ;
6401     PyObject * obj0 = 0 ;
6402     PyObject * obj1 = 0 ;
6403     PyObject * obj2 = 0 ;
6404     PyObject * obj3 = 0 ;
6405     PyObject * obj4 = 0 ;
6406     PyObject * obj5 = 0 ;
6407     char *kwnames[] = {
6408         (char *) "bitmap",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
6409     };
6410
6411     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:new_SplashScreenWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
6412     {
6413         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6414         if (SWIG_arg_fail(1)) SWIG_fail;
6415         if (arg1 == NULL) {
6416             SWIG_null_ref("wxBitmap");
6417         }
6418         if (SWIG_arg_fail(1)) SWIG_fail;
6419     }
6420     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6421     if (SWIG_arg_fail(2)) SWIG_fail;
6422     {
6423         arg3 = (int)(SWIG_As_int(obj2));
6424         if (SWIG_arg_fail(3)) SWIG_fail;
6425     }
6426     if (obj3) {
6427         {
6428             arg4 = &temp4;
6429             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6430         }
6431     }
6432     if (obj4) {
6433         {
6434             arg5 = &temp5;
6435             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6436         }
6437     }
6438     if (obj5) {
6439         {
6440             arg6 = (long)(SWIG_As_long(obj5));
6441             if (SWIG_arg_fail(6)) SWIG_fail;
6442         }
6443     }
6444     {
6445         if (!wxPyCheckForApp()) SWIG_fail;
6446         PyThreadState* __tstate = wxPyBeginAllowThreads();
6447         result = (wxSplashScreenWindow *)new wxSplashScreenWindow((wxBitmap const &)*arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6);
6448
6449         wxPyEndAllowThreads(__tstate);
6450         if (PyErr_Occurred()) SWIG_fail;
6451     }
6452     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreenWindow, 1);
6453     return resultobj;
6454     fail:
6455     return NULL;
6456 }
6457
6458
6459 static PyObject *_wrap_SplashScreenWindow_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6460     PyObject *resultobj;
6461     wxSplashScreenWindow *arg1 = (wxSplashScreenWindow *) 0 ;
6462     wxBitmap *arg2 = 0 ;
6463     PyObject * obj0 = 0 ;
6464     PyObject * obj1 = 0 ;
6465     char *kwnames[] = {
6466         (char *) "self",(char *) "bitmap", NULL
6467     };
6468
6469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplashScreenWindow_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
6470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreenWindow, SWIG_POINTER_EXCEPTION | 0);
6471     if (SWIG_arg_fail(1)) SWIG_fail;
6472     {
6473         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6474         if (SWIG_arg_fail(2)) SWIG_fail;
6475         if (arg2 == NULL) {
6476             SWIG_null_ref("wxBitmap");
6477         }
6478         if (SWIG_arg_fail(2)) SWIG_fail;
6479     }
6480     {
6481         PyThreadState* __tstate = wxPyBeginAllowThreads();
6482         (arg1)->SetBitmap((wxBitmap const &)*arg2);
6483
6484         wxPyEndAllowThreads(__tstate);
6485         if (PyErr_Occurred()) SWIG_fail;
6486     }
6487     Py_INCREF(Py_None); resultobj = Py_None;
6488     return resultobj;
6489     fail:
6490     return NULL;
6491 }
6492
6493
6494 static PyObject *_wrap_SplashScreenWindow_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6495     PyObject *resultobj;
6496     wxSplashScreenWindow *arg1 = (wxSplashScreenWindow *) 0 ;
6497     wxBitmap *result;
6498     PyObject * obj0 = 0 ;
6499     char *kwnames[] = {
6500         (char *) "self", NULL
6501     };
6502
6503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreenWindow_GetBitmap",kwnames,&obj0)) goto fail;
6504     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreenWindow, SWIG_POINTER_EXCEPTION | 0);
6505     if (SWIG_arg_fail(1)) SWIG_fail;
6506     {
6507         PyThreadState* __tstate = wxPyBeginAllowThreads();
6508         {
6509             wxBitmap &_result_ref = (arg1)->GetBitmap();
6510             result = (wxBitmap *) &_result_ref;
6511         }
6512
6513         wxPyEndAllowThreads(__tstate);
6514         if (PyErr_Occurred()) SWIG_fail;
6515     }
6516     {
6517         wxBitmap* resultptr = new wxBitmap(*result);
6518         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
6519     }
6520     return resultobj;
6521     fail:
6522     return NULL;
6523 }
6524
6525
6526 static PyObject * SplashScreenWindow_swigregister(PyObject *, PyObject *args) {
6527     PyObject *obj;
6528     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6529     SWIG_TypeClientData(SWIGTYPE_p_wxSplashScreenWindow, obj);
6530     Py_INCREF(obj);
6531     return Py_BuildValue((char *)"");
6532 }
6533 static PyObject *_wrap_new_SplashScreen(PyObject *, PyObject *args, PyObject *kwargs) {
6534     PyObject *resultobj;
6535     wxBitmap *arg1 = 0 ;
6536     long arg2 ;
6537     int arg3 ;
6538     wxWindow *arg4 = (wxWindow *) 0 ;
6539     int arg5 = (int) -1 ;
6540     wxPoint const &arg6_defvalue = wxDefaultPosition ;
6541     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
6542     wxSize const &arg7_defvalue = wxDefaultSize ;
6543     wxSize *arg7 = (wxSize *) &arg7_defvalue ;
6544     long arg8 = (long) wxSIMPLE_BORDER|wxFRAME_NO_TASKBAR|wxSTAY_ON_TOP ;
6545     wxSplashScreen *result;
6546     wxPoint temp6 ;
6547     wxSize temp7 ;
6548     PyObject * obj0 = 0 ;
6549     PyObject * obj1 = 0 ;
6550     PyObject * obj2 = 0 ;
6551     PyObject * obj3 = 0 ;
6552     PyObject * obj4 = 0 ;
6553     PyObject * obj5 = 0 ;
6554     PyObject * obj6 = 0 ;
6555     PyObject * obj7 = 0 ;
6556     char *kwnames[] = {
6557         (char *) "bitmap",(char *) "splashStyle",(char *) "milliseconds",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
6558     };
6559
6560     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:new_SplashScreen",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6561     {
6562         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6563         if (SWIG_arg_fail(1)) SWIG_fail;
6564         if (arg1 == NULL) {
6565             SWIG_null_ref("wxBitmap");
6566         }
6567         if (SWIG_arg_fail(1)) SWIG_fail;
6568     }
6569     {
6570         arg2 = (long)(SWIG_As_long(obj1));
6571         if (SWIG_arg_fail(2)) SWIG_fail;
6572     }
6573     {
6574         arg3 = (int)(SWIG_As_int(obj2));
6575         if (SWIG_arg_fail(3)) SWIG_fail;
6576     }
6577     SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6578     if (SWIG_arg_fail(4)) SWIG_fail;
6579     if (obj4) {
6580         {
6581             arg5 = (int)(SWIG_As_int(obj4));
6582             if (SWIG_arg_fail(5)) SWIG_fail;
6583         }
6584     }
6585     if (obj5) {
6586         {
6587             arg6 = &temp6;
6588             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
6589         }
6590     }
6591     if (obj6) {
6592         {
6593             arg7 = &temp7;
6594             if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
6595         }
6596     }
6597     if (obj7) {
6598         {
6599             arg8 = (long)(SWIG_As_long(obj7));
6600             if (SWIG_arg_fail(8)) SWIG_fail;
6601         }
6602     }
6603     {
6604         if (!wxPyCheckForApp()) SWIG_fail;
6605         PyThreadState* __tstate = wxPyBeginAllowThreads();
6606         result = (wxSplashScreen *)new wxSplashScreen((wxBitmap const &)*arg1,arg2,arg3,arg4,arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8);
6607
6608         wxPyEndAllowThreads(__tstate);
6609         if (PyErr_Occurred()) SWIG_fail;
6610     }
6611     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreen, 1);
6612     return resultobj;
6613     fail:
6614     return NULL;
6615 }
6616
6617
6618 static PyObject *_wrap_SplashScreen_GetSplashStyle(PyObject *, PyObject *args, PyObject *kwargs) {
6619     PyObject *resultobj;
6620     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6621     long result;
6622     PyObject * obj0 = 0 ;
6623     char *kwnames[] = {
6624         (char *) "self", NULL
6625     };
6626
6627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetSplashStyle",kwnames,&obj0)) goto fail;
6628     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6629     if (SWIG_arg_fail(1)) SWIG_fail;
6630     {
6631         PyThreadState* __tstate = wxPyBeginAllowThreads();
6632         result = (long)((wxSplashScreen const *)arg1)->GetSplashStyle();
6633
6634         wxPyEndAllowThreads(__tstate);
6635         if (PyErr_Occurred()) SWIG_fail;
6636     }
6637     {
6638         resultobj = SWIG_From_long((long)(result));
6639     }
6640     return resultobj;
6641     fail:
6642     return NULL;
6643 }
6644
6645
6646 static PyObject *_wrap_SplashScreen_GetSplashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6647     PyObject *resultobj;
6648     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6649     wxSplashScreenWindow *result;
6650     PyObject * obj0 = 0 ;
6651     char *kwnames[] = {
6652         (char *) "self", NULL
6653     };
6654
6655     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetSplashWindow",kwnames,&obj0)) goto fail;
6656     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6657     if (SWIG_arg_fail(1)) SWIG_fail;
6658     {
6659         PyThreadState* __tstate = wxPyBeginAllowThreads();
6660         result = (wxSplashScreenWindow *)((wxSplashScreen const *)arg1)->GetSplashWindow();
6661
6662         wxPyEndAllowThreads(__tstate);
6663         if (PyErr_Occurred()) SWIG_fail;
6664     }
6665     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreenWindow, 0);
6666     return resultobj;
6667     fail:
6668     return NULL;
6669 }
6670
6671
6672 static PyObject *_wrap_SplashScreen_GetTimeout(PyObject *, PyObject *args, PyObject *kwargs) {
6673     PyObject *resultobj;
6674     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6675     int result;
6676     PyObject * obj0 = 0 ;
6677     char *kwnames[] = {
6678         (char *) "self", NULL
6679     };
6680
6681     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetTimeout",kwnames,&obj0)) goto fail;
6682     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6683     if (SWIG_arg_fail(1)) SWIG_fail;
6684     {
6685         PyThreadState* __tstate = wxPyBeginAllowThreads();
6686         result = (int)((wxSplashScreen const *)arg1)->GetTimeout();
6687
6688         wxPyEndAllowThreads(__tstate);
6689         if (PyErr_Occurred()) SWIG_fail;
6690     }
6691     {
6692         resultobj = SWIG_From_int((int)(result));
6693     }
6694     return resultobj;
6695     fail:
6696     return NULL;
6697 }
6698
6699
6700 static PyObject * SplashScreen_swigregister(PyObject *, PyObject *args) {
6701     PyObject *obj;
6702     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6703     SWIG_TypeClientData(SWIGTYPE_p_wxSplashScreen, obj);
6704     Py_INCREF(obj);
6705     return Py_BuildValue((char *)"");
6706 }
6707 static PyObject *_wrap_new_StatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
6708     PyObject *resultobj;
6709     wxWindow *arg1 = (wxWindow *) 0 ;
6710     int arg2 = (int) -1 ;
6711     long arg3 = (long) wxST_SIZEGRIP ;
6712     wxString const &arg4_defvalue = wxPyStatusLineNameStr ;
6713     wxString *arg4 = (wxString *) &arg4_defvalue ;
6714     wxStatusBar *result;
6715     bool temp4 = false ;
6716     PyObject * obj0 = 0 ;
6717     PyObject * obj1 = 0 ;
6718     PyObject * obj2 = 0 ;
6719     PyObject * obj3 = 0 ;
6720     char *kwnames[] = {
6721         (char *) "parent",(char *) "id",(char *) "style",(char *) "name", NULL
6722     };
6723
6724     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_StatusBar",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6725     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6726     if (SWIG_arg_fail(1)) SWIG_fail;
6727     if (obj1) {
6728         {
6729             arg2 = (int)(SWIG_As_int(obj1));
6730             if (SWIG_arg_fail(2)) SWIG_fail;
6731         }
6732     }
6733     if (obj2) {
6734         {
6735             arg3 = (long)(SWIG_As_long(obj2));
6736             if (SWIG_arg_fail(3)) SWIG_fail;
6737         }
6738     }
6739     if (obj3) {
6740         {
6741             arg4 = wxString_in_helper(obj3);
6742             if (arg4 == NULL) SWIG_fail;
6743             temp4 = true;
6744         }
6745     }
6746     {
6747         if (!wxPyCheckForApp()) SWIG_fail;
6748         PyThreadState* __tstate = wxPyBeginAllowThreads();
6749         result = (wxStatusBar *)new wxStatusBar(arg1,arg2,arg3,(wxString const &)*arg4);
6750
6751         wxPyEndAllowThreads(__tstate);
6752         if (PyErr_Occurred()) SWIG_fail;
6753     }
6754     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStatusBar, 1);
6755     {
6756         if (temp4)
6757         delete arg4;
6758     }
6759     return resultobj;
6760     fail:
6761     {
6762         if (temp4)
6763         delete arg4;
6764     }
6765     return NULL;
6766 }
6767
6768
6769 static PyObject *_wrap_new_PreStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
6770     PyObject *resultobj;
6771     wxStatusBar *result;
6772     char *kwnames[] = {
6773         NULL
6774     };
6775
6776     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStatusBar",kwnames)) goto fail;
6777     {
6778         if (!wxPyCheckForApp()) SWIG_fail;
6779         PyThreadState* __tstate = wxPyBeginAllowThreads();
6780         result = (wxStatusBar *)new wxStatusBar();
6781
6782         wxPyEndAllowThreads(__tstate);
6783         if (PyErr_Occurred()) SWIG_fail;
6784     }
6785     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStatusBar, 1);
6786     return resultobj;
6787     fail:
6788     return NULL;
6789 }
6790
6791
6792 static PyObject *_wrap_StatusBar_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6793     PyObject *resultobj;
6794     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6795     wxWindow *arg2 = (wxWindow *) 0 ;
6796     int arg3 = (int) -1 ;
6797     long arg4 = (long) wxST_SIZEGRIP ;
6798     wxString const &arg5_defvalue = wxPyStatusLineNameStr ;
6799     wxString *arg5 = (wxString *) &arg5_defvalue ;
6800     bool result;
6801     bool temp5 = false ;
6802     PyObject * obj0 = 0 ;
6803     PyObject * obj1 = 0 ;
6804     PyObject * obj2 = 0 ;
6805     PyObject * obj3 = 0 ;
6806     PyObject * obj4 = 0 ;
6807     char *kwnames[] = {
6808         (char *) "self",(char *) "parent",(char *) "id",(char *) "style",(char *) "name", NULL
6809     };
6810
6811     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:StatusBar_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6812     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6813     if (SWIG_arg_fail(1)) SWIG_fail;
6814     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6815     if (SWIG_arg_fail(2)) SWIG_fail;
6816     if (obj2) {
6817         {
6818             arg3 = (int)(SWIG_As_int(obj2));
6819             if (SWIG_arg_fail(3)) SWIG_fail;
6820         }
6821     }
6822     if (obj3) {
6823         {
6824             arg4 = (long)(SWIG_As_long(obj3));
6825             if (SWIG_arg_fail(4)) SWIG_fail;
6826         }
6827     }
6828     if (obj4) {
6829         {
6830             arg5 = wxString_in_helper(obj4);
6831             if (arg5 == NULL) SWIG_fail;
6832             temp5 = true;
6833         }
6834     }
6835     {
6836         PyThreadState* __tstate = wxPyBeginAllowThreads();
6837         result = (bool)(arg1)->Create(arg2,arg3,arg4,(wxString const &)*arg5);
6838
6839         wxPyEndAllowThreads(__tstate);
6840         if (PyErr_Occurred()) SWIG_fail;
6841     }
6842     {
6843         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6844     }
6845     {
6846         if (temp5)
6847         delete arg5;
6848     }
6849     return resultobj;
6850     fail:
6851     {
6852         if (temp5)
6853         delete arg5;
6854     }
6855     return NULL;
6856 }
6857
6858
6859 static PyObject *_wrap_StatusBar_SetFieldsCount(PyObject *, PyObject *args, PyObject *kwargs) {
6860     PyObject *resultobj;
6861     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6862     int arg2 = (int) 1 ;
6863     PyObject * obj0 = 0 ;
6864     PyObject * obj1 = 0 ;
6865     char *kwnames[] = {
6866         (char *) "self",(char *) "number", NULL
6867     };
6868
6869     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_SetFieldsCount",kwnames,&obj0,&obj1)) goto fail;
6870     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6871     if (SWIG_arg_fail(1)) SWIG_fail;
6872     if (obj1) {
6873         {
6874             arg2 = (int)(SWIG_As_int(obj1));
6875             if (SWIG_arg_fail(2)) SWIG_fail;
6876         }
6877     }
6878     {
6879         PyThreadState* __tstate = wxPyBeginAllowThreads();
6880         (arg1)->SetFieldsCount(arg2);
6881
6882         wxPyEndAllowThreads(__tstate);
6883         if (PyErr_Occurred()) SWIG_fail;
6884     }
6885     Py_INCREF(Py_None); resultobj = Py_None;
6886     return resultobj;
6887     fail:
6888     return NULL;
6889 }
6890
6891
6892 static PyObject *_wrap_StatusBar_GetFieldsCount(PyObject *, PyObject *args, PyObject *kwargs) {
6893     PyObject *resultobj;
6894     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6895     int result;
6896     PyObject * obj0 = 0 ;
6897     char *kwnames[] = {
6898         (char *) "self", NULL
6899     };
6900
6901     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetFieldsCount",kwnames,&obj0)) goto fail;
6902     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6903     if (SWIG_arg_fail(1)) SWIG_fail;
6904     {
6905         PyThreadState* __tstate = wxPyBeginAllowThreads();
6906         result = (int)((wxStatusBar const *)arg1)->GetFieldsCount();
6907
6908         wxPyEndAllowThreads(__tstate);
6909         if (PyErr_Occurred()) SWIG_fail;
6910     }
6911     {
6912         resultobj = SWIG_From_int((int)(result));
6913     }
6914     return resultobj;
6915     fail:
6916     return NULL;
6917 }
6918
6919
6920 static PyObject *_wrap_StatusBar_SetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
6921     PyObject *resultobj;
6922     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6923     wxString *arg2 = 0 ;
6924     int arg3 = (int) 0 ;
6925     bool temp2 = false ;
6926     PyObject * obj0 = 0 ;
6927     PyObject * obj1 = 0 ;
6928     PyObject * obj2 = 0 ;
6929     char *kwnames[] = {
6930         (char *) "self",(char *) "text",(char *) "number", NULL
6931     };
6932
6933     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StatusBar_SetStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
6934     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6935     if (SWIG_arg_fail(1)) SWIG_fail;
6936     {
6937         arg2 = wxString_in_helper(obj1);
6938         if (arg2 == NULL) SWIG_fail;
6939         temp2 = true;
6940     }
6941     if (obj2) {
6942         {
6943             arg3 = (int)(SWIG_As_int(obj2));
6944             if (SWIG_arg_fail(3)) SWIG_fail;
6945         }
6946     }
6947     {
6948         PyThreadState* __tstate = wxPyBeginAllowThreads();
6949         (arg1)->SetStatusText((wxString const &)*arg2,arg3);
6950
6951         wxPyEndAllowThreads(__tstate);
6952         if (PyErr_Occurred()) SWIG_fail;
6953     }
6954     Py_INCREF(Py_None); resultobj = Py_None;
6955     {
6956         if (temp2)
6957         delete arg2;
6958     }
6959     return resultobj;
6960     fail:
6961     {
6962         if (temp2)
6963         delete arg2;
6964     }
6965     return NULL;
6966 }
6967
6968
6969 static PyObject *_wrap_StatusBar_GetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
6970     PyObject *resultobj;
6971     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6972     int arg2 = (int) 0 ;
6973     wxString result;
6974     PyObject * obj0 = 0 ;
6975     PyObject * obj1 = 0 ;
6976     char *kwnames[] = {
6977         (char *) "self",(char *) "number", NULL
6978     };
6979
6980     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_GetStatusText",kwnames,&obj0,&obj1)) goto fail;
6981     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6982     if (SWIG_arg_fail(1)) SWIG_fail;
6983     if (obj1) {
6984         {
6985             arg2 = (int)(SWIG_As_int(obj1));
6986             if (SWIG_arg_fail(2)) SWIG_fail;
6987         }
6988     }
6989     {
6990         PyThreadState* __tstate = wxPyBeginAllowThreads();
6991         result = ((wxStatusBar const *)arg1)->GetStatusText(arg2);
6992
6993         wxPyEndAllowThreads(__tstate);
6994         if (PyErr_Occurred()) SWIG_fail;
6995     }
6996     {
6997 #if wxUSE_UNICODE
6998         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6999 #else
7000         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7001 #endif
7002     }
7003     return resultobj;
7004     fail:
7005     return NULL;
7006 }
7007
7008
7009 static PyObject *_wrap_StatusBar_PushStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
7010     PyObject *resultobj;
7011     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7012     wxString *arg2 = 0 ;
7013     int arg3 = (int) 0 ;
7014     bool temp2 = false ;
7015     PyObject * obj0 = 0 ;
7016     PyObject * obj1 = 0 ;
7017     PyObject * obj2 = 0 ;
7018     char *kwnames[] = {
7019         (char *) "self",(char *) "text",(char *) "number", NULL
7020     };
7021
7022     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StatusBar_PushStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
7023     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7024     if (SWIG_arg_fail(1)) SWIG_fail;
7025     {
7026         arg2 = wxString_in_helper(obj1);
7027         if (arg2 == NULL) SWIG_fail;
7028         temp2 = true;
7029     }
7030     if (obj2) {
7031         {
7032             arg3 = (int)(SWIG_As_int(obj2));
7033             if (SWIG_arg_fail(3)) SWIG_fail;
7034         }
7035     }
7036     {
7037         PyThreadState* __tstate = wxPyBeginAllowThreads();
7038         (arg1)->PushStatusText((wxString const &)*arg2,arg3);
7039
7040         wxPyEndAllowThreads(__tstate);
7041         if (PyErr_Occurred()) SWIG_fail;
7042     }
7043     Py_INCREF(Py_None); resultobj = Py_None;
7044     {
7045         if (temp2)
7046         delete arg2;
7047     }
7048     return resultobj;
7049     fail:
7050     {
7051         if (temp2)
7052         delete arg2;
7053     }
7054     return NULL;
7055 }
7056
7057
7058 static PyObject *_wrap_StatusBar_PopStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
7059     PyObject *resultobj;
7060     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7061     int arg2 = (int) 0 ;
7062     PyObject * obj0 = 0 ;
7063     PyObject * obj1 = 0 ;
7064     char *kwnames[] = {
7065         (char *) "self",(char *) "number", NULL
7066     };
7067
7068     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_PopStatusText",kwnames,&obj0,&obj1)) goto fail;
7069     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7070     if (SWIG_arg_fail(1)) SWIG_fail;
7071     if (obj1) {
7072         {
7073             arg2 = (int)(SWIG_As_int(obj1));
7074             if (SWIG_arg_fail(2)) SWIG_fail;
7075         }
7076     }
7077     {
7078         PyThreadState* __tstate = wxPyBeginAllowThreads();
7079         (arg1)->PopStatusText(arg2);
7080
7081         wxPyEndAllowThreads(__tstate);
7082         if (PyErr_Occurred()) SWIG_fail;
7083     }
7084     Py_INCREF(Py_None); resultobj = Py_None;
7085     return resultobj;
7086     fail:
7087     return NULL;
7088 }
7089
7090
7091 static PyObject *_wrap_StatusBar_SetStatusWidths(PyObject *, PyObject *args, PyObject *kwargs) {
7092     PyObject *resultobj;
7093     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7094     int arg2 ;
7095     int *arg3 = (int *) 0 ;
7096     PyObject * obj0 = 0 ;
7097     PyObject * obj1 = 0 ;
7098     char *kwnames[] = {
7099         (char *) "self",(char *) "widths", NULL
7100     };
7101
7102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetStatusWidths",kwnames,&obj0,&obj1)) goto fail;
7103     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7104     if (SWIG_arg_fail(1)) SWIG_fail;
7105     {
7106         arg2 = PyList_Size(obj1);
7107         arg3 =  int_LIST_helper(obj1);
7108         if (arg3 == NULL) SWIG_fail;
7109     }
7110     {
7111         PyThreadState* __tstate = wxPyBeginAllowThreads();
7112         (arg1)->SetStatusWidths(arg2,(int const *)arg3);
7113
7114         wxPyEndAllowThreads(__tstate);
7115         if (PyErr_Occurred()) SWIG_fail;
7116     }
7117     Py_INCREF(Py_None); resultobj = Py_None;
7118     {
7119         if (arg3) delete [] arg3;
7120     }
7121     return resultobj;
7122     fail:
7123     {
7124         if (arg3) delete [] arg3;
7125     }
7126     return NULL;
7127 }
7128
7129
7130 static PyObject *_wrap_StatusBar_SetStatusStyles(PyObject *, PyObject *args, PyObject *kwargs) {
7131     PyObject *resultobj;
7132     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7133     int arg2 ;
7134     int *arg3 = (int *) 0 ;
7135     PyObject * obj0 = 0 ;
7136     PyObject * obj1 = 0 ;
7137     char *kwnames[] = {
7138         (char *) "self",(char *) "styles", NULL
7139     };
7140
7141     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetStatusStyles",kwnames,&obj0,&obj1)) goto fail;
7142     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7143     if (SWIG_arg_fail(1)) SWIG_fail;
7144     {
7145         arg2 = PyList_Size(obj1);
7146         arg3 =  int_LIST_helper(obj1);
7147         if (arg3 == NULL) SWIG_fail;
7148     }
7149     {
7150         PyThreadState* __tstate = wxPyBeginAllowThreads();
7151         (arg1)->SetStatusStyles(arg2,(int const *)arg3);
7152
7153         wxPyEndAllowThreads(__tstate);
7154         if (PyErr_Occurred()) SWIG_fail;
7155     }
7156     Py_INCREF(Py_None); resultobj = Py_None;
7157     {
7158         if (arg3) delete [] arg3;
7159     }
7160     return resultobj;
7161     fail:
7162     {
7163         if (arg3) delete [] arg3;
7164     }
7165     return NULL;
7166 }
7167
7168
7169 static PyObject *_wrap_StatusBar_GetFieldRect(PyObject *, PyObject *args, PyObject *kwargs) {
7170     PyObject *resultobj;
7171     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7172     int arg2 ;
7173     wxRect result;
7174     PyObject * obj0 = 0 ;
7175     PyObject * obj1 = 0 ;
7176     char *kwnames[] = {
7177         (char *) "self",(char *) "i", NULL
7178     };
7179
7180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_GetFieldRect",kwnames,&obj0,&obj1)) goto fail;
7181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7182     if (SWIG_arg_fail(1)) SWIG_fail;
7183     {
7184         arg2 = (int)(SWIG_As_int(obj1));
7185         if (SWIG_arg_fail(2)) SWIG_fail;
7186     }
7187     {
7188         PyThreadState* __tstate = wxPyBeginAllowThreads();
7189         result = wxStatusBar_GetFieldRect(arg1,arg2);
7190
7191         wxPyEndAllowThreads(__tstate);
7192         if (PyErr_Occurred()) SWIG_fail;
7193     }
7194     {
7195         wxRect * resultptr;
7196         resultptr = new wxRect((wxRect &)(result));
7197         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7198     }
7199     return resultobj;
7200     fail:
7201     return NULL;
7202 }
7203
7204
7205 static PyObject *_wrap_StatusBar_SetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7206     PyObject *resultobj;
7207     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7208     int arg2 ;
7209     PyObject * obj0 = 0 ;
7210     PyObject * obj1 = 0 ;
7211     char *kwnames[] = {
7212         (char *) "self",(char *) "height", NULL
7213     };
7214
7215     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetMinHeight",kwnames,&obj0,&obj1)) goto fail;
7216     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7217     if (SWIG_arg_fail(1)) SWIG_fail;
7218     {
7219         arg2 = (int)(SWIG_As_int(obj1));
7220         if (SWIG_arg_fail(2)) SWIG_fail;
7221     }
7222     {
7223         PyThreadState* __tstate = wxPyBeginAllowThreads();
7224         (arg1)->SetMinHeight(arg2);
7225
7226         wxPyEndAllowThreads(__tstate);
7227         if (PyErr_Occurred()) SWIG_fail;
7228     }
7229     Py_INCREF(Py_None); resultobj = Py_None;
7230     return resultobj;
7231     fail:
7232     return NULL;
7233 }
7234
7235
7236 static PyObject *_wrap_StatusBar_GetBorderX(PyObject *, PyObject *args, PyObject *kwargs) {
7237     PyObject *resultobj;
7238     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7239     int result;
7240     PyObject * obj0 = 0 ;
7241     char *kwnames[] = {
7242         (char *) "self", NULL
7243     };
7244
7245     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetBorderX",kwnames,&obj0)) goto fail;
7246     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7247     if (SWIG_arg_fail(1)) SWIG_fail;
7248     {
7249         PyThreadState* __tstate = wxPyBeginAllowThreads();
7250         result = (int)((wxStatusBar const *)arg1)->GetBorderX();
7251
7252         wxPyEndAllowThreads(__tstate);
7253         if (PyErr_Occurred()) SWIG_fail;
7254     }
7255     {
7256         resultobj = SWIG_From_int((int)(result));
7257     }
7258     return resultobj;
7259     fail:
7260     return NULL;
7261 }
7262
7263
7264 static PyObject *_wrap_StatusBar_GetBorderY(PyObject *, PyObject *args, PyObject *kwargs) {
7265     PyObject *resultobj;
7266     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7267     int result;
7268     PyObject * obj0 = 0 ;
7269     char *kwnames[] = {
7270         (char *) "self", NULL
7271     };
7272
7273     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetBorderY",kwnames,&obj0)) goto fail;
7274     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7275     if (SWIG_arg_fail(1)) SWIG_fail;
7276     {
7277         PyThreadState* __tstate = wxPyBeginAllowThreads();
7278         result = (int)((wxStatusBar const *)arg1)->GetBorderY();
7279
7280         wxPyEndAllowThreads(__tstate);
7281         if (PyErr_Occurred()) SWIG_fail;
7282     }
7283     {
7284         resultobj = SWIG_From_int((int)(result));
7285     }
7286     return resultobj;
7287     fail:
7288     return NULL;
7289 }
7290
7291
7292 static PyObject *_wrap_StatusBar_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7293     PyObject *resultobj;
7294     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
7295     wxVisualAttributes result;
7296     PyObject * obj0 = 0 ;
7297     char *kwnames[] = {
7298         (char *) "variant", NULL
7299     };
7300
7301     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StatusBar_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
7302     if (obj0) {
7303         {
7304             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
7305             if (SWIG_arg_fail(1)) SWIG_fail;
7306         }
7307     }
7308     {
7309         if (!wxPyCheckForApp()) SWIG_fail;
7310         PyThreadState* __tstate = wxPyBeginAllowThreads();
7311         result = wxStatusBar::GetClassDefaultAttributes((wxWindowVariant )arg1);
7312
7313         wxPyEndAllowThreads(__tstate);
7314         if (PyErr_Occurred()) SWIG_fail;
7315     }
7316     {
7317         wxVisualAttributes * resultptr;
7318         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
7319         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
7320     }
7321     return resultobj;
7322     fail:
7323     return NULL;
7324 }
7325
7326
7327 static PyObject * StatusBar_swigregister(PyObject *, PyObject *args) {
7328     PyObject *obj;
7329     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7330     SWIG_TypeClientData(SWIGTYPE_p_wxStatusBar, obj);
7331     Py_INCREF(obj);
7332     return Py_BuildValue((char *)"");
7333 }
7334 static int _wrap_SplitterNameStr_set(PyObject *) {
7335     PyErr_SetString(PyExc_TypeError,"Variable SplitterNameStr is read-only.");
7336     return 1;
7337 }
7338
7339
7340 static PyObject *_wrap_SplitterNameStr_get(void) {
7341     PyObject *pyobj;
7342
7343     {
7344 #if wxUSE_UNICODE
7345         pyobj = PyUnicode_FromWideChar((&wxPySplitterNameStr)->c_str(), (&wxPySplitterNameStr)->Len());
7346 #else
7347         pyobj = PyString_FromStringAndSize((&wxPySplitterNameStr)->c_str(), (&wxPySplitterNameStr)->Len());
7348 #endif
7349     }
7350     return pyobj;
7351 }
7352
7353
7354 static PyObject *_wrap_new_SplitterWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7355     PyObject *resultobj;
7356     wxWindow *arg1 = (wxWindow *) 0 ;
7357     int arg2 = (int) -1 ;
7358     wxPoint const &arg3_defvalue = wxDefaultPosition ;
7359     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
7360     wxSize const &arg4_defvalue = wxDefaultSize ;
7361     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
7362     long arg5 = (long) wxSP_3D ;
7363     wxString const &arg6_defvalue = wxPySplitterNameStr ;
7364     wxString *arg6 = (wxString *) &arg6_defvalue ;
7365     wxSplitterWindow *result;
7366     wxPoint temp3 ;
7367     wxSize temp4 ;
7368     bool temp6 = false ;
7369     PyObject * obj0 = 0 ;
7370     PyObject * obj1 = 0 ;
7371     PyObject * obj2 = 0 ;
7372     PyObject * obj3 = 0 ;
7373     PyObject * obj4 = 0 ;
7374     PyObject * obj5 = 0 ;
7375     char *kwnames[] = {
7376         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
7377     };
7378
7379     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SplitterWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
7380     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7381     if (SWIG_arg_fail(1)) SWIG_fail;
7382     if (obj1) {
7383         {
7384             arg2 = (int)(SWIG_As_int(obj1));
7385             if (SWIG_arg_fail(2)) SWIG_fail;
7386         }
7387     }
7388     if (obj2) {
7389         {
7390             arg3 = &temp3;
7391             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
7392         }
7393     }
7394     if (obj3) {
7395         {
7396             arg4 = &temp4;
7397             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
7398         }
7399     }
7400     if (obj4) {
7401         {
7402             arg5 = (long)(SWIG_As_long(obj4));
7403             if (SWIG_arg_fail(5)) SWIG_fail;
7404         }
7405     }
7406     if (obj5) {
7407         {
7408             arg6 = wxString_in_helper(obj5);
7409             if (arg6 == NULL) SWIG_fail;
7410             temp6 = true;
7411         }
7412     }
7413     {
7414         if (!wxPyCheckForApp()) SWIG_fail;
7415         PyThreadState* __tstate = wxPyBeginAllowThreads();
7416         result = (wxSplitterWindow *)new wxSplitterWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
7417
7418         wxPyEndAllowThreads(__tstate);
7419         if (PyErr_Occurred()) SWIG_fail;
7420     }
7421     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterWindow, 1);
7422     {
7423         if (temp6)
7424         delete arg6;
7425     }
7426     return resultobj;
7427     fail:
7428     {
7429         if (temp6)
7430         delete arg6;
7431     }
7432     return NULL;
7433 }
7434
7435
7436 static PyObject *_wrap_new_PreSplitterWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7437     PyObject *resultobj;
7438     wxSplitterWindow *result;
7439     char *kwnames[] = {
7440         NULL
7441     };
7442
7443     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSplitterWindow",kwnames)) goto fail;
7444     {
7445         if (!wxPyCheckForApp()) SWIG_fail;
7446         PyThreadState* __tstate = wxPyBeginAllowThreads();
7447         result = (wxSplitterWindow *)new wxSplitterWindow();
7448
7449         wxPyEndAllowThreads(__tstate);
7450         if (PyErr_Occurred()) SWIG_fail;
7451     }
7452     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterWindow, 1);
7453     return resultobj;
7454     fail:
7455     return NULL;
7456 }
7457
7458
7459 static PyObject *_wrap_SplitterWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7460     PyObject *resultobj;
7461     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7462     wxWindow *arg2 = (wxWindow *) 0 ;
7463     int arg3 = (int) -1 ;
7464     wxPoint const &arg4_defvalue = wxDefaultPosition ;
7465     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
7466     wxSize const &arg5_defvalue = wxDefaultSize ;
7467     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
7468     long arg6 = (long) wxSP_3D ;
7469     wxString const &arg7_defvalue = wxPySplitterNameStr ;
7470     wxString *arg7 = (wxString *) &arg7_defvalue ;
7471     bool result;
7472     wxPoint temp4 ;
7473     wxSize temp5 ;
7474     bool temp7 = false ;
7475     PyObject * obj0 = 0 ;
7476     PyObject * obj1 = 0 ;
7477     PyObject * obj2 = 0 ;
7478     PyObject * obj3 = 0 ;
7479     PyObject * obj4 = 0 ;
7480     PyObject * obj5 = 0 ;
7481     PyObject * obj6 = 0 ;
7482     char *kwnames[] = {
7483         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
7484     };
7485
7486     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SplitterWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
7487     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7488     if (SWIG_arg_fail(1)) SWIG_fail;
7489     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7490     if (SWIG_arg_fail(2)) SWIG_fail;
7491     if (obj2) {
7492         {
7493             arg3 = (int)(SWIG_As_int(obj2));
7494             if (SWIG_arg_fail(3)) SWIG_fail;
7495         }
7496     }
7497     if (obj3) {
7498         {
7499             arg4 = &temp4;
7500             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
7501         }
7502     }
7503     if (obj4) {
7504         {
7505             arg5 = &temp5;
7506             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
7507         }
7508     }
7509     if (obj5) {
7510         {
7511             arg6 = (long)(SWIG_As_long(obj5));
7512             if (SWIG_arg_fail(6)) SWIG_fail;
7513         }
7514     }
7515     if (obj6) {
7516         {
7517             arg7 = wxString_in_helper(obj6);
7518             if (arg7 == NULL) SWIG_fail;
7519             temp7 = true;
7520         }
7521     }
7522     {
7523         PyThreadState* __tstate = wxPyBeginAllowThreads();
7524         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
7525
7526         wxPyEndAllowThreads(__tstate);
7527         if (PyErr_Occurred()) SWIG_fail;
7528     }
7529     {
7530         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7531     }
7532     {
7533         if (temp7)
7534         delete arg7;
7535     }
7536     return resultobj;
7537     fail:
7538     {
7539         if (temp7)
7540         delete arg7;
7541     }
7542     return NULL;
7543 }
7544
7545
7546 static PyObject *_wrap_SplitterWindow_GetWindow1(PyObject *, PyObject *args, PyObject *kwargs) {
7547     PyObject *resultobj;
7548     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7549     wxWindow *result;
7550     PyObject * obj0 = 0 ;
7551     char *kwnames[] = {
7552         (char *) "self", NULL
7553     };
7554
7555     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetWindow1",kwnames,&obj0)) goto fail;
7556     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7557     if (SWIG_arg_fail(1)) SWIG_fail;
7558     {
7559         PyThreadState* __tstate = wxPyBeginAllowThreads();
7560         result = (wxWindow *)((wxSplitterWindow const *)arg1)->GetWindow1();
7561
7562         wxPyEndAllowThreads(__tstate);
7563         if (PyErr_Occurred()) SWIG_fail;
7564     }
7565     {
7566         resultobj = wxPyMake_wxObject(result, 0);
7567     }
7568     return resultobj;
7569     fail:
7570     return NULL;
7571 }
7572
7573
7574 static PyObject *_wrap_SplitterWindow_GetWindow2(PyObject *, PyObject *args, PyObject *kwargs) {
7575     PyObject *resultobj;
7576     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7577     wxWindow *result;
7578     PyObject * obj0 = 0 ;
7579     char *kwnames[] = {
7580         (char *) "self", NULL
7581     };
7582
7583     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetWindow2",kwnames,&obj0)) goto fail;
7584     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7585     if (SWIG_arg_fail(1)) SWIG_fail;
7586     {
7587         PyThreadState* __tstate = wxPyBeginAllowThreads();
7588         result = (wxWindow *)((wxSplitterWindow const *)arg1)->GetWindow2();
7589
7590         wxPyEndAllowThreads(__tstate);
7591         if (PyErr_Occurred()) SWIG_fail;
7592     }
7593     {
7594         resultobj = wxPyMake_wxObject(result, 0);
7595     }
7596     return resultobj;
7597     fail:
7598     return NULL;
7599 }
7600
7601
7602 static PyObject *_wrap_SplitterWindow_SetSplitMode(PyObject *, PyObject *args, PyObject *kwargs) {
7603     PyObject *resultobj;
7604     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7605     int arg2 ;
7606     PyObject * obj0 = 0 ;
7607     PyObject * obj1 = 0 ;
7608     char *kwnames[] = {
7609         (char *) "self",(char *) "mode", NULL
7610     };
7611
7612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSplitMode",kwnames,&obj0,&obj1)) goto fail;
7613     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7614     if (SWIG_arg_fail(1)) SWIG_fail;
7615     {
7616         arg2 = (int)(SWIG_As_int(obj1));
7617         if (SWIG_arg_fail(2)) SWIG_fail;
7618     }
7619     {
7620         PyThreadState* __tstate = wxPyBeginAllowThreads();
7621         (arg1)->SetSplitMode(arg2);
7622
7623         wxPyEndAllowThreads(__tstate);
7624         if (PyErr_Occurred()) SWIG_fail;
7625     }
7626     Py_INCREF(Py_None); resultobj = Py_None;
7627     return resultobj;
7628     fail:
7629     return NULL;
7630 }
7631
7632
7633 static PyObject *_wrap_SplitterWindow_GetSplitMode(PyObject *, PyObject *args, PyObject *kwargs) {
7634     PyObject *resultobj;
7635     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7636     wxSplitMode result;
7637     PyObject * obj0 = 0 ;
7638     char *kwnames[] = {
7639         (char *) "self", NULL
7640     };
7641
7642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSplitMode",kwnames,&obj0)) goto fail;
7643     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7644     if (SWIG_arg_fail(1)) SWIG_fail;
7645     {
7646         PyThreadState* __tstate = wxPyBeginAllowThreads();
7647         result = (wxSplitMode)((wxSplitterWindow const *)arg1)->GetSplitMode();
7648
7649         wxPyEndAllowThreads(__tstate);
7650         if (PyErr_Occurred()) SWIG_fail;
7651     }
7652     resultobj = SWIG_From_int((result));
7653     return resultobj;
7654     fail:
7655     return NULL;
7656 }
7657
7658
7659 static PyObject *_wrap_SplitterWindow_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
7660     PyObject *resultobj;
7661     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7662     wxWindow *arg2 = (wxWindow *) 0 ;
7663     PyObject * obj0 = 0 ;
7664     PyObject * obj1 = 0 ;
7665     char *kwnames[] = {
7666         (char *) "self",(char *) "window", NULL
7667     };
7668
7669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_Initialize",kwnames,&obj0,&obj1)) goto fail;
7670     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7671     if (SWIG_arg_fail(1)) SWIG_fail;
7672     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7673     if (SWIG_arg_fail(2)) SWIG_fail;
7674     {
7675         PyThreadState* __tstate = wxPyBeginAllowThreads();
7676         (arg1)->Initialize(arg2);
7677
7678         wxPyEndAllowThreads(__tstate);
7679         if (PyErr_Occurred()) SWIG_fail;
7680     }
7681     Py_INCREF(Py_None); resultobj = Py_None;
7682     return resultobj;
7683     fail:
7684     return NULL;
7685 }
7686
7687
7688 static PyObject *_wrap_SplitterWindow_SplitVertically(PyObject *, PyObject *args, PyObject *kwargs) {
7689     PyObject *resultobj;
7690     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7691     wxWindow *arg2 = (wxWindow *) 0 ;
7692     wxWindow *arg3 = (wxWindow *) 0 ;
7693     int arg4 = (int) 0 ;
7694     bool result;
7695     PyObject * obj0 = 0 ;
7696     PyObject * obj1 = 0 ;
7697     PyObject * obj2 = 0 ;
7698     PyObject * obj3 = 0 ;
7699     char *kwnames[] = {
7700         (char *) "self",(char *) "window1",(char *) "window2",(char *) "sashPosition", NULL
7701     };
7702
7703     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SplitVertically",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7704     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7705     if (SWIG_arg_fail(1)) SWIG_fail;
7706     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7707     if (SWIG_arg_fail(2)) SWIG_fail;
7708     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7709     if (SWIG_arg_fail(3)) SWIG_fail;
7710     if (obj3) {
7711         {
7712             arg4 = (int)(SWIG_As_int(obj3));
7713             if (SWIG_arg_fail(4)) SWIG_fail;
7714         }
7715     }
7716     {
7717         PyThreadState* __tstate = wxPyBeginAllowThreads();
7718         result = (bool)(arg1)->SplitVertically(arg2,arg3,arg4);
7719
7720         wxPyEndAllowThreads(__tstate);
7721         if (PyErr_Occurred()) SWIG_fail;
7722     }
7723     {
7724         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7725     }
7726     return resultobj;
7727     fail:
7728     return NULL;
7729 }
7730
7731
7732 static PyObject *_wrap_SplitterWindow_SplitHorizontally(PyObject *, PyObject *args, PyObject *kwargs) {
7733     PyObject *resultobj;
7734     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7735     wxWindow *arg2 = (wxWindow *) 0 ;
7736     wxWindow *arg3 = (wxWindow *) 0 ;
7737     int arg4 = (int) 0 ;
7738     bool result;
7739     PyObject * obj0 = 0 ;
7740     PyObject * obj1 = 0 ;
7741     PyObject * obj2 = 0 ;
7742     PyObject * obj3 = 0 ;
7743     char *kwnames[] = {
7744         (char *) "self",(char *) "window1",(char *) "window2",(char *) "sashPosition", NULL
7745     };
7746
7747     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SplitHorizontally",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7748     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7749     if (SWIG_arg_fail(1)) SWIG_fail;
7750     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7751     if (SWIG_arg_fail(2)) SWIG_fail;
7752     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7753     if (SWIG_arg_fail(3)) SWIG_fail;
7754     if (obj3) {
7755         {
7756             arg4 = (int)(SWIG_As_int(obj3));
7757             if (SWIG_arg_fail(4)) SWIG_fail;
7758         }
7759     }
7760     {
7761         PyThreadState* __tstate = wxPyBeginAllowThreads();
7762         result = (bool)(arg1)->SplitHorizontally(arg2,arg3,arg4);
7763
7764         wxPyEndAllowThreads(__tstate);
7765         if (PyErr_Occurred()) SWIG_fail;
7766     }
7767     {
7768         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7769     }
7770     return resultobj;
7771     fail:
7772     return NULL;
7773 }
7774
7775
7776 static PyObject *_wrap_SplitterWindow_Unsplit(PyObject *, PyObject *args, PyObject *kwargs) {
7777     PyObject *resultobj;
7778     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7779     wxWindow *arg2 = (wxWindow *) NULL ;
7780     bool result;
7781     PyObject * obj0 = 0 ;
7782     PyObject * obj1 = 0 ;
7783     char *kwnames[] = {
7784         (char *) "self",(char *) "toRemove", NULL
7785     };
7786
7787     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SplitterWindow_Unsplit",kwnames,&obj0,&obj1)) goto fail;
7788     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7789     if (SWIG_arg_fail(1)) SWIG_fail;
7790     if (obj1) {
7791         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7792         if (SWIG_arg_fail(2)) SWIG_fail;
7793     }
7794     {
7795         PyThreadState* __tstate = wxPyBeginAllowThreads();
7796         result = (bool)(arg1)->Unsplit(arg2);
7797
7798         wxPyEndAllowThreads(__tstate);
7799         if (PyErr_Occurred()) SWIG_fail;
7800     }
7801     {
7802         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7803     }
7804     return resultobj;
7805     fail:
7806     return NULL;
7807 }
7808
7809
7810 static PyObject *_wrap_SplitterWindow_ReplaceWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7811     PyObject *resultobj;
7812     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7813     wxWindow *arg2 = (wxWindow *) 0 ;
7814     wxWindow *arg3 = (wxWindow *) 0 ;
7815     bool result;
7816     PyObject * obj0 = 0 ;
7817     PyObject * obj1 = 0 ;
7818     PyObject * obj2 = 0 ;
7819     char *kwnames[] = {
7820         (char *) "self",(char *) "winOld",(char *) "winNew", NULL
7821     };
7822
7823     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SplitterWindow_ReplaceWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
7824     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7825     if (SWIG_arg_fail(1)) SWIG_fail;
7826     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7827     if (SWIG_arg_fail(2)) SWIG_fail;
7828     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7829     if (SWIG_arg_fail(3)) SWIG_fail;
7830     {
7831         PyThreadState* __tstate = wxPyBeginAllowThreads();
7832         result = (bool)(arg1)->ReplaceWindow(arg2,arg3);
7833
7834         wxPyEndAllowThreads(__tstate);
7835         if (PyErr_Occurred()) SWIG_fail;
7836     }
7837     {
7838         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7839     }
7840     return resultobj;
7841     fail:
7842     return NULL;
7843 }
7844
7845
7846 static PyObject *_wrap_SplitterWindow_UpdateSize(PyObject *, PyObject *args, PyObject *kwargs) {
7847     PyObject *resultobj;
7848     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7849     PyObject * obj0 = 0 ;
7850     char *kwnames[] = {
7851         (char *) "self", NULL
7852     };
7853
7854     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_UpdateSize",kwnames,&obj0)) goto fail;
7855     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7856     if (SWIG_arg_fail(1)) SWIG_fail;
7857     {
7858         PyThreadState* __tstate = wxPyBeginAllowThreads();
7859         (arg1)->UpdateSize();
7860
7861         wxPyEndAllowThreads(__tstate);
7862         if (PyErr_Occurred()) SWIG_fail;
7863     }
7864     Py_INCREF(Py_None); resultobj = Py_None;
7865     return resultobj;
7866     fail:
7867     return NULL;
7868 }
7869
7870
7871 static PyObject *_wrap_SplitterWindow_IsSplit(PyObject *, PyObject *args, PyObject *kwargs) {
7872     PyObject *resultobj;
7873     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7874     bool result;
7875     PyObject * obj0 = 0 ;
7876     char *kwnames[] = {
7877         (char *) "self", NULL
7878     };
7879
7880     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_IsSplit",kwnames,&obj0)) goto fail;
7881     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7882     if (SWIG_arg_fail(1)) SWIG_fail;
7883     {
7884         PyThreadState* __tstate = wxPyBeginAllowThreads();
7885         result = (bool)((wxSplitterWindow const *)arg1)->IsSplit();
7886
7887         wxPyEndAllowThreads(__tstate);
7888         if (PyErr_Occurred()) SWIG_fail;
7889     }
7890     {
7891         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7892     }
7893     return resultobj;
7894     fail:
7895     return NULL;
7896 }
7897
7898
7899 static PyObject *_wrap_SplitterWindow_SetSashSize(PyObject *, PyObject *args, PyObject *kwargs) {
7900     PyObject *resultobj;
7901     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7902     int arg2 ;
7903     PyObject * obj0 = 0 ;
7904     PyObject * obj1 = 0 ;
7905     char *kwnames[] = {
7906         (char *) "self",(char *) "width", NULL
7907     };
7908
7909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSashSize",kwnames,&obj0,&obj1)) goto fail;
7910     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7911     if (SWIG_arg_fail(1)) SWIG_fail;
7912     {
7913         arg2 = (int)(SWIG_As_int(obj1));
7914         if (SWIG_arg_fail(2)) SWIG_fail;
7915     }
7916     {
7917         PyThreadState* __tstate = wxPyBeginAllowThreads();
7918         (arg1)->SetSashSize(arg2);
7919
7920         wxPyEndAllowThreads(__tstate);
7921         if (PyErr_Occurred()) SWIG_fail;
7922     }
7923     Py_INCREF(Py_None); resultobj = Py_None;
7924     return resultobj;
7925     fail:
7926     return NULL;
7927 }
7928
7929
7930 static PyObject *_wrap_SplitterWindow_SetBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
7931     PyObject *resultobj;
7932     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7933     int arg2 ;
7934     PyObject * obj0 = 0 ;
7935     PyObject * obj1 = 0 ;
7936     char *kwnames[] = {
7937         (char *) "self",(char *) "width", NULL
7938     };
7939
7940     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetBorderSize",kwnames,&obj0,&obj1)) goto fail;
7941     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7942     if (SWIG_arg_fail(1)) SWIG_fail;
7943     {
7944         arg2 = (int)(SWIG_As_int(obj1));
7945         if (SWIG_arg_fail(2)) SWIG_fail;
7946     }
7947     {
7948         PyThreadState* __tstate = wxPyBeginAllowThreads();
7949         (arg1)->SetBorderSize(arg2);
7950
7951         wxPyEndAllowThreads(__tstate);
7952         if (PyErr_Occurred()) SWIG_fail;
7953     }
7954     Py_INCREF(Py_None); resultobj = Py_None;
7955     return resultobj;
7956     fail:
7957     return NULL;
7958 }
7959
7960
7961 static PyObject *_wrap_SplitterWindow_GetSashSize(PyObject *, PyObject *args, PyObject *kwargs) {
7962     PyObject *resultobj;
7963     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7964     int result;
7965     PyObject * obj0 = 0 ;
7966     char *kwnames[] = {
7967         (char *) "self", NULL
7968     };
7969
7970     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashSize",kwnames,&obj0)) goto fail;
7971     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7972     if (SWIG_arg_fail(1)) SWIG_fail;
7973     {
7974         PyThreadState* __tstate = wxPyBeginAllowThreads();
7975         result = (int)((wxSplitterWindow const *)arg1)->GetSashSize();
7976
7977         wxPyEndAllowThreads(__tstate);
7978         if (PyErr_Occurred()) SWIG_fail;
7979     }
7980     {
7981         resultobj = SWIG_From_int((int)(result));
7982     }
7983     return resultobj;
7984     fail:
7985     return NULL;
7986 }
7987
7988
7989 static PyObject *_wrap_SplitterWindow_GetBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
7990     PyObject *resultobj;
7991     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7992     int result;
7993     PyObject * obj0 = 0 ;
7994     char *kwnames[] = {
7995         (char *) "self", NULL
7996     };
7997
7998     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetBorderSize",kwnames,&obj0)) goto fail;
7999     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8000     if (SWIG_arg_fail(1)) SWIG_fail;
8001     {
8002         PyThreadState* __tstate = wxPyBeginAllowThreads();
8003         result = (int)((wxSplitterWindow const *)arg1)->GetBorderSize();
8004
8005         wxPyEndAllowThreads(__tstate);
8006         if (PyErr_Occurred()) SWIG_fail;
8007     }
8008     {
8009         resultobj = SWIG_From_int((int)(result));
8010     }
8011     return resultobj;
8012     fail:
8013     return NULL;
8014 }
8015
8016
8017 static PyObject *_wrap_SplitterWindow_SetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8018     PyObject *resultobj;
8019     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8020     int arg2 ;
8021     bool arg3 = (bool) true ;
8022     PyObject * obj0 = 0 ;
8023     PyObject * obj1 = 0 ;
8024     PyObject * obj2 = 0 ;
8025     char *kwnames[] = {
8026         (char *) "self",(char *) "position",(char *) "redraw", NULL
8027     };
8028
8029     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SplitterWindow_SetSashPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
8030     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8031     if (SWIG_arg_fail(1)) SWIG_fail;
8032     {
8033         arg2 = (int)(SWIG_As_int(obj1));
8034         if (SWIG_arg_fail(2)) SWIG_fail;
8035     }
8036     if (obj2) {
8037         {
8038             arg3 = (bool)(SWIG_As_bool(obj2));
8039             if (SWIG_arg_fail(3)) SWIG_fail;
8040         }
8041     }
8042     {
8043         PyThreadState* __tstate = wxPyBeginAllowThreads();
8044         (arg1)->SetSashPosition(arg2,arg3);
8045
8046         wxPyEndAllowThreads(__tstate);
8047         if (PyErr_Occurred()) SWIG_fail;
8048     }
8049     Py_INCREF(Py_None); resultobj = Py_None;
8050     return resultobj;
8051     fail:
8052     return NULL;
8053 }
8054
8055
8056 static PyObject *_wrap_SplitterWindow_GetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8057     PyObject *resultobj;
8058     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8059     int result;
8060     PyObject * obj0 = 0 ;
8061     char *kwnames[] = {
8062         (char *) "self", NULL
8063     };
8064
8065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashPosition",kwnames,&obj0)) goto fail;
8066     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8067     if (SWIG_arg_fail(1)) SWIG_fail;
8068     {
8069         PyThreadState* __tstate = wxPyBeginAllowThreads();
8070         result = (int)((wxSplitterWindow const *)arg1)->GetSashPosition();
8071
8072         wxPyEndAllowThreads(__tstate);
8073         if (PyErr_Occurred()) SWIG_fail;
8074     }
8075     {
8076         resultobj = SWIG_From_int((int)(result));
8077     }
8078     return resultobj;
8079     fail:
8080     return NULL;
8081 }
8082
8083
8084 static PyObject *_wrap_SplitterWindow_SetSashGravity(PyObject *, PyObject *args, PyObject *kwargs) {
8085     PyObject *resultobj;
8086     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8087     double arg2 ;
8088     PyObject * obj0 = 0 ;
8089     PyObject * obj1 = 0 ;
8090     char *kwnames[] = {
8091         (char *) "self",(char *) "gravity", NULL
8092     };
8093
8094     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSashGravity",kwnames,&obj0,&obj1)) goto fail;
8095     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8096     if (SWIG_arg_fail(1)) SWIG_fail;
8097     {
8098         arg2 = (double)(SWIG_As_double(obj1));
8099         if (SWIG_arg_fail(2)) SWIG_fail;
8100     }
8101     {
8102         PyThreadState* __tstate = wxPyBeginAllowThreads();
8103         (arg1)->SetSashGravity(arg2);
8104
8105         wxPyEndAllowThreads(__tstate);
8106         if (PyErr_Occurred()) SWIG_fail;
8107     }
8108     Py_INCREF(Py_None); resultobj = Py_None;
8109     return resultobj;
8110     fail:
8111     return NULL;
8112 }
8113
8114
8115 static PyObject *_wrap_SplitterWindow_GetSashGravity(PyObject *, PyObject *args, PyObject *kwargs) {
8116     PyObject *resultobj;
8117     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8118     double result;
8119     PyObject * obj0 = 0 ;
8120     char *kwnames[] = {
8121         (char *) "self", NULL
8122     };
8123
8124     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashGravity",kwnames,&obj0)) goto fail;
8125     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8126     if (SWIG_arg_fail(1)) SWIG_fail;
8127     {
8128         PyThreadState* __tstate = wxPyBeginAllowThreads();
8129         result = (double)((wxSplitterWindow const *)arg1)->GetSashGravity();
8130
8131         wxPyEndAllowThreads(__tstate);
8132         if (PyErr_Occurred()) SWIG_fail;
8133     }
8134     {
8135         resultobj = SWIG_From_double((double)(result));
8136     }
8137     return resultobj;
8138     fail:
8139     return NULL;
8140 }
8141
8142
8143 static PyObject *_wrap_SplitterWindow_SetMinimumPaneSize(PyObject *, PyObject *args, PyObject *kwargs) {
8144     PyObject *resultobj;
8145     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8146     int arg2 ;
8147     PyObject * obj0 = 0 ;
8148     PyObject * obj1 = 0 ;
8149     char *kwnames[] = {
8150         (char *) "self",(char *) "min", NULL
8151     };
8152
8153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetMinimumPaneSize",kwnames,&obj0,&obj1)) goto fail;
8154     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8155     if (SWIG_arg_fail(1)) SWIG_fail;
8156     {
8157         arg2 = (int)(SWIG_As_int(obj1));
8158         if (SWIG_arg_fail(2)) SWIG_fail;
8159     }
8160     {
8161         PyThreadState* __tstate = wxPyBeginAllowThreads();
8162         (arg1)->SetMinimumPaneSize(arg2);
8163
8164         wxPyEndAllowThreads(__tstate);
8165         if (PyErr_Occurred()) SWIG_fail;
8166     }
8167     Py_INCREF(Py_None); resultobj = Py_None;
8168     return resultobj;
8169     fail:
8170     return NULL;
8171 }
8172
8173
8174 static PyObject *_wrap_SplitterWindow_GetMinimumPaneSize(PyObject *, PyObject *args, PyObject *kwargs) {
8175     PyObject *resultobj;
8176     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8177     int result;
8178     PyObject * obj0 = 0 ;
8179     char *kwnames[] = {
8180         (char *) "self", NULL
8181     };
8182
8183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetMinimumPaneSize",kwnames,&obj0)) goto fail;
8184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8185     if (SWIG_arg_fail(1)) SWIG_fail;
8186     {
8187         PyThreadState* __tstate = wxPyBeginAllowThreads();
8188         result = (int)((wxSplitterWindow const *)arg1)->GetMinimumPaneSize();
8189
8190         wxPyEndAllowThreads(__tstate);
8191         if (PyErr_Occurred()) SWIG_fail;
8192     }
8193     {
8194         resultobj = SWIG_From_int((int)(result));
8195     }
8196     return resultobj;
8197     fail:
8198     return NULL;
8199 }
8200
8201
8202 static PyObject *_wrap_SplitterWindow_SashHitTest(PyObject *, PyObject *args, PyObject *kwargs) {
8203     PyObject *resultobj;
8204     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8205     int arg2 ;
8206     int arg3 ;
8207     int arg4 = (int) 5 ;
8208     bool result;
8209     PyObject * obj0 = 0 ;
8210     PyObject * obj1 = 0 ;
8211     PyObject * obj2 = 0 ;
8212     PyObject * obj3 = 0 ;
8213     char *kwnames[] = {
8214         (char *) "self",(char *) "x",(char *) "y",(char *) "tolerance", NULL
8215     };
8216
8217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SashHitTest",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8218     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8219     if (SWIG_arg_fail(1)) SWIG_fail;
8220     {
8221         arg2 = (int)(SWIG_As_int(obj1));
8222         if (SWIG_arg_fail(2)) SWIG_fail;
8223     }
8224     {
8225         arg3 = (int)(SWIG_As_int(obj2));
8226         if (SWIG_arg_fail(3)) SWIG_fail;
8227     }
8228     if (obj3) {
8229         {
8230             arg4 = (int)(SWIG_As_int(obj3));
8231             if (SWIG_arg_fail(4)) SWIG_fail;
8232         }
8233     }
8234     {
8235         PyThreadState* __tstate = wxPyBeginAllowThreads();
8236         result = (bool)(arg1)->SashHitTest(arg2,arg3,arg4);
8237
8238         wxPyEndAllowThreads(__tstate);
8239         if (PyErr_Occurred()) SWIG_fail;
8240     }
8241     {
8242         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8243     }
8244     return resultobj;
8245     fail:
8246     return NULL;
8247 }
8248
8249
8250 static PyObject *_wrap_SplitterWindow_SizeWindows(PyObject *, PyObject *args, PyObject *kwargs) {
8251     PyObject *resultobj;
8252     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8253     PyObject * obj0 = 0 ;
8254     char *kwnames[] = {
8255         (char *) "self", NULL
8256     };
8257
8258     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_SizeWindows",kwnames,&obj0)) goto fail;
8259     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8260     if (SWIG_arg_fail(1)) SWIG_fail;
8261     {
8262         PyThreadState* __tstate = wxPyBeginAllowThreads();
8263         (arg1)->SizeWindows();
8264
8265         wxPyEndAllowThreads(__tstate);
8266         if (PyErr_Occurred()) SWIG_fail;
8267     }
8268     Py_INCREF(Py_None); resultobj = Py_None;
8269     return resultobj;
8270     fail:
8271     return NULL;
8272 }
8273
8274
8275 static PyObject *_wrap_SplitterWindow_SetNeedUpdating(PyObject *, PyObject *args, PyObject *kwargs) {
8276     PyObject *resultobj;
8277     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8278     bool arg2 ;
8279     PyObject * obj0 = 0 ;
8280     PyObject * obj1 = 0 ;
8281     char *kwnames[] = {
8282         (char *) "self",(char *) "needUpdating", NULL
8283     };
8284
8285     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetNeedUpdating",kwnames,&obj0,&obj1)) goto fail;
8286     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8287     if (SWIG_arg_fail(1)) SWIG_fail;
8288     {
8289         arg2 = (bool)(SWIG_As_bool(obj1));
8290         if (SWIG_arg_fail(2)) SWIG_fail;
8291     }
8292     {
8293         PyThreadState* __tstate = wxPyBeginAllowThreads();
8294         (arg1)->SetNeedUpdating(arg2);
8295
8296         wxPyEndAllowThreads(__tstate);
8297         if (PyErr_Occurred()) SWIG_fail;
8298     }
8299     Py_INCREF(Py_None); resultobj = Py_None;
8300     return resultobj;
8301     fail:
8302     return NULL;
8303 }
8304
8305
8306 static PyObject *_wrap_SplitterWindow_GetNeedUpdating(PyObject *, PyObject *args, PyObject *kwargs) {
8307     PyObject *resultobj;
8308     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8309     bool result;
8310     PyObject * obj0 = 0 ;
8311     char *kwnames[] = {
8312         (char *) "self", NULL
8313     };
8314
8315     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetNeedUpdating",kwnames,&obj0)) goto fail;
8316     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8317     if (SWIG_arg_fail(1)) SWIG_fail;
8318     {
8319         PyThreadState* __tstate = wxPyBeginAllowThreads();
8320         result = (bool)((wxSplitterWindow const *)arg1)->GetNeedUpdating();
8321
8322         wxPyEndAllowThreads(__tstate);
8323         if (PyErr_Occurred()) SWIG_fail;
8324     }
8325     {
8326         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8327     }
8328     return resultobj;
8329     fail:
8330     return NULL;
8331 }
8332
8333
8334 static PyObject *_wrap_SplitterWindow_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8335     PyObject *resultobj;
8336     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
8337     wxVisualAttributes result;
8338     PyObject * obj0 = 0 ;
8339     char *kwnames[] = {
8340         (char *) "variant", NULL
8341     };
8342
8343     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SplitterWindow_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
8344     if (obj0) {
8345         {
8346             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
8347             if (SWIG_arg_fail(1)) SWIG_fail;
8348         }
8349     }
8350     {
8351         if (!wxPyCheckForApp()) SWIG_fail;
8352         PyThreadState* __tstate = wxPyBeginAllowThreads();
8353         result = wxSplitterWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
8354
8355         wxPyEndAllowThreads(__tstate);
8356         if (PyErr_Occurred()) SWIG_fail;
8357     }
8358     {
8359         wxVisualAttributes * resultptr;
8360         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
8361         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
8362     }
8363     return resultobj;
8364     fail:
8365     return NULL;
8366 }
8367
8368
8369 static PyObject * SplitterWindow_swigregister(PyObject *, PyObject *args) {
8370     PyObject *obj;
8371     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8372     SWIG_TypeClientData(SWIGTYPE_p_wxSplitterWindow, obj);
8373     Py_INCREF(obj);
8374     return Py_BuildValue((char *)"");
8375 }
8376 static PyObject *_wrap_new_SplitterEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8377     PyObject *resultobj;
8378     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
8379     wxSplitterWindow *arg2 = (wxSplitterWindow *) (wxSplitterWindow *) NULL ;
8380     wxSplitterEvent *result;
8381     PyObject * obj0 = 0 ;
8382     PyObject * obj1 = 0 ;
8383     char *kwnames[] = {
8384         (char *) "type",(char *) "splitter", NULL
8385     };
8386
8387     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SplitterEvent",kwnames,&obj0,&obj1)) goto fail;
8388     if (obj0) {
8389         {
8390             arg1 = (wxEventType)(SWIG_As_int(obj0));
8391             if (SWIG_arg_fail(1)) SWIG_fail;
8392         }
8393     }
8394     if (obj1) {
8395         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8396         if (SWIG_arg_fail(2)) SWIG_fail;
8397     }
8398     {
8399         PyThreadState* __tstate = wxPyBeginAllowThreads();
8400         result = (wxSplitterEvent *)new wxSplitterEvent(arg1,arg2);
8401
8402         wxPyEndAllowThreads(__tstate);
8403         if (PyErr_Occurred()) SWIG_fail;
8404     }
8405     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterEvent, 1);
8406     return resultobj;
8407     fail:
8408     return NULL;
8409 }
8410
8411
8412 static PyObject *_wrap_SplitterEvent_SetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8413     PyObject *resultobj;
8414     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8415     int arg2 ;
8416     PyObject * obj0 = 0 ;
8417     PyObject * obj1 = 0 ;
8418     char *kwnames[] = {
8419         (char *) "self",(char *) "pos", NULL
8420     };
8421
8422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterEvent_SetSashPosition",kwnames,&obj0,&obj1)) goto fail;
8423     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8424     if (SWIG_arg_fail(1)) SWIG_fail;
8425     {
8426         arg2 = (int)(SWIG_As_int(obj1));
8427         if (SWIG_arg_fail(2)) SWIG_fail;
8428     }
8429     {
8430         PyThreadState* __tstate = wxPyBeginAllowThreads();
8431         (arg1)->SetSashPosition(arg2);
8432
8433         wxPyEndAllowThreads(__tstate);
8434         if (PyErr_Occurred()) SWIG_fail;
8435     }
8436     Py_INCREF(Py_None); resultobj = Py_None;
8437     return resultobj;
8438     fail:
8439     return NULL;
8440 }
8441
8442
8443 static PyObject *_wrap_SplitterEvent_GetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8444     PyObject *resultobj;
8445     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8446     int result;
8447     PyObject * obj0 = 0 ;
8448     char *kwnames[] = {
8449         (char *) "self", NULL
8450     };
8451
8452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetSashPosition",kwnames,&obj0)) goto fail;
8453     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8454     if (SWIG_arg_fail(1)) SWIG_fail;
8455     {
8456         PyThreadState* __tstate = wxPyBeginAllowThreads();
8457         result = (int)((wxSplitterEvent const *)arg1)->GetSashPosition();
8458
8459         wxPyEndAllowThreads(__tstate);
8460         if (PyErr_Occurred()) SWIG_fail;
8461     }
8462     {
8463         resultobj = SWIG_From_int((int)(result));
8464     }
8465     return resultobj;
8466     fail:
8467     return NULL;
8468 }
8469
8470
8471 static PyObject *_wrap_SplitterEvent_GetWindowBeingRemoved(PyObject *, PyObject *args, PyObject *kwargs) {
8472     PyObject *resultobj;
8473     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8474     wxWindow *result;
8475     PyObject * obj0 = 0 ;
8476     char *kwnames[] = {
8477         (char *) "self", NULL
8478     };
8479
8480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetWindowBeingRemoved",kwnames,&obj0)) goto fail;
8481     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8482     if (SWIG_arg_fail(1)) SWIG_fail;
8483     {
8484         PyThreadState* __tstate = wxPyBeginAllowThreads();
8485         result = (wxWindow *)((wxSplitterEvent const *)arg1)->GetWindowBeingRemoved();
8486
8487         wxPyEndAllowThreads(__tstate);
8488         if (PyErr_Occurred()) SWIG_fail;
8489     }
8490     {
8491         resultobj = wxPyMake_wxObject(result, 0);
8492     }
8493     return resultobj;
8494     fail:
8495     return NULL;
8496 }
8497
8498
8499 static PyObject *_wrap_SplitterEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
8500     PyObject *resultobj;
8501     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8502     int result;
8503     PyObject * obj0 = 0 ;
8504     char *kwnames[] = {
8505         (char *) "self", NULL
8506     };
8507
8508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetX",kwnames,&obj0)) goto fail;
8509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8510     if (SWIG_arg_fail(1)) SWIG_fail;
8511     {
8512         PyThreadState* __tstate = wxPyBeginAllowThreads();
8513         result = (int)((wxSplitterEvent const *)arg1)->GetX();
8514
8515         wxPyEndAllowThreads(__tstate);
8516         if (PyErr_Occurred()) SWIG_fail;
8517     }
8518     {
8519         resultobj = SWIG_From_int((int)(result));
8520     }
8521     return resultobj;
8522     fail:
8523     return NULL;
8524 }
8525
8526
8527 static PyObject *_wrap_SplitterEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
8528     PyObject *resultobj;
8529     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8530     int result;
8531     PyObject * obj0 = 0 ;
8532     char *kwnames[] = {
8533         (char *) "self", NULL
8534     };
8535
8536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetY",kwnames,&obj0)) goto fail;
8537     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8538     if (SWIG_arg_fail(1)) SWIG_fail;
8539     {
8540         PyThreadState* __tstate = wxPyBeginAllowThreads();
8541         result = (int)((wxSplitterEvent const *)arg1)->GetY();
8542
8543         wxPyEndAllowThreads(__tstate);
8544         if (PyErr_Occurred()) SWIG_fail;
8545     }
8546     {
8547         resultobj = SWIG_From_int((int)(result));
8548     }
8549     return resultobj;
8550     fail:
8551     return NULL;
8552 }
8553
8554
8555 static PyObject * SplitterEvent_swigregister(PyObject *, PyObject *args) {
8556     PyObject *obj;
8557     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8558     SWIG_TypeClientData(SWIGTYPE_p_wxSplitterEvent, obj);
8559     Py_INCREF(obj);
8560     return Py_BuildValue((char *)"");
8561 }
8562 static int _wrap_SashNameStr_set(PyObject *) {
8563     PyErr_SetString(PyExc_TypeError,"Variable SashNameStr is read-only.");
8564     return 1;
8565 }
8566
8567
8568 static PyObject *_wrap_SashNameStr_get(void) {
8569     PyObject *pyobj;
8570
8571     {
8572 #if wxUSE_UNICODE
8573         pyobj = PyUnicode_FromWideChar((&wxPySashNameStr)->c_str(), (&wxPySashNameStr)->Len());
8574 #else
8575         pyobj = PyString_FromStringAndSize((&wxPySashNameStr)->c_str(), (&wxPySashNameStr)->Len());
8576 #endif
8577     }
8578     return pyobj;
8579 }
8580
8581
8582 static int _wrap_SashLayoutNameStr_set(PyObject *) {
8583     PyErr_SetString(PyExc_TypeError,"Variable SashLayoutNameStr is read-only.");
8584     return 1;
8585 }
8586
8587
8588 static PyObject *_wrap_SashLayoutNameStr_get(void) {
8589     PyObject *pyobj;
8590
8591     {
8592 #if wxUSE_UNICODE
8593         pyobj = PyUnicode_FromWideChar((&wxPySashLayoutNameStr)->c_str(), (&wxPySashLayoutNameStr)->Len());
8594 #else
8595         pyobj = PyString_FromStringAndSize((&wxPySashLayoutNameStr)->c_str(), (&wxPySashLayoutNameStr)->Len());
8596 #endif
8597     }
8598     return pyobj;
8599 }
8600
8601
8602 static PyObject *_wrap_new_SashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
8603     PyObject *resultobj;
8604     wxWindow *arg1 = (wxWindow *) 0 ;
8605     int arg2 = (int) -1 ;
8606     wxPoint const &arg3_defvalue = wxDefaultPosition ;
8607     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
8608     wxSize const &arg4_defvalue = wxDefaultSize ;
8609     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
8610     long arg5 = (long) wxCLIP_CHILDREN|wxSW_3D ;
8611     wxString const &arg6_defvalue = wxPySashNameStr ;
8612     wxString *arg6 = (wxString *) &arg6_defvalue ;
8613     wxSashWindow *result;
8614     wxPoint temp3 ;
8615     wxSize temp4 ;
8616     bool temp6 = false ;
8617     PyObject * obj0 = 0 ;
8618     PyObject * obj1 = 0 ;
8619     PyObject * obj2 = 0 ;
8620     PyObject * obj3 = 0 ;
8621     PyObject * obj4 = 0 ;
8622     PyObject * obj5 = 0 ;
8623     char *kwnames[] = {
8624         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
8625     };
8626
8627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SashWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
8628     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8629     if (SWIG_arg_fail(1)) SWIG_fail;
8630     if (obj1) {
8631         {
8632             arg2 = (int)(SWIG_As_int(obj1));
8633             if (SWIG_arg_fail(2)) SWIG_fail;
8634         }
8635     }
8636     if (obj2) {
8637         {
8638             arg3 = &temp3;
8639             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
8640         }
8641     }
8642     if (obj3) {
8643         {
8644             arg4 = &temp4;
8645             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
8646         }
8647     }
8648     if (obj4) {
8649         {
8650             arg5 = (long)(SWIG_As_long(obj4));
8651             if (SWIG_arg_fail(5)) SWIG_fail;
8652         }
8653     }
8654     if (obj5) {
8655         {
8656             arg6 = wxString_in_helper(obj5);
8657             if (arg6 == NULL) SWIG_fail;
8658             temp6 = true;
8659         }
8660     }
8661     {
8662         if (!wxPyCheckForApp()) SWIG_fail;
8663         PyThreadState* __tstate = wxPyBeginAllowThreads();
8664         result = (wxSashWindow *)new wxSashWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
8665
8666         wxPyEndAllowThreads(__tstate);
8667         if (PyErr_Occurred()) SWIG_fail;
8668     }
8669     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashWindow, 1);
8670     {
8671         if (temp6)
8672         delete arg6;
8673     }
8674     return resultobj;
8675     fail:
8676     {
8677         if (temp6)
8678         delete arg6;
8679     }
8680     return NULL;
8681 }
8682
8683
8684 static PyObject *_wrap_new_PreSashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
8685     PyObject *resultobj;
8686     wxSashWindow *result;
8687     char *kwnames[] = {
8688         NULL
8689     };
8690
8691     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSashWindow",kwnames)) goto fail;
8692     {
8693         if (!wxPyCheckForApp()) SWIG_fail;
8694         PyThreadState* __tstate = wxPyBeginAllowThreads();
8695         result = (wxSashWindow *)new wxSashWindow();
8696
8697         wxPyEndAllowThreads(__tstate);
8698         if (PyErr_Occurred()) SWIG_fail;
8699     }
8700     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashWindow, 1);
8701     return resultobj;
8702     fail:
8703     return NULL;
8704 }
8705
8706
8707 static PyObject *_wrap_SashWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
8708     PyObject *resultobj;
8709     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8710     wxWindow *arg2 = (wxWindow *) 0 ;
8711     int arg3 = (int) -1 ;
8712     wxPoint const &arg4_defvalue = wxDefaultPosition ;
8713     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
8714     wxSize const &arg5_defvalue = wxDefaultSize ;
8715     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
8716     long arg6 = (long) wxCLIP_CHILDREN|wxSW_3D ;
8717     wxString const &arg7_defvalue = wxPySashNameStr ;
8718     wxString *arg7 = (wxString *) &arg7_defvalue ;
8719     bool result;
8720     wxPoint temp4 ;
8721     wxSize temp5 ;
8722     bool temp7 = false ;
8723     PyObject * obj0 = 0 ;
8724     PyObject * obj1 = 0 ;
8725     PyObject * obj2 = 0 ;
8726     PyObject * obj3 = 0 ;
8727     PyObject * obj4 = 0 ;
8728     PyObject * obj5 = 0 ;
8729     PyObject * obj6 = 0 ;
8730     char *kwnames[] = {
8731         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
8732     };
8733
8734     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SashWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
8735     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8736     if (SWIG_arg_fail(1)) SWIG_fail;
8737     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8738     if (SWIG_arg_fail(2)) SWIG_fail;
8739     if (obj2) {
8740         {
8741             arg3 = (int)(SWIG_As_int(obj2));
8742             if (SWIG_arg_fail(3)) SWIG_fail;
8743         }
8744     }
8745     if (obj3) {
8746         {
8747             arg4 = &temp4;
8748             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
8749         }
8750     }
8751     if (obj4) {
8752         {
8753             arg5 = &temp5;
8754             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
8755         }
8756     }
8757     if (obj5) {
8758         {
8759             arg6 = (long)(SWIG_As_long(obj5));
8760             if (SWIG_arg_fail(6)) SWIG_fail;
8761         }
8762     }
8763     if (obj6) {
8764         {
8765             arg7 = wxString_in_helper(obj6);
8766             if (arg7 == NULL) SWIG_fail;
8767             temp7 = true;
8768         }
8769     }
8770     {
8771         PyThreadState* __tstate = wxPyBeginAllowThreads();
8772         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
8773
8774         wxPyEndAllowThreads(__tstate);
8775         if (PyErr_Occurred()) SWIG_fail;
8776     }
8777     {
8778         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8779     }
8780     {
8781         if (temp7)
8782         delete arg7;
8783     }
8784     return resultobj;
8785     fail:
8786     {
8787         if (temp7)
8788         delete arg7;
8789     }
8790     return NULL;
8791 }
8792
8793
8794 static PyObject *_wrap_SashWindow_SetSashVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8795     PyObject *resultobj;
8796     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8797     wxSashEdgePosition arg2 ;
8798     bool arg3 ;
8799     PyObject * obj0 = 0 ;
8800     PyObject * obj1 = 0 ;
8801     PyObject * obj2 = 0 ;
8802     char *kwnames[] = {
8803         (char *) "self",(char *) "edge",(char *) "sash", NULL
8804     };
8805
8806     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SashWindow_SetSashVisible",kwnames,&obj0,&obj1,&obj2)) goto fail;
8807     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8808     if (SWIG_arg_fail(1)) SWIG_fail;
8809     {
8810         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8811         if (SWIG_arg_fail(2)) SWIG_fail;
8812     }
8813     {
8814         arg3 = (bool)(SWIG_As_bool(obj2));
8815         if (SWIG_arg_fail(3)) SWIG_fail;
8816     }
8817     {
8818         PyThreadState* __tstate = wxPyBeginAllowThreads();
8819         (arg1)->SetSashVisible((wxSashEdgePosition )arg2,arg3);
8820
8821         wxPyEndAllowThreads(__tstate);
8822         if (PyErr_Occurred()) SWIG_fail;
8823     }
8824     Py_INCREF(Py_None); resultobj = Py_None;
8825     return resultobj;
8826     fail:
8827     return NULL;
8828 }
8829
8830
8831 static PyObject *_wrap_SashWindow_GetSashVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8832     PyObject *resultobj;
8833     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8834     wxSashEdgePosition arg2 ;
8835     bool result;
8836     PyObject * obj0 = 0 ;
8837     PyObject * obj1 = 0 ;
8838     char *kwnames[] = {
8839         (char *) "self",(char *) "edge", NULL
8840     };
8841
8842     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_GetSashVisible",kwnames,&obj0,&obj1)) goto fail;
8843     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8844     if (SWIG_arg_fail(1)) SWIG_fail;
8845     {
8846         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8847         if (SWIG_arg_fail(2)) SWIG_fail;
8848     }
8849     {
8850         PyThreadState* __tstate = wxPyBeginAllowThreads();
8851         result = (bool)((wxSashWindow const *)arg1)->GetSashVisible((wxSashEdgePosition )arg2);
8852
8853         wxPyEndAllowThreads(__tstate);
8854         if (PyErr_Occurred()) SWIG_fail;
8855     }
8856     {
8857         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8858     }
8859     return resultobj;
8860     fail:
8861     return NULL;
8862 }
8863
8864
8865 static PyObject *_wrap_SashWindow_SetSashBorder(PyObject *, PyObject *args, PyObject *kwargs) {
8866     PyObject *resultobj;
8867     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8868     wxSashEdgePosition arg2 ;
8869     bool arg3 ;
8870     PyObject * obj0 = 0 ;
8871     PyObject * obj1 = 0 ;
8872     PyObject * obj2 = 0 ;
8873     char *kwnames[] = {
8874         (char *) "self",(char *) "edge",(char *) "border", NULL
8875     };
8876
8877     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SashWindow_SetSashBorder",kwnames,&obj0,&obj1,&obj2)) goto fail;
8878     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8879     if (SWIG_arg_fail(1)) SWIG_fail;
8880     {
8881         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8882         if (SWIG_arg_fail(2)) SWIG_fail;
8883     }
8884     {
8885         arg3 = (bool)(SWIG_As_bool(obj2));
8886         if (SWIG_arg_fail(3)) SWIG_fail;
8887     }
8888     {
8889         PyThreadState* __tstate = wxPyBeginAllowThreads();
8890         (arg1)->SetSashBorder((wxSashEdgePosition )arg2,arg3);
8891
8892         wxPyEndAllowThreads(__tstate);
8893         if (PyErr_Occurred()) SWIG_fail;
8894     }
8895     Py_INCREF(Py_None); resultobj = Py_None;
8896     return resultobj;
8897     fail:
8898     return NULL;
8899 }
8900
8901
8902 static PyObject *_wrap_SashWindow_HasBorder(PyObject *, PyObject *args, PyObject *kwargs) {
8903     PyObject *resultobj;
8904     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8905     wxSashEdgePosition arg2 ;
8906     bool result;
8907     PyObject * obj0 = 0 ;
8908     PyObject * obj1 = 0 ;
8909     char *kwnames[] = {
8910         (char *) "self",(char *) "edge", NULL
8911     };
8912
8913     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_HasBorder",kwnames,&obj0,&obj1)) goto fail;
8914     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8915     if (SWIG_arg_fail(1)) SWIG_fail;
8916     {
8917         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8918         if (SWIG_arg_fail(2)) SWIG_fail;
8919     }
8920     {
8921         PyThreadState* __tstate = wxPyBeginAllowThreads();
8922         result = (bool)((wxSashWindow const *)arg1)->HasBorder((wxSashEdgePosition )arg2);
8923
8924         wxPyEndAllowThreads(__tstate);
8925         if (PyErr_Occurred()) SWIG_fail;
8926     }
8927     {
8928         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8929     }
8930     return resultobj;
8931     fail:
8932     return NULL;
8933 }
8934
8935
8936 static PyObject *_wrap_SashWindow_GetEdgeMargin(PyObject *, PyObject *args, PyObject *kwargs) {
8937     PyObject *resultobj;
8938     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8939     wxSashEdgePosition arg2 ;
8940     int result;
8941     PyObject * obj0 = 0 ;
8942     PyObject * obj1 = 0 ;
8943     char *kwnames[] = {
8944         (char *) "self",(char *) "edge", NULL
8945     };
8946
8947     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_GetEdgeMargin",kwnames,&obj0,&obj1)) goto fail;
8948     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8949     if (SWIG_arg_fail(1)) SWIG_fail;
8950     {
8951         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8952         if (SWIG_arg_fail(2)) SWIG_fail;
8953     }
8954     {
8955         PyThreadState* __tstate = wxPyBeginAllowThreads();
8956         result = (int)((wxSashWindow const *)arg1)->GetEdgeMargin((wxSashEdgePosition )arg2);
8957
8958         wxPyEndAllowThreads(__tstate);
8959         if (PyErr_Occurred()) SWIG_fail;
8960     }
8961     {
8962         resultobj = SWIG_From_int((int)(result));
8963     }
8964     return resultobj;
8965     fail:
8966     return NULL;
8967 }
8968
8969
8970 static PyObject *_wrap_SashWindow_SetDefaultBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
8971     PyObject *resultobj;
8972     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8973     int arg2 ;
8974     PyObject * obj0 = 0 ;
8975     PyObject * obj1 = 0 ;
8976     char *kwnames[] = {
8977         (char *) "self",(char *) "width", NULL
8978     };
8979
8980     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetDefaultBorderSize",kwnames,&obj0,&obj1)) goto fail;
8981     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8982     if (SWIG_arg_fail(1)) SWIG_fail;
8983     {
8984         arg2 = (int)(SWIG_As_int(obj1));
8985         if (SWIG_arg_fail(2)) SWIG_fail;
8986     }
8987     {
8988         PyThreadState* __tstate = wxPyBeginAllowThreads();
8989         (arg1)->SetDefaultBorderSize(arg2);
8990
8991         wxPyEndAllowThreads(__tstate);
8992         if (PyErr_Occurred()) SWIG_fail;
8993     }
8994     Py_INCREF(Py_None); resultobj = Py_None;
8995     return resultobj;
8996     fail:
8997     return NULL;
8998 }
8999
9000
9001 static PyObject *_wrap_SashWindow_GetDefaultBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
9002     PyObject *resultobj;
9003     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9004     int result;
9005     PyObject * obj0 = 0 ;
9006     char *kwnames[] = {
9007         (char *) "self", NULL
9008     };
9009
9010     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetDefaultBorderSize",kwnames,&obj0)) goto fail;
9011     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9012     if (SWIG_arg_fail(1)) SWIG_fail;
9013     {
9014         PyThreadState* __tstate = wxPyBeginAllowThreads();
9015         result = (int)((wxSashWindow const *)arg1)->GetDefaultBorderSize();
9016
9017         wxPyEndAllowThreads(__tstate);
9018         if (PyErr_Occurred()) SWIG_fail;
9019     }
9020     {
9021         resultobj = SWIG_From_int((int)(result));
9022     }
9023     return resultobj;
9024     fail:
9025     return NULL;
9026 }
9027
9028
9029 static PyObject *_wrap_SashWindow_SetExtraBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
9030     PyObject *resultobj;
9031     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9032     int arg2 ;
9033     PyObject * obj0 = 0 ;
9034     PyObject * obj1 = 0 ;
9035     char *kwnames[] = {
9036         (char *) "self",(char *) "width", NULL
9037     };
9038
9039     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetExtraBorderSize",kwnames,&obj0,&obj1)) goto fail;
9040     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9041     if (SWIG_arg_fail(1)) SWIG_fail;
9042     {
9043         arg2 = (int)(SWIG_As_int(obj1));
9044         if (SWIG_arg_fail(2)) SWIG_fail;
9045     }
9046     {
9047         PyThreadState* __tstate = wxPyBeginAllowThreads();
9048         (arg1)->SetExtraBorderSize(arg2);
9049
9050         wxPyEndAllowThreads(__tstate);
9051         if (PyErr_Occurred()) SWIG_fail;
9052     }
9053     Py_INCREF(Py_None); resultobj = Py_None;
9054     return resultobj;
9055     fail:
9056     return NULL;
9057 }
9058
9059
9060 static PyObject *_wrap_SashWindow_GetExtraBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
9061     PyObject *resultobj;
9062     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9063     int result;
9064     PyObject * obj0 = 0 ;
9065     char *kwnames[] = {
9066         (char *) "self", NULL
9067     };
9068
9069     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetExtraBorderSize",kwnames,&obj0)) goto fail;
9070     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9071     if (SWIG_arg_fail(1)) SWIG_fail;
9072     {
9073         PyThreadState* __tstate = wxPyBeginAllowThreads();
9074         result = (int)((wxSashWindow const *)arg1)->GetExtraBorderSize();
9075
9076         wxPyEndAllowThreads(__tstate);
9077         if (PyErr_Occurred()) SWIG_fail;
9078     }
9079     {
9080         resultobj = SWIG_From_int((int)(result));
9081     }
9082     return resultobj;
9083     fail:
9084     return NULL;
9085 }
9086
9087
9088 static PyObject *_wrap_SashWindow_SetMinimumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9089     PyObject *resultobj;
9090     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9091     int arg2 ;
9092     PyObject * obj0 = 0 ;
9093     PyObject * obj1 = 0 ;
9094     char *kwnames[] = {
9095         (char *) "self",(char *) "min", NULL
9096     };
9097
9098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMinimumSizeX",kwnames,&obj0,&obj1)) goto fail;
9099     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9100     if (SWIG_arg_fail(1)) SWIG_fail;
9101     {
9102         arg2 = (int)(SWIG_As_int(obj1));
9103         if (SWIG_arg_fail(2)) SWIG_fail;
9104     }
9105     {
9106         PyThreadState* __tstate = wxPyBeginAllowThreads();
9107         (arg1)->SetMinimumSizeX(arg2);
9108
9109         wxPyEndAllowThreads(__tstate);
9110         if (PyErr_Occurred()) SWIG_fail;
9111     }
9112     Py_INCREF(Py_None); resultobj = Py_None;
9113     return resultobj;
9114     fail:
9115     return NULL;
9116 }
9117
9118
9119 static PyObject *_wrap_SashWindow_SetMinimumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9120     PyObject *resultobj;
9121     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9122     int arg2 ;
9123     PyObject * obj0 = 0 ;
9124     PyObject * obj1 = 0 ;
9125     char *kwnames[] = {
9126         (char *) "self",(char *) "min", NULL
9127     };
9128
9129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMinimumSizeY",kwnames,&obj0,&obj1)) goto fail;
9130     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9131     if (SWIG_arg_fail(1)) SWIG_fail;
9132     {
9133         arg2 = (int)(SWIG_As_int(obj1));
9134         if (SWIG_arg_fail(2)) SWIG_fail;
9135     }
9136     {
9137         PyThreadState* __tstate = wxPyBeginAllowThreads();
9138         (arg1)->SetMinimumSizeY(arg2);
9139
9140         wxPyEndAllowThreads(__tstate);
9141         if (PyErr_Occurred()) SWIG_fail;
9142     }
9143     Py_INCREF(Py_None); resultobj = Py_None;
9144     return resultobj;
9145     fail:
9146     return NULL;
9147 }
9148
9149
9150 static PyObject *_wrap_SashWindow_GetMinimumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9151     PyObject *resultobj;
9152     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9153     int result;
9154     PyObject * obj0 = 0 ;
9155     char *kwnames[] = {
9156         (char *) "self", NULL
9157     };
9158
9159     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMinimumSizeX",kwnames,&obj0)) goto fail;
9160     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9161     if (SWIG_arg_fail(1)) SWIG_fail;
9162     {
9163         PyThreadState* __tstate = wxPyBeginAllowThreads();
9164         result = (int)((wxSashWindow const *)arg1)->GetMinimumSizeX();
9165
9166         wxPyEndAllowThreads(__tstate);
9167         if (PyErr_Occurred()) SWIG_fail;
9168     }
9169     {
9170         resultobj = SWIG_From_int((int)(result));
9171     }
9172     return resultobj;
9173     fail:
9174     return NULL;
9175 }
9176
9177
9178 static PyObject *_wrap_SashWindow_GetMinimumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9179     PyObject *resultobj;
9180     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9181     int result;
9182     PyObject * obj0 = 0 ;
9183     char *kwnames[] = {
9184         (char *) "self", NULL
9185     };
9186
9187     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMinimumSizeY",kwnames,&obj0)) goto fail;
9188     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9189     if (SWIG_arg_fail(1)) SWIG_fail;
9190     {
9191         PyThreadState* __tstate = wxPyBeginAllowThreads();
9192         result = (int)((wxSashWindow const *)arg1)->GetMinimumSizeY();
9193
9194         wxPyEndAllowThreads(__tstate);
9195         if (PyErr_Occurred()) SWIG_fail;
9196     }
9197     {
9198         resultobj = SWIG_From_int((int)(result));
9199     }
9200     return resultobj;
9201     fail:
9202     return NULL;
9203 }
9204
9205
9206 static PyObject *_wrap_SashWindow_SetMaximumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9207     PyObject *resultobj;
9208     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9209     int arg2 ;
9210     PyObject * obj0 = 0 ;
9211     PyObject * obj1 = 0 ;
9212     char *kwnames[] = {
9213         (char *) "self",(char *) "max", NULL
9214     };
9215
9216     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMaximumSizeX",kwnames,&obj0,&obj1)) goto fail;
9217     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9218     if (SWIG_arg_fail(1)) SWIG_fail;
9219     {
9220         arg2 = (int)(SWIG_As_int(obj1));
9221         if (SWIG_arg_fail(2)) SWIG_fail;
9222     }
9223     {
9224         PyThreadState* __tstate = wxPyBeginAllowThreads();
9225         (arg1)->SetMaximumSizeX(arg2);
9226
9227         wxPyEndAllowThreads(__tstate);
9228         if (PyErr_Occurred()) SWIG_fail;
9229     }
9230     Py_INCREF(Py_None); resultobj = Py_None;
9231     return resultobj;
9232     fail:
9233     return NULL;
9234 }
9235
9236
9237 static PyObject *_wrap_SashWindow_SetMaximumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9238     PyObject *resultobj;
9239     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9240     int arg2 ;
9241     PyObject * obj0 = 0 ;
9242     PyObject * obj1 = 0 ;
9243     char *kwnames[] = {
9244         (char *) "self",(char *) "max", NULL
9245     };
9246
9247     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMaximumSizeY",kwnames,&obj0,&obj1)) goto fail;
9248     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9249     if (SWIG_arg_fail(1)) SWIG_fail;
9250     {
9251         arg2 = (int)(SWIG_As_int(obj1));
9252         if (SWIG_arg_fail(2)) SWIG_fail;
9253     }
9254     {
9255         PyThreadState* __tstate = wxPyBeginAllowThreads();
9256         (arg1)->SetMaximumSizeY(arg2);
9257
9258         wxPyEndAllowThreads(__tstate);
9259         if (PyErr_Occurred()) SWIG_fail;
9260     }
9261     Py_INCREF(Py_None); resultobj = Py_None;
9262     return resultobj;
9263     fail:
9264     return NULL;
9265 }
9266
9267
9268 static PyObject *_wrap_SashWindow_GetMaximumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9269     PyObject *resultobj;
9270     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9271     int result;
9272     PyObject * obj0 = 0 ;
9273     char *kwnames[] = {
9274         (char *) "self", NULL
9275     };
9276
9277     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMaximumSizeX",kwnames,&obj0)) goto fail;
9278     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9279     if (SWIG_arg_fail(1)) SWIG_fail;
9280     {
9281         PyThreadState* __tstate = wxPyBeginAllowThreads();
9282         result = (int)((wxSashWindow const *)arg1)->GetMaximumSizeX();
9283
9284         wxPyEndAllowThreads(__tstate);
9285         if (PyErr_Occurred()) SWIG_fail;
9286     }
9287     {
9288         resultobj = SWIG_From_int((int)(result));
9289     }
9290     return resultobj;
9291     fail:
9292     return NULL;
9293 }
9294
9295
9296 static PyObject *_wrap_SashWindow_GetMaximumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9297     PyObject *resultobj;
9298     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9299     int result;
9300     PyObject * obj0 = 0 ;
9301     char *kwnames[] = {
9302         (char *) "self", NULL
9303     };
9304
9305     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMaximumSizeY",kwnames,&obj0)) goto fail;
9306     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9307     if (SWIG_arg_fail(1)) SWIG_fail;
9308     {
9309         PyThreadState* __tstate = wxPyBeginAllowThreads();
9310         result = (int)((wxSashWindow const *)arg1)->GetMaximumSizeY();
9311
9312         wxPyEndAllowThreads(__tstate);
9313         if (PyErr_Occurred()) SWIG_fail;
9314     }
9315     {
9316         resultobj = SWIG_From_int((int)(result));
9317     }
9318     return resultobj;
9319     fail:
9320     return NULL;
9321 }
9322
9323
9324 static PyObject *_wrap_SashWindow_SashHitTest(PyObject *, PyObject *args, PyObject *kwargs) {
9325     PyObject *resultobj;
9326     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9327     int arg2 ;
9328     int arg3 ;
9329     int arg4 = (int) 2 ;
9330     wxSashEdgePosition result;
9331     PyObject * obj0 = 0 ;
9332     PyObject * obj1 = 0 ;
9333     PyObject * obj2 = 0 ;
9334     PyObject * obj3 = 0 ;
9335     char *kwnames[] = {
9336         (char *) "self",(char *) "x",(char *) "y",(char *) "tolerance", NULL
9337     };
9338
9339     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SashWindow_SashHitTest",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9340     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9341     if (SWIG_arg_fail(1)) SWIG_fail;
9342     {
9343         arg2 = (int)(SWIG_As_int(obj1));
9344         if (SWIG_arg_fail(2)) SWIG_fail;
9345     }
9346     {
9347         arg3 = (int)(SWIG_As_int(obj2));
9348         if (SWIG_arg_fail(3)) SWIG_fail;
9349     }
9350     if (obj3) {
9351         {
9352             arg4 = (int)(SWIG_As_int(obj3));
9353             if (SWIG_arg_fail(4)) SWIG_fail;
9354         }
9355     }
9356     {
9357         PyThreadState* __tstate = wxPyBeginAllowThreads();
9358         result = (wxSashEdgePosition)(arg1)->SashHitTest(arg2,arg3,arg4);
9359
9360         wxPyEndAllowThreads(__tstate);
9361         if (PyErr_Occurred()) SWIG_fail;
9362     }
9363     resultobj = SWIG_From_int((result));
9364     return resultobj;
9365     fail:
9366     return NULL;
9367 }
9368
9369
9370 static PyObject *_wrap_SashWindow_SizeWindows(PyObject *, PyObject *args, PyObject *kwargs) {
9371     PyObject *resultobj;
9372     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9373     PyObject * obj0 = 0 ;
9374     char *kwnames[] = {
9375         (char *) "self", NULL
9376     };
9377
9378     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_SizeWindows",kwnames,&obj0)) goto fail;
9379     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9380     if (SWIG_arg_fail(1)) SWIG_fail;
9381     {
9382         PyThreadState* __tstate = wxPyBeginAllowThreads();
9383         (arg1)->SizeWindows();
9384
9385         wxPyEndAllowThreads(__tstate);
9386         if (PyErr_Occurred()) SWIG_fail;
9387     }
9388     Py_INCREF(Py_None); resultobj = Py_None;
9389     return resultobj;
9390     fail:
9391     return NULL;
9392 }
9393
9394
9395 static PyObject * SashWindow_swigregister(PyObject *, PyObject *args) {
9396     PyObject *obj;
9397     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9398     SWIG_TypeClientData(SWIGTYPE_p_wxSashWindow, obj);
9399     Py_INCREF(obj);
9400     return Py_BuildValue((char *)"");
9401 }
9402 static PyObject *_wrap_new_SashEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9403     PyObject *resultobj;
9404     int arg1 = (int) 0 ;
9405     wxSashEdgePosition arg2 = (wxSashEdgePosition) wxSASH_NONE ;
9406     wxSashEvent *result;
9407     PyObject * obj0 = 0 ;
9408     PyObject * obj1 = 0 ;
9409     char *kwnames[] = {
9410         (char *) "id",(char *) "edge", NULL
9411     };
9412
9413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SashEvent",kwnames,&obj0,&obj1)) goto fail;
9414     if (obj0) {
9415         {
9416             arg1 = (int)(SWIG_As_int(obj0));
9417             if (SWIG_arg_fail(1)) SWIG_fail;
9418         }
9419     }
9420     if (obj1) {
9421         {
9422             arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
9423             if (SWIG_arg_fail(2)) SWIG_fail;
9424         }
9425     }
9426     {
9427         PyThreadState* __tstate = wxPyBeginAllowThreads();
9428         result = (wxSashEvent *)new wxSashEvent(arg1,(wxSashEdgePosition )arg2);
9429
9430         wxPyEndAllowThreads(__tstate);
9431         if (PyErr_Occurred()) SWIG_fail;
9432     }
9433     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashEvent, 1);
9434     return resultobj;
9435     fail:
9436     return NULL;
9437 }
9438
9439
9440 static PyObject *_wrap_SashEvent_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
9441     PyObject *resultobj;
9442     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9443     wxSashEdgePosition arg2 ;
9444     PyObject * obj0 = 0 ;
9445     PyObject * obj1 = 0 ;
9446     char *kwnames[] = {
9447         (char *) "self",(char *) "edge", NULL
9448     };
9449
9450     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetEdge",kwnames,&obj0,&obj1)) goto fail;
9451     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9452     if (SWIG_arg_fail(1)) SWIG_fail;
9453     {
9454         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
9455         if (SWIG_arg_fail(2)) SWIG_fail;
9456     }
9457     {
9458         PyThreadState* __tstate = wxPyBeginAllowThreads();
9459         (arg1)->SetEdge((wxSashEdgePosition )arg2);
9460
9461         wxPyEndAllowThreads(__tstate);
9462         if (PyErr_Occurred()) SWIG_fail;
9463     }
9464     Py_INCREF(Py_None); resultobj = Py_None;
9465     return resultobj;
9466     fail:
9467     return NULL;
9468 }
9469
9470
9471 static PyObject *_wrap_SashEvent_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
9472     PyObject *resultobj;
9473     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9474     wxSashEdgePosition result;
9475     PyObject * obj0 = 0 ;
9476     char *kwnames[] = {
9477         (char *) "self", NULL
9478     };
9479
9480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetEdge",kwnames,&obj0)) goto fail;
9481     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9482     if (SWIG_arg_fail(1)) SWIG_fail;
9483     {
9484         PyThreadState* __tstate = wxPyBeginAllowThreads();
9485         result = (wxSashEdgePosition)((wxSashEvent const *)arg1)->GetEdge();
9486
9487         wxPyEndAllowThreads(__tstate);
9488         if (PyErr_Occurred()) SWIG_fail;
9489     }
9490     resultobj = SWIG_From_int((result));
9491     return resultobj;
9492     fail:
9493     return NULL;
9494 }
9495
9496
9497 static PyObject *_wrap_SashEvent_SetDragRect(PyObject *, PyObject *args, PyObject *kwargs) {
9498     PyObject *resultobj;
9499     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9500     wxRect *arg2 = 0 ;
9501     wxRect temp2 ;
9502     PyObject * obj0 = 0 ;
9503     PyObject * obj1 = 0 ;
9504     char *kwnames[] = {
9505         (char *) "self",(char *) "rect", NULL
9506     };
9507
9508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetDragRect",kwnames,&obj0,&obj1)) goto fail;
9509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9510     if (SWIG_arg_fail(1)) SWIG_fail;
9511     {
9512         arg2 = &temp2;
9513         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
9514     }
9515     {
9516         PyThreadState* __tstate = wxPyBeginAllowThreads();
9517         (arg1)->SetDragRect((wxRect const &)*arg2);
9518
9519         wxPyEndAllowThreads(__tstate);
9520         if (PyErr_Occurred()) SWIG_fail;
9521     }
9522     Py_INCREF(Py_None); resultobj = Py_None;
9523     return resultobj;
9524     fail:
9525     return NULL;
9526 }
9527
9528
9529 static PyObject *_wrap_SashEvent_GetDragRect(PyObject *, PyObject *args, PyObject *kwargs) {
9530     PyObject *resultobj;
9531     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9532     wxRect result;
9533     PyObject * obj0 = 0 ;
9534     char *kwnames[] = {
9535         (char *) "self", NULL
9536     };
9537
9538     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetDragRect",kwnames,&obj0)) goto fail;
9539     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9540     if (SWIG_arg_fail(1)) SWIG_fail;
9541     {
9542         PyThreadState* __tstate = wxPyBeginAllowThreads();
9543         result = ((wxSashEvent const *)arg1)->GetDragRect();
9544
9545         wxPyEndAllowThreads(__tstate);
9546         if (PyErr_Occurred()) SWIG_fail;
9547     }
9548     {
9549         wxRect * resultptr;
9550         resultptr = new wxRect((wxRect &)(result));
9551         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
9552     }
9553     return resultobj;
9554     fail:
9555     return NULL;
9556 }
9557
9558
9559 static PyObject *_wrap_SashEvent_SetDragStatus(PyObject *, PyObject *args, PyObject *kwargs) {
9560     PyObject *resultobj;
9561     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9562     wxSashDragStatus arg2 ;
9563     PyObject * obj0 = 0 ;
9564     PyObject * obj1 = 0 ;
9565     char *kwnames[] = {
9566         (char *) "self",(char *) "status", NULL
9567     };
9568
9569     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetDragStatus",kwnames,&obj0,&obj1)) goto fail;
9570     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9571     if (SWIG_arg_fail(1)) SWIG_fail;
9572     {
9573         arg2 = (wxSashDragStatus)(SWIG_As_int(obj1));
9574         if (SWIG_arg_fail(2)) SWIG_fail;
9575     }
9576     {
9577         PyThreadState* __tstate = wxPyBeginAllowThreads();
9578         (arg1)->SetDragStatus((wxSashDragStatus )arg2);
9579
9580         wxPyEndAllowThreads(__tstate);
9581         if (PyErr_Occurred()) SWIG_fail;
9582     }
9583     Py_INCREF(Py_None); resultobj = Py_None;
9584     return resultobj;
9585     fail:
9586     return NULL;
9587 }
9588
9589
9590 static PyObject *_wrap_SashEvent_GetDragStatus(PyObject *, PyObject *args, PyObject *kwargs) {
9591     PyObject *resultobj;
9592     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9593     wxSashDragStatus result;
9594     PyObject * obj0 = 0 ;
9595     char *kwnames[] = {
9596         (char *) "self", NULL
9597     };
9598
9599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetDragStatus",kwnames,&obj0)) goto fail;
9600     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9601     if (SWIG_arg_fail(1)) SWIG_fail;
9602     {
9603         PyThreadState* __tstate = wxPyBeginAllowThreads();
9604         result = (wxSashDragStatus)((wxSashEvent const *)arg1)->GetDragStatus();
9605
9606         wxPyEndAllowThreads(__tstate);
9607         if (PyErr_Occurred()) SWIG_fail;
9608     }
9609     resultobj = SWIG_From_int((result));
9610     return resultobj;
9611     fail:
9612     return NULL;
9613 }
9614
9615
9616 static PyObject * SashEvent_swigregister(PyObject *, PyObject *args) {
9617     PyObject *obj;
9618     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9619     SWIG_TypeClientData(SWIGTYPE_p_wxSashEvent, obj);
9620     Py_INCREF(obj);
9621     return Py_BuildValue((char *)"");
9622 }
9623 static PyObject *_wrap_new_QueryLayoutInfoEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9624     PyObject *resultobj;
9625     int arg1 = (int) 0 ;
9626     wxQueryLayoutInfoEvent *result;
9627     PyObject * obj0 = 0 ;
9628     char *kwnames[] = {
9629         (char *) "id", NULL
9630     };
9631
9632     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryLayoutInfoEvent",kwnames,&obj0)) goto fail;
9633     if (obj0) {
9634         {
9635             arg1 = (int)(SWIG_As_int(obj0));
9636             if (SWIG_arg_fail(1)) SWIG_fail;
9637         }
9638     }
9639     {
9640         PyThreadState* __tstate = wxPyBeginAllowThreads();
9641         result = (wxQueryLayoutInfoEvent *)new wxQueryLayoutInfoEvent(arg1);
9642
9643         wxPyEndAllowThreads(__tstate);
9644         if (PyErr_Occurred()) SWIG_fail;
9645     }
9646     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryLayoutInfoEvent, 1);
9647     return resultobj;
9648     fail:
9649     return NULL;
9650 }
9651
9652
9653 static PyObject *_wrap_QueryLayoutInfoEvent_SetRequestedLength(PyObject *, PyObject *args, PyObject *kwargs) {
9654     PyObject *resultobj;
9655     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9656     int arg2 ;
9657     PyObject * obj0 = 0 ;
9658     PyObject * obj1 = 0 ;
9659     char *kwnames[] = {
9660         (char *) "self",(char *) "length", NULL
9661     };
9662
9663     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetRequestedLength",kwnames,&obj0,&obj1)) goto fail;
9664     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9665     if (SWIG_arg_fail(1)) SWIG_fail;
9666     {
9667         arg2 = (int)(SWIG_As_int(obj1));
9668         if (SWIG_arg_fail(2)) SWIG_fail;
9669     }
9670     {
9671         PyThreadState* __tstate = wxPyBeginAllowThreads();
9672         (arg1)->SetRequestedLength(arg2);
9673
9674         wxPyEndAllowThreads(__tstate);
9675         if (PyErr_Occurred()) SWIG_fail;
9676     }
9677     Py_INCREF(Py_None); resultobj = Py_None;
9678     return resultobj;
9679     fail:
9680     return NULL;
9681 }
9682
9683
9684 static PyObject *_wrap_QueryLayoutInfoEvent_GetRequestedLength(PyObject *, PyObject *args, PyObject *kwargs) {
9685     PyObject *resultobj;
9686     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9687     int result;
9688     PyObject * obj0 = 0 ;
9689     char *kwnames[] = {
9690         (char *) "self", NULL
9691     };
9692
9693     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetRequestedLength",kwnames,&obj0)) goto fail;
9694     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9695     if (SWIG_arg_fail(1)) SWIG_fail;
9696     {
9697         PyThreadState* __tstate = wxPyBeginAllowThreads();
9698         result = (int)((wxQueryLayoutInfoEvent const *)arg1)->GetRequestedLength();
9699
9700         wxPyEndAllowThreads(__tstate);
9701         if (PyErr_Occurred()) SWIG_fail;
9702     }
9703     {
9704         resultobj = SWIG_From_int((int)(result));
9705     }
9706     return resultobj;
9707     fail:
9708     return NULL;
9709 }
9710
9711
9712 static PyObject *_wrap_QueryLayoutInfoEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9713     PyObject *resultobj;
9714     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9715     int arg2 ;
9716     PyObject * obj0 = 0 ;
9717     PyObject * obj1 = 0 ;
9718     char *kwnames[] = {
9719         (char *) "self",(char *) "flags", NULL
9720     };
9721
9722     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
9723     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9724     if (SWIG_arg_fail(1)) SWIG_fail;
9725     {
9726         arg2 = (int)(SWIG_As_int(obj1));
9727         if (SWIG_arg_fail(2)) SWIG_fail;
9728     }
9729     {
9730         PyThreadState* __tstate = wxPyBeginAllowThreads();
9731         (arg1)->SetFlags(arg2);
9732
9733         wxPyEndAllowThreads(__tstate);
9734         if (PyErr_Occurred()) SWIG_fail;
9735     }
9736     Py_INCREF(Py_None); resultobj = Py_None;
9737     return resultobj;
9738     fail:
9739     return NULL;
9740 }
9741
9742
9743 static PyObject *_wrap_QueryLayoutInfoEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9744     PyObject *resultobj;
9745     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9746     int result;
9747     PyObject * obj0 = 0 ;
9748     char *kwnames[] = {
9749         (char *) "self", NULL
9750     };
9751
9752     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetFlags",kwnames,&obj0)) goto fail;
9753     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9754     if (SWIG_arg_fail(1)) SWIG_fail;
9755     {
9756         PyThreadState* __tstate = wxPyBeginAllowThreads();
9757         result = (int)((wxQueryLayoutInfoEvent const *)arg1)->GetFlags();
9758
9759         wxPyEndAllowThreads(__tstate);
9760         if (PyErr_Occurred()) SWIG_fail;
9761     }
9762     {
9763         resultobj = SWIG_From_int((int)(result));
9764     }
9765     return resultobj;
9766     fail:
9767     return NULL;
9768 }
9769
9770
9771 static PyObject *_wrap_QueryLayoutInfoEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
9772     PyObject *resultobj;
9773     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9774     wxSize *arg2 = 0 ;
9775     wxSize temp2 ;
9776     PyObject * obj0 = 0 ;
9777     PyObject * obj1 = 0 ;
9778     char *kwnames[] = {
9779         (char *) "self",(char *) "size", NULL
9780     };
9781
9782     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
9783     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9784     if (SWIG_arg_fail(1)) SWIG_fail;
9785     {
9786         arg2 = &temp2;
9787         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
9788     }
9789     {
9790         PyThreadState* __tstate = wxPyBeginAllowThreads();
9791         (arg1)->SetSize((wxSize const &)*arg2);
9792
9793         wxPyEndAllowThreads(__tstate);
9794         if (PyErr_Occurred()) SWIG_fail;
9795     }
9796     Py_INCREF(Py_None); resultobj = Py_None;
9797     return resultobj;
9798     fail:
9799     return NULL;
9800 }
9801
9802
9803 static PyObject *_wrap_QueryLayoutInfoEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
9804     PyObject *resultobj;
9805     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9806     wxSize result;
9807     PyObject * obj0 = 0 ;
9808     char *kwnames[] = {
9809         (char *) "self", NULL
9810     };
9811
9812     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetSize",kwnames,&obj0)) goto fail;
9813     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9814     if (SWIG_arg_fail(1)) SWIG_fail;
9815     {
9816         PyThreadState* __tstate = wxPyBeginAllowThreads();
9817         result = ((wxQueryLayoutInfoEvent const *)arg1)->GetSize();
9818
9819         wxPyEndAllowThreads(__tstate);
9820         if (PyErr_Occurred()) SWIG_fail;
9821     }
9822     {
9823         wxSize * resultptr;
9824         resultptr = new wxSize((wxSize &)(result));
9825         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9826     }
9827     return resultobj;
9828     fail:
9829     return NULL;
9830 }
9831
9832
9833 static PyObject *_wrap_QueryLayoutInfoEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
9834     PyObject *resultobj;
9835     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9836     wxLayoutOrientation arg2 ;
9837     PyObject * obj0 = 0 ;
9838     PyObject * obj1 = 0 ;
9839     char *kwnames[] = {
9840         (char *) "self",(char *) "orient", NULL
9841     };
9842
9843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
9844     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9845     if (SWIG_arg_fail(1)) SWIG_fail;
9846     {
9847         arg2 = (wxLayoutOrientation)(SWIG_As_int(obj1));
9848         if (SWIG_arg_fail(2)) SWIG_fail;
9849     }
9850     {
9851         PyThreadState* __tstate = wxPyBeginAllowThreads();
9852         (arg1)->SetOrientation((wxLayoutOrientation )arg2);
9853
9854         wxPyEndAllowThreads(__tstate);
9855         if (PyErr_Occurred()) SWIG_fail;
9856     }
9857     Py_INCREF(Py_None); resultobj = Py_None;
9858     return resultobj;
9859     fail:
9860     return NULL;
9861 }
9862
9863
9864 static PyObject *_wrap_QueryLayoutInfoEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
9865     PyObject *resultobj;
9866     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9867     wxLayoutOrientation result;
9868     PyObject * obj0 = 0 ;
9869     char *kwnames[] = {
9870         (char *) "self", NULL
9871     };
9872
9873     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetOrientation",kwnames,&obj0)) goto fail;
9874     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9875     if (SWIG_arg_fail(1)) SWIG_fail;
9876     {
9877         PyThreadState* __tstate = wxPyBeginAllowThreads();
9878         result = (wxLayoutOrientation)((wxQueryLayoutInfoEvent const *)arg1)->GetOrientation();
9879
9880         wxPyEndAllowThreads(__tstate);
9881         if (PyErr_Occurred()) SWIG_fail;
9882     }
9883     resultobj = SWIG_From_int((result));
9884     return resultobj;
9885     fail:
9886     return NULL;
9887 }
9888
9889
9890 static PyObject *_wrap_QueryLayoutInfoEvent_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9891     PyObject *resultobj;
9892     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9893     wxLayoutAlignment arg2 ;
9894     PyObject * obj0 = 0 ;
9895     PyObject * obj1 = 0 ;
9896     char *kwnames[] = {
9897         (char *) "self",(char *) "align", NULL
9898     };
9899
9900     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetAlignment",kwnames,&obj0,&obj1)) goto fail;
9901     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9902     if (SWIG_arg_fail(1)) SWIG_fail;
9903     {
9904         arg2 = (wxLayoutAlignment)(SWIG_As_int(obj1));
9905         if (SWIG_arg_fail(2)) SWIG_fail;
9906     }
9907     {
9908         PyThreadState* __tstate = wxPyBeginAllowThreads();
9909         (arg1)->SetAlignment((wxLayoutAlignment )arg2);
9910
9911         wxPyEndAllowThreads(__tstate);
9912         if (PyErr_Occurred()) SWIG_fail;
9913     }
9914     Py_INCREF(Py_None); resultobj = Py_None;
9915     return resultobj;
9916     fail:
9917     return NULL;
9918 }
9919
9920
9921 static PyObject *_wrap_QueryLayoutInfoEvent_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9922     PyObject *resultobj;
9923     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9924     wxLayoutAlignment result;
9925     PyObject * obj0 = 0 ;
9926     char *kwnames[] = {
9927         (char *) "self", NULL
9928     };
9929
9930     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetAlignment",kwnames,&obj0)) goto fail;
9931     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9932     if (SWIG_arg_fail(1)) SWIG_fail;
9933     {
9934         PyThreadState* __tstate = wxPyBeginAllowThreads();
9935         result = (wxLayoutAlignment)((wxQueryLayoutInfoEvent const *)arg1)->GetAlignment();
9936
9937         wxPyEndAllowThreads(__tstate);
9938         if (PyErr_Occurred()) SWIG_fail;
9939     }
9940     resultobj = SWIG_From_int((result));
9941     return resultobj;
9942     fail:
9943     return NULL;
9944 }
9945
9946
9947 static PyObject * QueryLayoutInfoEvent_swigregister(PyObject *, PyObject *args) {
9948     PyObject *obj;
9949     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9950     SWIG_TypeClientData(SWIGTYPE_p_wxQueryLayoutInfoEvent, obj);
9951     Py_INCREF(obj);
9952     return Py_BuildValue((char *)"");
9953 }
9954 static PyObject *_wrap_new_CalculateLayoutEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9955     PyObject *resultobj;
9956     int arg1 = (int) 0 ;
9957     wxCalculateLayoutEvent *result;
9958     PyObject * obj0 = 0 ;
9959     char *kwnames[] = {
9960         (char *) "id", NULL
9961     };
9962
9963     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_CalculateLayoutEvent",kwnames,&obj0)) goto fail;
9964     if (obj0) {
9965         {
9966             arg1 = (int)(SWIG_As_int(obj0));
9967             if (SWIG_arg_fail(1)) SWIG_fail;
9968         }
9969     }
9970     {
9971         PyThreadState* __tstate = wxPyBeginAllowThreads();
9972         result = (wxCalculateLayoutEvent *)new wxCalculateLayoutEvent(arg1);
9973
9974         wxPyEndAllowThreads(__tstate);
9975         if (PyErr_Occurred()) SWIG_fail;
9976     }
9977     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCalculateLayoutEvent, 1);
9978     return resultobj;
9979     fail:
9980     return NULL;
9981 }
9982
9983
9984 static PyObject *_wrap_CalculateLayoutEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9985     PyObject *resultobj;
9986     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
9987     int arg2 ;
9988     PyObject * obj0 = 0 ;
9989     PyObject * obj1 = 0 ;
9990     char *kwnames[] = {
9991         (char *) "self",(char *) "flags", NULL
9992     };
9993
9994     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CalculateLayoutEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
9995     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
9996     if (SWIG_arg_fail(1)) SWIG_fail;
9997     {
9998         arg2 = (int)(SWIG_As_int(obj1));
9999         if (SWIG_arg_fail(2)) SWIG_fail;
10000     }
10001     {
10002         PyThreadState* __tstate = wxPyBeginAllowThreads();
10003         (arg1)->SetFlags(arg2);
10004
10005         wxPyEndAllowThreads(__tstate);
10006         if (PyErr_Occurred()) SWIG_fail;
10007     }
10008     Py_INCREF(Py_None); resultobj = Py_None;
10009     return resultobj;
10010     fail:
10011     return NULL;
10012 }
10013
10014
10015 static PyObject *_wrap_CalculateLayoutEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
10016     PyObject *resultobj;
10017     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10018     int result;
10019     PyObject * obj0 = 0 ;
10020     char *kwnames[] = {
10021         (char *) "self", NULL
10022     };
10023
10024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CalculateLayoutEvent_GetFlags",kwnames,&obj0)) goto fail;
10025     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10026     if (SWIG_arg_fail(1)) SWIG_fail;
10027     {
10028         PyThreadState* __tstate = wxPyBeginAllowThreads();
10029         result = (int)((wxCalculateLayoutEvent const *)arg1)->GetFlags();
10030
10031         wxPyEndAllowThreads(__tstate);
10032         if (PyErr_Occurred()) SWIG_fail;
10033     }
10034     {
10035         resultobj = SWIG_From_int((int)(result));
10036     }
10037     return resultobj;
10038     fail:
10039     return NULL;
10040 }
10041
10042
10043 static PyObject *_wrap_CalculateLayoutEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
10044     PyObject *resultobj;
10045     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10046     wxRect *arg2 = 0 ;
10047     wxRect temp2 ;
10048     PyObject * obj0 = 0 ;
10049     PyObject * obj1 = 0 ;
10050     char *kwnames[] = {
10051         (char *) "self",(char *) "rect", NULL
10052     };
10053
10054     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CalculateLayoutEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
10055     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10056     if (SWIG_arg_fail(1)) SWIG_fail;
10057     {
10058         arg2 = &temp2;
10059         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10060     }
10061     {
10062         PyThreadState* __tstate = wxPyBeginAllowThreads();
10063         (arg1)->SetRect((wxRect const &)*arg2);
10064
10065         wxPyEndAllowThreads(__tstate);
10066         if (PyErr_Occurred()) SWIG_fail;
10067     }
10068     Py_INCREF(Py_None); resultobj = Py_None;
10069     return resultobj;
10070     fail:
10071     return NULL;
10072 }
10073
10074
10075 static PyObject *_wrap_CalculateLayoutEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
10076     PyObject *resultobj;
10077     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10078     wxRect result;
10079     PyObject * obj0 = 0 ;
10080     char *kwnames[] = {
10081         (char *) "self", NULL
10082     };
10083
10084     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CalculateLayoutEvent_GetRect",kwnames,&obj0)) goto fail;
10085     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10086     if (SWIG_arg_fail(1)) SWIG_fail;
10087     {
10088         PyThreadState* __tstate = wxPyBeginAllowThreads();
10089         result = ((wxCalculateLayoutEvent const *)arg1)->GetRect();
10090
10091         wxPyEndAllowThreads(__tstate);
10092         if (PyErr_Occurred()) SWIG_fail;
10093     }
10094     {
10095         wxRect * resultptr;
10096         resultptr = new wxRect((wxRect &)(result));
10097         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
10098     }
10099     return resultobj;
10100     fail:
10101     return NULL;
10102 }
10103
10104
10105 static PyObject * CalculateLayoutEvent_swigregister(PyObject *, PyObject *args) {
10106     PyObject *obj;
10107     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10108     SWIG_TypeClientData(SWIGTYPE_p_wxCalculateLayoutEvent, obj);
10109     Py_INCREF(obj);
10110     return Py_BuildValue((char *)"");
10111 }
10112 static PyObject *_wrap_new_SashLayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10113     PyObject *resultobj;
10114     wxWindow *arg1 = (wxWindow *) 0 ;
10115     int arg2 = (int) -1 ;
10116     wxPoint const &arg3_defvalue = wxDefaultPosition ;
10117     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10118     wxSize const &arg4_defvalue = wxDefaultSize ;
10119     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10120     long arg5 = (long) wxCLIP_CHILDREN|wxSW_3D ;
10121     wxString const &arg6_defvalue = wxPySashLayoutNameStr ;
10122     wxString *arg6 = (wxString *) &arg6_defvalue ;
10123     wxSashLayoutWindow *result;
10124     wxPoint temp3 ;
10125     wxSize temp4 ;
10126     bool temp6 = false ;
10127     PyObject * obj0 = 0 ;
10128     PyObject * obj1 = 0 ;
10129     PyObject * obj2 = 0 ;
10130     PyObject * obj3 = 0 ;
10131     PyObject * obj4 = 0 ;
10132     PyObject * obj5 = 0 ;
10133     char *kwnames[] = {
10134         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10135     };
10136
10137     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SashLayoutWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10138     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10139     if (SWIG_arg_fail(1)) SWIG_fail;
10140     if (obj1) {
10141         {
10142             arg2 = (int)(SWIG_As_int(obj1));
10143             if (SWIG_arg_fail(2)) SWIG_fail;
10144         }
10145     }
10146     if (obj2) {
10147         {
10148             arg3 = &temp3;
10149             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10150         }
10151     }
10152     if (obj3) {
10153         {
10154             arg4 = &temp4;
10155             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10156         }
10157     }
10158     if (obj4) {
10159         {
10160             arg5 = (long)(SWIG_As_long(obj4));
10161             if (SWIG_arg_fail(5)) SWIG_fail;
10162         }
10163     }
10164     if (obj5) {
10165         {
10166             arg6 = wxString_in_helper(obj5);
10167             if (arg6 == NULL) SWIG_fail;
10168             temp6 = true;
10169         }
10170     }
10171     {
10172         if (!wxPyCheckForApp()) SWIG_fail;
10173         PyThreadState* __tstate = wxPyBeginAllowThreads();
10174         result = (wxSashLayoutWindow *)new wxSashLayoutWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10175
10176         wxPyEndAllowThreads(__tstate);
10177         if (PyErr_Occurred()) SWIG_fail;
10178     }
10179     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashLayoutWindow, 1);
10180     {
10181         if (temp6)
10182         delete arg6;
10183     }
10184     return resultobj;
10185     fail:
10186     {
10187         if (temp6)
10188         delete arg6;
10189     }
10190     return NULL;
10191 }
10192
10193
10194 static PyObject *_wrap_new_PreSashLayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10195     PyObject *resultobj;
10196     wxSashLayoutWindow *result;
10197     char *kwnames[] = {
10198         NULL
10199     };
10200
10201     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSashLayoutWindow",kwnames)) goto fail;
10202     {
10203         if (!wxPyCheckForApp()) SWIG_fail;
10204         PyThreadState* __tstate = wxPyBeginAllowThreads();
10205         result = (wxSashLayoutWindow *)new wxSashLayoutWindow();
10206
10207         wxPyEndAllowThreads(__tstate);
10208         if (PyErr_Occurred()) SWIG_fail;
10209     }
10210     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashLayoutWindow, 1);
10211     return resultobj;
10212     fail:
10213     return NULL;
10214 }
10215
10216
10217 static PyObject *_wrap_SashLayoutWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10218     PyObject *resultobj;
10219     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10220     wxWindow *arg2 = (wxWindow *) 0 ;
10221     int arg3 = (int) -1 ;
10222     wxPoint const &arg4_defvalue = wxDefaultPosition ;
10223     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10224     wxSize const &arg5_defvalue = wxDefaultSize ;
10225     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10226     long arg6 = (long) wxCLIP_CHILDREN|wxSW_3D ;
10227     wxString const &arg7_defvalue = wxPySashLayoutNameStr ;
10228     wxString *arg7 = (wxString *) &arg7_defvalue ;
10229     bool result;
10230     wxPoint temp4 ;
10231     wxSize temp5 ;
10232     bool temp7 = false ;
10233     PyObject * obj0 = 0 ;
10234     PyObject * obj1 = 0 ;
10235     PyObject * obj2 = 0 ;
10236     PyObject * obj3 = 0 ;
10237     PyObject * obj4 = 0 ;
10238     PyObject * obj5 = 0 ;
10239     PyObject * obj6 = 0 ;
10240     char *kwnames[] = {
10241         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10242     };
10243
10244     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SashLayoutWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10245     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10246     if (SWIG_arg_fail(1)) SWIG_fail;
10247     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10248     if (SWIG_arg_fail(2)) SWIG_fail;
10249     if (obj2) {
10250         {
10251             arg3 = (int)(SWIG_As_int(obj2));
10252             if (SWIG_arg_fail(3)) SWIG_fail;
10253         }
10254     }
10255     if (obj3) {
10256         {
10257             arg4 = &temp4;
10258             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10259         }
10260     }
10261     if (obj4) {
10262         {
10263             arg5 = &temp5;
10264             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10265         }
10266     }
10267     if (obj5) {
10268         {
10269             arg6 = (long)(SWIG_As_long(obj5));
10270             if (SWIG_arg_fail(6)) SWIG_fail;
10271         }
10272     }
10273     if (obj6) {
10274         {
10275             arg7 = wxString_in_helper(obj6);
10276             if (arg7 == NULL) SWIG_fail;
10277             temp7 = true;
10278         }
10279     }
10280     {
10281         PyThreadState* __tstate = wxPyBeginAllowThreads();
10282         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10283
10284         wxPyEndAllowThreads(__tstate);
10285         if (PyErr_Occurred()) SWIG_fail;
10286     }
10287     {
10288         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10289     }
10290     {
10291         if (temp7)
10292         delete arg7;
10293     }
10294     return resultobj;
10295     fail:
10296     {
10297         if (temp7)
10298         delete arg7;
10299     }
10300     return NULL;
10301 }
10302
10303
10304 static PyObject *_wrap_SashLayoutWindow_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
10305     PyObject *resultobj;
10306     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10307     wxLayoutAlignment result;
10308     PyObject * obj0 = 0 ;
10309     char *kwnames[] = {
10310         (char *) "self", NULL
10311     };
10312
10313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashLayoutWindow_GetAlignment",kwnames,&obj0)) goto fail;
10314     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10315     if (SWIG_arg_fail(1)) SWIG_fail;
10316     {
10317         PyThreadState* __tstate = wxPyBeginAllowThreads();
10318         result = (wxLayoutAlignment)(arg1)->GetAlignment();
10319
10320         wxPyEndAllowThreads(__tstate);
10321         if (PyErr_Occurred()) SWIG_fail;
10322     }
10323     resultobj = SWIG_From_int((result));
10324     return resultobj;
10325     fail:
10326     return NULL;
10327 }
10328
10329
10330 static PyObject *_wrap_SashLayoutWindow_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
10331     PyObject *resultobj;
10332     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10333     wxLayoutOrientation result;
10334     PyObject * obj0 = 0 ;
10335     char *kwnames[] = {
10336         (char *) "self", NULL
10337     };
10338
10339     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashLayoutWindow_GetOrientation",kwnames,&obj0)) goto fail;
10340     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10341     if (SWIG_arg_fail(1)) SWIG_fail;
10342     {
10343         PyThreadState* __tstate = wxPyBeginAllowThreads();
10344         result = (wxLayoutOrientation)(arg1)->GetOrientation();
10345
10346         wxPyEndAllowThreads(__tstate);
10347         if (PyErr_Occurred()) SWIG_fail;
10348     }
10349     resultobj = SWIG_From_int((result));
10350     return resultobj;
10351     fail:
10352     return NULL;
10353 }
10354
10355
10356 static PyObject *_wrap_SashLayoutWindow_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
10357     PyObject *resultobj;
10358     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10359     wxLayoutAlignment arg2 ;
10360     PyObject * obj0 = 0 ;
10361     PyObject * obj1 = 0 ;
10362     char *kwnames[] = {
10363         (char *) "self",(char *) "alignment", NULL
10364     };
10365
10366     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetAlignment",kwnames,&obj0,&obj1)) goto fail;
10367     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10368     if (SWIG_arg_fail(1)) SWIG_fail;
10369     {
10370         arg2 = (wxLayoutAlignment)(SWIG_As_int(obj1));
10371         if (SWIG_arg_fail(2)) SWIG_fail;
10372     }
10373     {
10374         PyThreadState* __tstate = wxPyBeginAllowThreads();
10375         (arg1)->SetAlignment((wxLayoutAlignment )arg2);
10376
10377         wxPyEndAllowThreads(__tstate);
10378         if (PyErr_Occurred()) SWIG_fail;
10379     }
10380     Py_INCREF(Py_None); resultobj = Py_None;
10381     return resultobj;
10382     fail:
10383     return NULL;
10384 }
10385
10386
10387 static PyObject *_wrap_SashLayoutWindow_SetDefaultSize(PyObject *, PyObject *args, PyObject *kwargs) {
10388     PyObject *resultobj;
10389     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10390     wxSize *arg2 = 0 ;
10391     wxSize temp2 ;
10392     PyObject * obj0 = 0 ;
10393     PyObject * obj1 = 0 ;
10394     char *kwnames[] = {
10395         (char *) "self",(char *) "size", NULL
10396     };
10397
10398     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetDefaultSize",kwnames,&obj0,&obj1)) goto fail;
10399     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10400     if (SWIG_arg_fail(1)) SWIG_fail;
10401     {
10402         arg2 = &temp2;
10403         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10404     }
10405     {
10406         PyThreadState* __tstate = wxPyBeginAllowThreads();
10407         (arg1)->SetDefaultSize((wxSize const &)*arg2);
10408
10409         wxPyEndAllowThreads(__tstate);
10410         if (PyErr_Occurred()) SWIG_fail;
10411     }
10412     Py_INCREF(Py_None); resultobj = Py_None;
10413     return resultobj;
10414     fail:
10415     return NULL;
10416 }
10417
10418
10419 static PyObject *_wrap_SashLayoutWindow_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
10420     PyObject *resultobj;
10421     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10422     wxLayoutOrientation arg2 ;
10423     PyObject * obj0 = 0 ;
10424     PyObject * obj1 = 0 ;
10425     char *kwnames[] = {
10426         (char *) "self",(char *) "orientation", NULL
10427     };
10428
10429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
10430     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10431     if (SWIG_arg_fail(1)) SWIG_fail;
10432     {
10433         arg2 = (wxLayoutOrientation)(SWIG_As_int(obj1));
10434         if (SWIG_arg_fail(2)) SWIG_fail;
10435     }
10436     {
10437         PyThreadState* __tstate = wxPyBeginAllowThreads();
10438         (arg1)->SetOrientation((wxLayoutOrientation )arg2);
10439
10440         wxPyEndAllowThreads(__tstate);
10441         if (PyErr_Occurred()) SWIG_fail;
10442     }
10443     Py_INCREF(Py_None); resultobj = Py_None;
10444     return resultobj;
10445     fail:
10446     return NULL;
10447 }
10448
10449
10450 static PyObject * SashLayoutWindow_swigregister(PyObject *, PyObject *args) {
10451     PyObject *obj;
10452     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10453     SWIG_TypeClientData(SWIGTYPE_p_wxSashLayoutWindow, obj);
10454     Py_INCREF(obj);
10455     return Py_BuildValue((char *)"");
10456 }
10457 static PyObject *_wrap_new_LayoutAlgorithm(PyObject *, PyObject *args, PyObject *kwargs) {
10458     PyObject *resultobj;
10459     wxLayoutAlgorithm *result;
10460     char *kwnames[] = {
10461         NULL
10462     };
10463
10464     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutAlgorithm",kwnames)) goto fail;
10465     {
10466         PyThreadState* __tstate = wxPyBeginAllowThreads();
10467         result = (wxLayoutAlgorithm *)new wxLayoutAlgorithm();
10468
10469         wxPyEndAllowThreads(__tstate);
10470         if (PyErr_Occurred()) SWIG_fail;
10471     }
10472     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutAlgorithm, 1);
10473     return resultobj;
10474     fail:
10475     return NULL;
10476 }
10477
10478
10479 static PyObject *_wrap_delete_LayoutAlgorithm(PyObject *, PyObject *args, PyObject *kwargs) {
10480     PyObject *resultobj;
10481     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10482     PyObject * obj0 = 0 ;
10483     char *kwnames[] = {
10484         (char *) "self", NULL
10485     };
10486
10487     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LayoutAlgorithm",kwnames,&obj0)) goto fail;
10488     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10489     if (SWIG_arg_fail(1)) SWIG_fail;
10490     {
10491         PyThreadState* __tstate = wxPyBeginAllowThreads();
10492         delete arg1;
10493
10494         wxPyEndAllowThreads(__tstate);
10495         if (PyErr_Occurred()) SWIG_fail;
10496     }
10497     Py_INCREF(Py_None); resultobj = Py_None;
10498     return resultobj;
10499     fail:
10500     return NULL;
10501 }
10502
10503
10504 static PyObject *_wrap_LayoutAlgorithm_LayoutMDIFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10505     PyObject *resultobj;
10506     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10507     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
10508     wxRect *arg3 = (wxRect *) NULL ;
10509     bool result;
10510     PyObject * obj0 = 0 ;
10511     PyObject * obj1 = 0 ;
10512     PyObject * obj2 = 0 ;
10513     char *kwnames[] = {
10514         (char *) "self",(char *) "frame",(char *) "rect", NULL
10515     };
10516
10517     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutMDIFrame",kwnames,&obj0,&obj1,&obj2)) goto fail;
10518     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10519     if (SWIG_arg_fail(1)) SWIG_fail;
10520     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
10521     if (SWIG_arg_fail(2)) SWIG_fail;
10522     if (obj2) {
10523         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
10524         if (SWIG_arg_fail(3)) SWIG_fail;
10525     }
10526     {
10527         PyThreadState* __tstate = wxPyBeginAllowThreads();
10528         result = (bool)(arg1)->LayoutMDIFrame(arg2,arg3);
10529
10530         wxPyEndAllowThreads(__tstate);
10531         if (PyErr_Occurred()) SWIG_fail;
10532     }
10533     {
10534         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10535     }
10536     return resultobj;
10537     fail:
10538     return NULL;
10539 }
10540
10541
10542 static PyObject *_wrap_LayoutAlgorithm_LayoutFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10543     PyObject *resultobj;
10544     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10545     wxFrame *arg2 = (wxFrame *) 0 ;
10546     wxWindow *arg3 = (wxWindow *) NULL ;
10547     bool result;
10548     PyObject * obj0 = 0 ;
10549     PyObject * obj1 = 0 ;
10550     PyObject * obj2 = 0 ;
10551     char *kwnames[] = {
10552         (char *) "self",(char *) "frame",(char *) "mainWindow", NULL
10553     };
10554
10555     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutFrame",kwnames,&obj0,&obj1,&obj2)) goto fail;
10556     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10557     if (SWIG_arg_fail(1)) SWIG_fail;
10558     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10559     if (SWIG_arg_fail(2)) SWIG_fail;
10560     if (obj2) {
10561         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10562         if (SWIG_arg_fail(3)) SWIG_fail;
10563     }
10564     {
10565         PyThreadState* __tstate = wxPyBeginAllowThreads();
10566         result = (bool)(arg1)->LayoutFrame(arg2,arg3);
10567
10568         wxPyEndAllowThreads(__tstate);
10569         if (PyErr_Occurred()) SWIG_fail;
10570     }
10571     {
10572         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10573     }
10574     return resultobj;
10575     fail:
10576     return NULL;
10577 }
10578
10579
10580 static PyObject *_wrap_LayoutAlgorithm_LayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10581     PyObject *resultobj;
10582     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10583     wxWindow *arg2 = (wxWindow *) 0 ;
10584     wxWindow *arg3 = (wxWindow *) NULL ;
10585     bool result;
10586     PyObject * obj0 = 0 ;
10587     PyObject * obj1 = 0 ;
10588     PyObject * obj2 = 0 ;
10589     char *kwnames[] = {
10590         (char *) "self",(char *) "parent",(char *) "mainWindow", NULL
10591     };
10592
10593     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
10594     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10595     if (SWIG_arg_fail(1)) SWIG_fail;
10596     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10597     if (SWIG_arg_fail(2)) SWIG_fail;
10598     if (obj2) {
10599         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10600         if (SWIG_arg_fail(3)) SWIG_fail;
10601     }
10602     {
10603         PyThreadState* __tstate = wxPyBeginAllowThreads();
10604         result = (bool)(arg1)->LayoutWindow(arg2,arg3);
10605
10606         wxPyEndAllowThreads(__tstate);
10607         if (PyErr_Occurred()) SWIG_fail;
10608     }
10609     {
10610         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10611     }
10612     return resultobj;
10613     fail:
10614     return NULL;
10615 }
10616
10617
10618 static PyObject * LayoutAlgorithm_swigregister(PyObject *, PyObject *args) {
10619     PyObject *obj;
10620     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10621     SWIG_TypeClientData(SWIGTYPE_p_wxLayoutAlgorithm, obj);
10622     Py_INCREF(obj);
10623     return Py_BuildValue((char *)"");
10624 }
10625 static PyObject *_wrap_new_PopupWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10626     PyObject *resultobj;
10627     wxWindow *arg1 = (wxWindow *) 0 ;
10628     int arg2 = (int) wxBORDER_NONE ;
10629     wxPopupWindow *result;
10630     PyObject * obj0 = 0 ;
10631     PyObject * obj1 = 0 ;
10632     char *kwnames[] = {
10633         (char *) "parent",(char *) "flags", NULL
10634     };
10635
10636     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PopupWindow",kwnames,&obj0,&obj1)) goto fail;
10637     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10638     if (SWIG_arg_fail(1)) SWIG_fail;
10639     if (obj1) {
10640         {
10641             arg2 = (int)(SWIG_As_int(obj1));
10642             if (SWIG_arg_fail(2)) SWIG_fail;
10643         }
10644     }
10645     {
10646         if (!wxPyCheckForApp()) SWIG_fail;
10647         PyThreadState* __tstate = wxPyBeginAllowThreads();
10648         result = (wxPopupWindow *)new wxPopupWindow(arg1,arg2);
10649
10650         wxPyEndAllowThreads(__tstate);
10651         if (PyErr_Occurred()) SWIG_fail;
10652     }
10653     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPopupWindow, 1);
10654     return resultobj;
10655     fail:
10656     return NULL;
10657 }
10658
10659
10660 static PyObject *_wrap_new_PrePopupWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10661     PyObject *resultobj;
10662     wxPopupWindow *result;
10663     char *kwnames[] = {
10664         NULL
10665     };
10666
10667     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePopupWindow",kwnames)) goto fail;
10668     {
10669         if (!wxPyCheckForApp()) SWIG_fail;
10670         PyThreadState* __tstate = wxPyBeginAllowThreads();
10671         result = (wxPopupWindow *)new wxPopupWindow();
10672
10673         wxPyEndAllowThreads(__tstate);
10674         if (PyErr_Occurred()) SWIG_fail;
10675     }
10676     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPopupWindow, 1);
10677     return resultobj;
10678     fail:
10679     return NULL;
10680 }
10681
10682
10683 static PyObject *_wrap_PopupWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10684     PyObject *resultobj;
10685     wxPopupWindow *arg1 = (wxPopupWindow *) 0 ;
10686     wxWindow *arg2 = (wxWindow *) 0 ;
10687     int arg3 = (int) wxBORDER_NONE ;
10688     bool result;
10689     PyObject * obj0 = 0 ;
10690     PyObject * obj1 = 0 ;
10691     PyObject * obj2 = 0 ;
10692     char *kwnames[] = {
10693         (char *) "self",(char *) "parent",(char *) "flags", NULL
10694     };
10695
10696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PopupWindow_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10697     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPopupWindow, SWIG_POINTER_EXCEPTION | 0);
10698     if (SWIG_arg_fail(1)) SWIG_fail;
10699     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10700     if (SWIG_arg_fail(2)) SWIG_fail;
10701     if (obj2) {
10702         {
10703             arg3 = (int)(SWIG_As_int(obj2));
10704             if (SWIG_arg_fail(3)) SWIG_fail;
10705         }
10706     }
10707     {
10708         PyThreadState* __tstate = wxPyBeginAllowThreads();
10709         result = (bool)(arg1)->Create(arg2,arg3);
10710
10711         wxPyEndAllowThreads(__tstate);
10712         if (PyErr_Occurred()) SWIG_fail;
10713     }
10714     {
10715         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10716     }
10717     return resultobj;
10718     fail:
10719     return NULL;
10720 }
10721
10722
10723 static PyObject *_wrap_PopupWindow_Position(PyObject *, PyObject *args, PyObject *kwargs) {
10724     PyObject *resultobj;
10725     wxPopupWindow *arg1 = (wxPopupWindow *) 0 ;
10726     wxPoint *arg2 = 0 ;
10727     wxSize *arg3 = 0 ;
10728     wxPoint temp2 ;
10729     wxSize temp3 ;
10730     PyObject * obj0 = 0 ;
10731     PyObject * obj1 = 0 ;
10732     PyObject * obj2 = 0 ;
10733     char *kwnames[] = {
10734         (char *) "self",(char *) "ptOrigin",(char *) "size", NULL
10735     };
10736
10737     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PopupWindow_Position",kwnames,&obj0,&obj1,&obj2)) goto fail;
10738     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPopupWindow, SWIG_POINTER_EXCEPTION | 0);
10739     if (SWIG_arg_fail(1)) SWIG_fail;
10740     {
10741         arg2 = &temp2;
10742         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
10743     }
10744     {
10745         arg3 = &temp3;
10746         if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
10747     }
10748     {
10749         PyThreadState* __tstate = wxPyBeginAllowThreads();
10750         (arg1)->Position((wxPoint const &)*arg2,(wxSize const &)*arg3);
10751
10752         wxPyEndAllowThreads(__tstate);
10753         if (PyErr_Occurred()) SWIG_fail;
10754     }
10755     Py_INCREF(Py_None); resultobj = Py_None;
10756     return resultobj;
10757     fail:
10758     return NULL;
10759 }
10760
10761
10762 static PyObject * PopupWindow_swigregister(PyObject *, PyObject *args) {
10763     PyObject *obj;
10764     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10765     SWIG_TypeClientData(SWIGTYPE_p_wxPopupWindow, obj);
10766     Py_INCREF(obj);
10767     return Py_BuildValue((char *)"");
10768 }
10769 static PyObject *_wrap_new_PopupTransientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10770     PyObject *resultobj;
10771     wxWindow *arg1 = (wxWindow *) 0 ;
10772     int arg2 = (int) wxBORDER_NONE ;
10773     wxPyPopupTransientWindow *result;
10774     PyObject * obj0 = 0 ;
10775     PyObject * obj1 = 0 ;
10776     char *kwnames[] = {
10777         (char *) "parent",(char *) "style", NULL
10778     };
10779
10780     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PopupTransientWindow",kwnames,&obj0,&obj1)) goto fail;
10781     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10782     if (SWIG_arg_fail(1)) SWIG_fail;
10783     if (obj1) {
10784         {
10785             arg2 = (int)(SWIG_As_int(obj1));
10786             if (SWIG_arg_fail(2)) SWIG_fail;
10787         }
10788     }
10789     {
10790         if (!wxPyCheckForApp()) SWIG_fail;
10791         PyThreadState* __tstate = wxPyBeginAllowThreads();
10792         result = (wxPyPopupTransientWindow *)new wxPyPopupTransientWindow(arg1,arg2);
10793
10794         wxPyEndAllowThreads(__tstate);
10795         if (PyErr_Occurred()) SWIG_fail;
10796     }
10797     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPopupTransientWindow, 1);
10798     return resultobj;
10799     fail:
10800     return NULL;
10801 }
10802
10803
10804 static PyObject *_wrap_new_PrePopupTransientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10805     PyObject *resultobj;
10806     wxPyPopupTransientWindow *result;
10807     char *kwnames[] = {
10808         NULL
10809     };
10810
10811     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePopupTransientWindow",kwnames)) goto fail;
10812     {
10813         if (!wxPyCheckForApp()) SWIG_fail;
10814         PyThreadState* __tstate = wxPyBeginAllowThreads();
10815         result = (wxPyPopupTransientWindow *)new wxPyPopupTransientWindow();
10816
10817         wxPyEndAllowThreads(__tstate);
10818         if (PyErr_Occurred()) SWIG_fail;
10819     }
10820     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPopupTransientWindow, 1);
10821     return resultobj;
10822     fail:
10823     return NULL;
10824 }
10825
10826
10827 static PyObject *_wrap_PopupTransientWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10828     PyObject *resultobj;
10829     wxPyPopupTransientWindow *arg1 = (wxPyPopupTransientWindow *) 0 ;
10830     PyObject *arg2 = (PyObject *) 0 ;
10831     PyObject *arg3 = (PyObject *) 0 ;
10832     PyObject * obj0 = 0 ;
10833     PyObject * obj1 = 0 ;
10834     PyObject * obj2 = 0 ;
10835     char *kwnames[] = {
10836         (char *) "self",(char *) "self",(char *) "_class", NULL
10837     };
10838
10839     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PopupTransientWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10840     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPopupTransientWindow, SWIG_POINTER_EXCEPTION | 0);
10841     if (SWIG_arg_fail(1)) SWIG_fail;
10842     arg2 = obj1;
10843     arg3 = obj2;
10844     {
10845         PyThreadState* __tstate = wxPyBeginAllowThreads();
10846         (arg1)->_setCallbackInfo(arg2,arg3);
10847
10848         wxPyEndAllowThreads(__tstate);
10849         if (PyErr_Occurred()) SWIG_fail;
10850     }
10851     Py_INCREF(Py_None); resultobj = Py_None;
10852     return resultobj;
10853     fail:
10854     return NULL;
10855 }
10856
10857
10858 static PyObject *_wrap_PopupTransientWindow_Popup(PyObject *, PyObject *args, PyObject *kwargs) {
10859     PyObject *resultobj;
10860     wxPyPopupTransientWindow *arg1 = (wxPyPopupTransientWindow *) 0 ;
10861     wxWindow *arg2 = (wxWindow *) NULL ;
10862     PyObject * obj0 = 0 ;
10863     PyObject * obj1 = 0 ;
10864     char *kwnames[] = {
10865         (char *) "self",(char *) "focus", NULL
10866     };
10867
10868     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PopupTransientWindow_Popup",kwnames,&obj0,&obj1)) goto fail;
10869     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPopupTransientWindow, SWIG_POINTER_EXCEPTION | 0);
10870     if (SWIG_arg_fail(1)) SWIG_fail;
10871     if (obj1) {
10872         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10873         if (SWIG_arg_fail(2)) SWIG_fail;
10874     }
10875     {
10876         PyThreadState* __tstate = wxPyBeginAllowThreads();
10877         (arg1)->Popup(arg2);
10878
10879         wxPyEndAllowThreads(__tstate);
10880         if (PyErr_Occurred()) SWIG_fail;
10881     }
10882     Py_INCREF(Py_None); resultobj = Py_None;
10883     return resultobj;
10884     fail:
10885     return NULL;
10886 }
10887
10888
10889 static PyObject *_wrap_PopupTransientWindow_Dismiss(PyObject *, PyObject *args, PyObject *kwargs) {
10890     PyObject *resultobj;
10891     wxPyPopupTransientWindow *arg1 = (wxPyPopupTransientWindow *) 0 ;
10892     PyObject * obj0 = 0 ;
10893     char *kwnames[] = {
10894         (char *) "self", NULL
10895     };
10896
10897     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PopupTransientWindow_Dismiss",kwnames,&obj0)) goto fail;
10898     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPopupTransientWindow, SWIG_POINTER_EXCEPTION | 0);
10899     if (SWIG_arg_fail(1)) SWIG_fail;
10900     {
10901         PyThreadState* __tstate = wxPyBeginAllowThreads();
10902         (arg1)->Dismiss();
10903
10904         wxPyEndAllowThreads(__tstate);
10905         if (PyErr_Occurred()) SWIG_fail;
10906     }
10907     Py_INCREF(Py_None); resultobj = Py_None;
10908     return resultobj;
10909     fail:
10910     return NULL;
10911 }
10912
10913
10914 static PyObject * PopupTransientWindow_swigregister(PyObject *, PyObject *args) {
10915     PyObject *obj;
10916     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10917     SWIG_TypeClientData(SWIGTYPE_p_wxPyPopupTransientWindow, obj);
10918     Py_INCREF(obj);
10919     return Py_BuildValue((char *)"");
10920 }
10921 static PyObject *_wrap_new_TipWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10922     PyObject *resultobj;
10923     wxWindow *arg1 = (wxWindow *) 0 ;
10924     wxString *arg2 = 0 ;
10925     int arg3 = (int) 100 ;
10926     wxRect *arg4 = (wxRect *) NULL ;
10927     wxTipWindow *result;
10928     bool temp2 = false ;
10929     PyObject * obj0 = 0 ;
10930     PyObject * obj1 = 0 ;
10931     PyObject * obj2 = 0 ;
10932     PyObject * obj3 = 0 ;
10933     char *kwnames[] = {
10934         (char *) "parent",(char *) "text",(char *) "maxLength",(char *) "rectBound", NULL
10935     };
10936
10937     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_TipWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10938     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10939     if (SWIG_arg_fail(1)) SWIG_fail;
10940     {
10941         arg2 = wxString_in_helper(obj1);
10942         if (arg2 == NULL) SWIG_fail;
10943         temp2 = true;
10944     }
10945     if (obj2) {
10946         {
10947             arg3 = (int)(SWIG_As_int(obj2));
10948             if (SWIG_arg_fail(3)) SWIG_fail;
10949         }
10950     }
10951     if (obj3) {
10952         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
10953         if (SWIG_arg_fail(4)) SWIG_fail;
10954     }
10955     {
10956         if (!wxPyCheckForApp()) SWIG_fail;
10957         PyThreadState* __tstate = wxPyBeginAllowThreads();
10958         result = (wxTipWindow *)new_wxTipWindow(arg1,(wxString const &)*arg2,arg3,arg4);
10959
10960         wxPyEndAllowThreads(__tstate);
10961         if (PyErr_Occurred()) SWIG_fail;
10962     }
10963     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipWindow, 1);
10964     {
10965         if (temp2)
10966         delete arg2;
10967     }
10968     return resultobj;
10969     fail:
10970     {
10971         if (temp2)
10972         delete arg2;
10973     }
10974     return NULL;
10975 }
10976
10977
10978 static PyObject *_wrap_TipWindow_SetBoundingRect(PyObject *, PyObject *args, PyObject *kwargs) {
10979     PyObject *resultobj;
10980     wxTipWindow *arg1 = (wxTipWindow *) 0 ;
10981     wxRect *arg2 = 0 ;
10982     wxRect temp2 ;
10983     PyObject * obj0 = 0 ;
10984     PyObject * obj1 = 0 ;
10985     char *kwnames[] = {
10986         (char *) "self",(char *) "rectBound", NULL
10987     };
10988
10989     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipWindow_SetBoundingRect",kwnames,&obj0,&obj1)) goto fail;
10990     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipWindow, SWIG_POINTER_EXCEPTION | 0);
10991     if (SWIG_arg_fail(1)) SWIG_fail;
10992     {
10993         arg2 = &temp2;
10994         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10995     }
10996     {
10997         PyThreadState* __tstate = wxPyBeginAllowThreads();
10998         (arg1)->SetBoundingRect((wxRect const &)*arg2);
10999
11000         wxPyEndAllowThreads(__tstate);
11001         if (PyErr_Occurred()) SWIG_fail;
11002     }
11003     Py_INCREF(Py_None); resultobj = Py_None;
11004     return resultobj;
11005     fail:
11006     return NULL;
11007 }
11008
11009
11010 static PyObject *_wrap_TipWindow_Close(PyObject *, PyObject *args, PyObject *kwargs) {
11011     PyObject *resultobj;
11012     wxTipWindow *arg1 = (wxTipWindow *) 0 ;
11013     PyObject * obj0 = 0 ;
11014     char *kwnames[] = {
11015         (char *) "self", NULL
11016     };
11017
11018     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipWindow_Close",kwnames,&obj0)) goto fail;
11019     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipWindow, SWIG_POINTER_EXCEPTION | 0);
11020     if (SWIG_arg_fail(1)) SWIG_fail;
11021     {
11022         PyThreadState* __tstate = wxPyBeginAllowThreads();
11023         (arg1)->Close();
11024
11025         wxPyEndAllowThreads(__tstate);
11026         if (PyErr_Occurred()) SWIG_fail;
11027     }
11028     Py_INCREF(Py_None); resultobj = Py_None;
11029     return resultobj;
11030     fail:
11031     return NULL;
11032 }
11033
11034
11035 static PyObject * TipWindow_swigregister(PyObject *, PyObject *args) {
11036     PyObject *obj;
11037     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11038     SWIG_TypeClientData(SWIGTYPE_p_wxTipWindow, obj);
11039     Py_INCREF(obj);
11040     return Py_BuildValue((char *)"");
11041 }
11042 static PyObject *_wrap_new_VScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
11043     PyObject *resultobj;
11044     wxWindow *arg1 = (wxWindow *) 0 ;
11045     int arg2 = (int) wxID_ANY ;
11046     wxPoint const &arg3_defvalue = wxDefaultPosition ;
11047     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
11048     wxSize const &arg4_defvalue = wxDefaultSize ;
11049     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
11050     long arg5 = (long) 0 ;
11051     wxString const &arg6_defvalue = wxPyPanelNameStr ;
11052     wxString *arg6 = (wxString *) &arg6_defvalue ;
11053     wxPyVScrolledWindow *result;
11054     wxPoint temp3 ;
11055     wxSize temp4 ;
11056     bool temp6 = false ;
11057     PyObject * obj0 = 0 ;
11058     PyObject * obj1 = 0 ;
11059     PyObject * obj2 = 0 ;
11060     PyObject * obj3 = 0 ;
11061     PyObject * obj4 = 0 ;
11062     PyObject * obj5 = 0 ;
11063     char *kwnames[] = {
11064         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11065     };
11066
11067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_VScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11068     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11069     if (SWIG_arg_fail(1)) SWIG_fail;
11070     if (obj1) {
11071         {
11072             arg2 = (int)(SWIG_As_int(obj1));
11073             if (SWIG_arg_fail(2)) SWIG_fail;
11074         }
11075     }
11076     if (obj2) {
11077         {
11078             arg3 = &temp3;
11079             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11080         }
11081     }
11082     if (obj3) {
11083         {
11084             arg4 = &temp4;
11085             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
11086         }
11087     }
11088     if (obj4) {
11089         {
11090             arg5 = (long)(SWIG_As_long(obj4));
11091             if (SWIG_arg_fail(5)) SWIG_fail;
11092         }
11093     }
11094     if (obj5) {
11095         {
11096             arg6 = wxString_in_helper(obj5);
11097             if (arg6 == NULL) SWIG_fail;
11098             temp6 = true;
11099         }
11100     }
11101     {
11102         if (!wxPyCheckForApp()) SWIG_fail;
11103         PyThreadState* __tstate = wxPyBeginAllowThreads();
11104         result = (wxPyVScrolledWindow *)new wxPyVScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
11105
11106         wxPyEndAllowThreads(__tstate);
11107         if (PyErr_Occurred()) SWIG_fail;
11108     }
11109     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVScrolledWindow, 1);
11110     {
11111         if (temp6)
11112         delete arg6;
11113     }
11114     return resultobj;
11115     fail:
11116     {
11117         if (temp6)
11118         delete arg6;
11119     }
11120     return NULL;
11121 }
11122
11123
11124 static PyObject *_wrap_new_PreVScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
11125     PyObject *resultobj;
11126     wxPyVScrolledWindow *result;
11127     char *kwnames[] = {
11128         NULL
11129     };
11130
11131     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreVScrolledWindow",kwnames)) goto fail;
11132     {
11133         if (!wxPyCheckForApp()) SWIG_fail;
11134         PyThreadState* __tstate = wxPyBeginAllowThreads();
11135         result = (wxPyVScrolledWindow *)new wxPyVScrolledWindow();
11136
11137         wxPyEndAllowThreads(__tstate);
11138         if (PyErr_Occurred()) SWIG_fail;
11139     }
11140     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVScrolledWindow, 1);
11141     return resultobj;
11142     fail:
11143     return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_VScrolledWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11148     PyObject *resultobj;
11149     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11150     PyObject *arg2 = (PyObject *) 0 ;
11151     PyObject *arg3 = (PyObject *) 0 ;
11152     PyObject * obj0 = 0 ;
11153     PyObject * obj1 = 0 ;
11154     PyObject * obj2 = 0 ;
11155     char *kwnames[] = {
11156         (char *) "self",(char *) "self",(char *) "_class", NULL
11157     };
11158
11159     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11160     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11161     if (SWIG_arg_fail(1)) SWIG_fail;
11162     arg2 = obj1;
11163     arg3 = obj2;
11164     {
11165         PyThreadState* __tstate = wxPyBeginAllowThreads();
11166         (arg1)->_setCallbackInfo(arg2,arg3);
11167
11168         wxPyEndAllowThreads(__tstate);
11169         if (PyErr_Occurred()) SWIG_fail;
11170     }
11171     Py_INCREF(Py_None); resultobj = Py_None;
11172     return resultobj;
11173     fail:
11174     return NULL;
11175 }
11176
11177
11178 static PyObject *_wrap_VScrolledWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11179     PyObject *resultobj;
11180     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11181     wxWindow *arg2 = (wxWindow *) 0 ;
11182     int arg3 = (int) wxID_ANY ;
11183     wxPoint const &arg4_defvalue = wxDefaultPosition ;
11184     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
11185     wxSize const &arg5_defvalue = wxDefaultSize ;
11186     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
11187     long arg6 = (long) 0 ;
11188     wxString const &arg7_defvalue = wxPyPanelNameStr ;
11189     wxString *arg7 = (wxString *) &arg7_defvalue ;
11190     bool result;
11191     wxPoint temp4 ;
11192     wxSize temp5 ;
11193     bool temp7 = false ;
11194     PyObject * obj0 = 0 ;
11195     PyObject * obj1 = 0 ;
11196     PyObject * obj2 = 0 ;
11197     PyObject * obj3 = 0 ;
11198     PyObject * obj4 = 0 ;
11199     PyObject * obj5 = 0 ;
11200     PyObject * obj6 = 0 ;
11201     char *kwnames[] = {
11202         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11203     };
11204
11205     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:VScrolledWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
11206     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11207     if (SWIG_arg_fail(1)) SWIG_fail;
11208     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11209     if (SWIG_arg_fail(2)) SWIG_fail;
11210     if (obj2) {
11211         {
11212             arg3 = (int)(SWIG_As_int(obj2));
11213             if (SWIG_arg_fail(3)) SWIG_fail;
11214         }
11215     }
11216     if (obj3) {
11217         {
11218             arg4 = &temp4;
11219             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
11220         }
11221     }
11222     if (obj4) {
11223         {
11224             arg5 = &temp5;
11225             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
11226         }
11227     }
11228     if (obj5) {
11229         {
11230             arg6 = (long)(SWIG_As_long(obj5));
11231             if (SWIG_arg_fail(6)) SWIG_fail;
11232         }
11233     }
11234     if (obj6) {
11235         {
11236             arg7 = wxString_in_helper(obj6);
11237             if (arg7 == NULL) SWIG_fail;
11238             temp7 = true;
11239         }
11240     }
11241     {
11242         PyThreadState* __tstate = wxPyBeginAllowThreads();
11243         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
11244
11245         wxPyEndAllowThreads(__tstate);
11246         if (PyErr_Occurred()) SWIG_fail;
11247     }
11248     {
11249         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11250     }
11251     {
11252         if (temp7)
11253         delete arg7;
11254     }
11255     return resultobj;
11256     fail:
11257     {
11258         if (temp7)
11259         delete arg7;
11260     }
11261     return NULL;
11262 }
11263
11264
11265 static PyObject *_wrap_VScrolledWindow_SetLineCount(PyObject *, PyObject *args, PyObject *kwargs) {
11266     PyObject *resultobj;
11267     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11268     size_t arg2 ;
11269     PyObject * obj0 = 0 ;
11270     PyObject * obj1 = 0 ;
11271     char *kwnames[] = {
11272         (char *) "self",(char *) "count", NULL
11273     };
11274
11275     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_SetLineCount",kwnames,&obj0,&obj1)) goto fail;
11276     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11277     if (SWIG_arg_fail(1)) SWIG_fail;
11278     {
11279         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11280         if (SWIG_arg_fail(2)) SWIG_fail;
11281     }
11282     {
11283         PyThreadState* __tstate = wxPyBeginAllowThreads();
11284         (arg1)->SetLineCount(arg2);
11285
11286         wxPyEndAllowThreads(__tstate);
11287         if (PyErr_Occurred()) SWIG_fail;
11288     }
11289     Py_INCREF(Py_None); resultobj = Py_None;
11290     return resultobj;
11291     fail:
11292     return NULL;
11293 }
11294
11295
11296 static PyObject *_wrap_VScrolledWindow_ScrollToLine(PyObject *, PyObject *args, PyObject *kwargs) {
11297     PyObject *resultobj;
11298     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11299     size_t arg2 ;
11300     bool result;
11301     PyObject * obj0 = 0 ;
11302     PyObject * obj1 = 0 ;
11303     char *kwnames[] = {
11304         (char *) "self",(char *) "line", NULL
11305     };
11306
11307     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollToLine",kwnames,&obj0,&obj1)) goto fail;
11308     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11309     if (SWIG_arg_fail(1)) SWIG_fail;
11310     {
11311         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11312         if (SWIG_arg_fail(2)) SWIG_fail;
11313     }
11314     {
11315         PyThreadState* __tstate = wxPyBeginAllowThreads();
11316         result = (bool)(arg1)->ScrollToLine(arg2);
11317
11318         wxPyEndAllowThreads(__tstate);
11319         if (PyErr_Occurred()) SWIG_fail;
11320     }
11321     {
11322         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11323     }
11324     return resultobj;
11325     fail:
11326     return NULL;
11327 }
11328
11329
11330 static PyObject *_wrap_VScrolledWindow_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
11331     PyObject *resultobj;
11332     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11333     int arg2 ;
11334     bool result;
11335     PyObject * obj0 = 0 ;
11336     PyObject * obj1 = 0 ;
11337     char *kwnames[] = {
11338         (char *) "self",(char *) "lines", NULL
11339     };
11340
11341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
11342     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11343     if (SWIG_arg_fail(1)) SWIG_fail;
11344     {
11345         arg2 = (int)(SWIG_As_int(obj1));
11346         if (SWIG_arg_fail(2)) SWIG_fail;
11347     }
11348     {
11349         PyThreadState* __tstate = wxPyBeginAllowThreads();
11350         result = (bool)(arg1)->ScrollLines(arg2);
11351
11352         wxPyEndAllowThreads(__tstate);
11353         if (PyErr_Occurred()) SWIG_fail;
11354     }
11355     {
11356         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11357     }
11358     return resultobj;
11359     fail:
11360     return NULL;
11361 }
11362
11363
11364 static PyObject *_wrap_VScrolledWindow_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
11365     PyObject *resultobj;
11366     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11367     int arg2 ;
11368     bool result;
11369     PyObject * obj0 = 0 ;
11370     PyObject * obj1 = 0 ;
11371     char *kwnames[] = {
11372         (char *) "self",(char *) "pages", NULL
11373     };
11374
11375     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
11376     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11377     if (SWIG_arg_fail(1)) SWIG_fail;
11378     {
11379         arg2 = (int)(SWIG_As_int(obj1));
11380         if (SWIG_arg_fail(2)) SWIG_fail;
11381     }
11382     {
11383         PyThreadState* __tstate = wxPyBeginAllowThreads();
11384         result = (bool)(arg1)->ScrollPages(arg2);
11385
11386         wxPyEndAllowThreads(__tstate);
11387         if (PyErr_Occurred()) SWIG_fail;
11388     }
11389     {
11390         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11391     }
11392     return resultobj;
11393     fail:
11394     return NULL;
11395 }
11396
11397
11398 static PyObject *_wrap_VScrolledWindow_RefreshLine(PyObject *, PyObject *args, PyObject *kwargs) {
11399     PyObject *resultobj;
11400     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11401     size_t arg2 ;
11402     PyObject * obj0 = 0 ;
11403     PyObject * obj1 = 0 ;
11404     char *kwnames[] = {
11405         (char *) "self",(char *) "line", NULL
11406     };
11407
11408     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_RefreshLine",kwnames,&obj0,&obj1)) goto fail;
11409     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11410     if (SWIG_arg_fail(1)) SWIG_fail;
11411     {
11412         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11413         if (SWIG_arg_fail(2)) SWIG_fail;
11414     }
11415     {
11416         PyThreadState* __tstate = wxPyBeginAllowThreads();
11417         (arg1)->RefreshLine(arg2);
11418
11419         wxPyEndAllowThreads(__tstate);
11420         if (PyErr_Occurred()) SWIG_fail;
11421     }
11422     Py_INCREF(Py_None); resultobj = Py_None;
11423     return resultobj;
11424     fail:
11425     return NULL;
11426 }
11427
11428
11429 static PyObject *_wrap_VScrolledWindow_RefreshLines(PyObject *, PyObject *args, PyObject *kwargs) {
11430     PyObject *resultobj;
11431     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11432     size_t arg2 ;
11433     size_t arg3 ;
11434     PyObject * obj0 = 0 ;
11435     PyObject * obj1 = 0 ;
11436     PyObject * obj2 = 0 ;
11437     char *kwnames[] = {
11438         (char *) "self",(char *) "from",(char *) "to", NULL
11439     };
11440
11441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow_RefreshLines",kwnames,&obj0,&obj1,&obj2)) goto fail;
11442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11443     if (SWIG_arg_fail(1)) SWIG_fail;
11444     {
11445         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11446         if (SWIG_arg_fail(2)) SWIG_fail;
11447     }
11448     {
11449         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11450         if (SWIG_arg_fail(3)) SWIG_fail;
11451     }
11452     {
11453         PyThreadState* __tstate = wxPyBeginAllowThreads();
11454         (arg1)->RefreshLines(arg2,arg3);
11455
11456         wxPyEndAllowThreads(__tstate);
11457         if (PyErr_Occurred()) SWIG_fail;
11458     }
11459     Py_INCREF(Py_None); resultobj = Py_None;
11460     return resultobj;
11461     fail:
11462     return NULL;
11463 }
11464
11465
11466 static PyObject *_wrap_VScrolledWindow_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
11467     PyObject *resultobj;
11468     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11469     int arg2 ;
11470     int arg3 ;
11471     int result;
11472     PyObject * obj0 = 0 ;
11473     PyObject * obj1 = 0 ;
11474     PyObject * obj2 = 0 ;
11475     char *kwnames[] = {
11476         (char *) "self",(char *) "x",(char *) "y", NULL
11477     };
11478
11479     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
11480     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11481     if (SWIG_arg_fail(1)) SWIG_fail;
11482     {
11483         arg2 = (int)(SWIG_As_int(obj1));
11484         if (SWIG_arg_fail(2)) SWIG_fail;
11485     }
11486     {
11487         arg3 = (int)(SWIG_As_int(obj2));
11488         if (SWIG_arg_fail(3)) SWIG_fail;
11489     }
11490     {
11491         PyThreadState* __tstate = wxPyBeginAllowThreads();
11492         result = (int)((wxPyVScrolledWindow const *)arg1)->HitTest(arg2,arg3);
11493
11494         wxPyEndAllowThreads(__tstate);
11495         if (PyErr_Occurred()) SWIG_fail;
11496     }
11497     {
11498         resultobj = SWIG_From_int((int)(result));
11499     }
11500     return resultobj;
11501     fail:
11502     return NULL;
11503 }
11504
11505
11506 static PyObject *_wrap_VScrolledWindow_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
11507     PyObject *resultobj;
11508     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11509     wxPoint *arg2 = 0 ;
11510     int result;
11511     wxPoint temp2 ;
11512     PyObject * obj0 = 0 ;
11513     PyObject * obj1 = 0 ;
11514     char *kwnames[] = {
11515         (char *) "self",(char *) "pt", NULL
11516     };
11517
11518     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_HitTest",kwnames,&obj0,&obj1)) goto fail;
11519     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11520     if (SWIG_arg_fail(1)) SWIG_fail;
11521     {
11522         arg2 = &temp2;
11523         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
11524     }
11525     {
11526         PyThreadState* __tstate = wxPyBeginAllowThreads();
11527         result = (int)((wxPyVScrolledWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
11528
11529         wxPyEndAllowThreads(__tstate);
11530         if (PyErr_Occurred()) SWIG_fail;
11531     }
11532     {
11533         resultobj = SWIG_From_int((int)(result));
11534     }
11535     return resultobj;
11536     fail:
11537     return NULL;
11538 }
11539
11540
11541 static PyObject *_wrap_VScrolledWindow_RefreshAll(PyObject *, PyObject *args, PyObject *kwargs) {
11542     PyObject *resultobj;
11543     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11544     PyObject * obj0 = 0 ;
11545     char *kwnames[] = {
11546         (char *) "self", NULL
11547     };
11548
11549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_RefreshAll",kwnames,&obj0)) goto fail;
11550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11551     if (SWIG_arg_fail(1)) SWIG_fail;
11552     {
11553         PyThreadState* __tstate = wxPyBeginAllowThreads();
11554         (arg1)->RefreshAll();
11555
11556         wxPyEndAllowThreads(__tstate);
11557         if (PyErr_Occurred()) SWIG_fail;
11558     }
11559     Py_INCREF(Py_None); resultobj = Py_None;
11560     return resultobj;
11561     fail:
11562     return NULL;
11563 }
11564
11565
11566 static PyObject *_wrap_VScrolledWindow_GetLineCount(PyObject *, PyObject *args, PyObject *kwargs) {
11567     PyObject *resultobj;
11568     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11569     size_t result;
11570     PyObject * obj0 = 0 ;
11571     char *kwnames[] = {
11572         (char *) "self", NULL
11573     };
11574
11575     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetLineCount",kwnames,&obj0)) goto fail;
11576     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11577     if (SWIG_arg_fail(1)) SWIG_fail;
11578     {
11579         PyThreadState* __tstate = wxPyBeginAllowThreads();
11580         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetLineCount();
11581
11582         wxPyEndAllowThreads(__tstate);
11583         if (PyErr_Occurred()) SWIG_fail;
11584     }
11585     {
11586         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11587     }
11588     return resultobj;
11589     fail:
11590     return NULL;
11591 }
11592
11593
11594 static PyObject *_wrap_VScrolledWindow_GetFirstVisibleLine(PyObject *, PyObject *args, PyObject *kwargs) {
11595     PyObject *resultobj;
11596     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11597     size_t result;
11598     PyObject * obj0 = 0 ;
11599     char *kwnames[] = {
11600         (char *) "self", NULL
11601     };
11602
11603     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetFirstVisibleLine",kwnames,&obj0)) goto fail;
11604     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11605     if (SWIG_arg_fail(1)) SWIG_fail;
11606     {
11607         PyThreadState* __tstate = wxPyBeginAllowThreads();
11608         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetFirstVisibleLine();
11609
11610         wxPyEndAllowThreads(__tstate);
11611         if (PyErr_Occurred()) SWIG_fail;
11612     }
11613     {
11614         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11615     }
11616     return resultobj;
11617     fail:
11618     return NULL;
11619 }
11620
11621
11622 static PyObject *_wrap_VScrolledWindow_GetLastVisibleLine(PyObject *, PyObject *args, PyObject *kwargs) {
11623     PyObject *resultobj;
11624     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11625     size_t result;
11626     PyObject * obj0 = 0 ;
11627     char *kwnames[] = {
11628         (char *) "self", NULL
11629     };
11630
11631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetLastVisibleLine",kwnames,&obj0)) goto fail;
11632     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11633     if (SWIG_arg_fail(1)) SWIG_fail;
11634     {
11635         PyThreadState* __tstate = wxPyBeginAllowThreads();
11636         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetLastVisibleLine();
11637
11638         wxPyEndAllowThreads(__tstate);
11639         if (PyErr_Occurred()) SWIG_fail;
11640     }
11641     {
11642         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11643     }
11644     return resultobj;
11645     fail:
11646     return NULL;
11647 }
11648
11649
11650 static PyObject *_wrap_VScrolledWindow_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11651     PyObject *resultobj;
11652     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11653     size_t arg2 ;
11654     bool result;
11655     PyObject * obj0 = 0 ;
11656     PyObject * obj1 = 0 ;
11657     char *kwnames[] = {
11658         (char *) "self",(char *) "line", NULL
11659     };
11660
11661     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_IsVisible",kwnames,&obj0,&obj1)) goto fail;
11662     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11663     if (SWIG_arg_fail(1)) SWIG_fail;
11664     {
11665         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11666         if (SWIG_arg_fail(2)) SWIG_fail;
11667     }
11668     {
11669         PyThreadState* __tstate = wxPyBeginAllowThreads();
11670         result = (bool)((wxPyVScrolledWindow const *)arg1)->IsVisible(arg2);
11671
11672         wxPyEndAllowThreads(__tstate);
11673         if (PyErr_Occurred()) SWIG_fail;
11674     }
11675     {
11676         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11677     }
11678     return resultobj;
11679     fail:
11680     return NULL;
11681 }
11682
11683
11684 static PyObject * VScrolledWindow_swigregister(PyObject *, PyObject *args) {
11685     PyObject *obj;
11686     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11687     SWIG_TypeClientData(SWIGTYPE_p_wxPyVScrolledWindow, obj);
11688     Py_INCREF(obj);
11689     return Py_BuildValue((char *)"");
11690 }
11691 static int _wrap_VListBoxNameStr_set(PyObject *) {
11692     PyErr_SetString(PyExc_TypeError,"Variable VListBoxNameStr is read-only.");
11693     return 1;
11694 }
11695
11696
11697 static PyObject *_wrap_VListBoxNameStr_get(void) {
11698     PyObject *pyobj;
11699
11700     {
11701 #if wxUSE_UNICODE
11702         pyobj = PyUnicode_FromWideChar((&wxPyVListBoxNameStr)->c_str(), (&wxPyVListBoxNameStr)->Len());
11703 #else
11704         pyobj = PyString_FromStringAndSize((&wxPyVListBoxNameStr)->c_str(), (&wxPyVListBoxNameStr)->Len());
11705 #endif
11706     }
11707     return pyobj;
11708 }
11709
11710
11711 static PyObject *_wrap_new_VListBox(PyObject *, PyObject *args, PyObject *kwargs) {
11712     PyObject *resultobj;
11713     wxWindow *arg1 = (wxWindow *) 0 ;
11714     int arg2 = (int) wxID_ANY ;
11715     wxPoint const &arg3_defvalue = wxDefaultPosition ;
11716     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
11717     wxSize const &arg4_defvalue = wxDefaultSize ;
11718     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
11719     long arg5 = (long) 0 ;
11720     wxString const &arg6_defvalue = wxPyVListBoxNameStr ;
11721     wxString *arg6 = (wxString *) &arg6_defvalue ;
11722     wxPyVListBox *result;
11723     wxPoint temp3 ;
11724     wxSize temp4 ;
11725     bool temp6 = false ;
11726     PyObject * obj0 = 0 ;
11727     PyObject * obj1 = 0 ;
11728     PyObject * obj2 = 0 ;
11729     PyObject * obj3 = 0 ;
11730     PyObject * obj4 = 0 ;
11731     PyObject * obj5 = 0 ;
11732     char *kwnames[] = {
11733         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11734     };
11735
11736     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_VListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11737     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11738     if (SWIG_arg_fail(1)) SWIG_fail;
11739     if (obj1) {
11740         {
11741             arg2 = (int)(SWIG_As_int(obj1));
11742             if (SWIG_arg_fail(2)) SWIG_fail;
11743         }
11744     }
11745     if (obj2) {
11746         {
11747             arg3 = &temp3;
11748             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11749         }
11750     }
11751     if (obj3) {
11752         {
11753             arg4 = &temp4;
11754             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
11755         }
11756     }
11757     if (obj4) {
11758         {
11759             arg5 = (long)(SWIG_As_long(obj4));
11760             if (SWIG_arg_fail(5)) SWIG_fail;
11761         }
11762     }
11763     if (obj5) {
11764         {
11765             arg6 = wxString_in_helper(obj5);
11766             if (arg6 == NULL) SWIG_fail;
11767             temp6 = true;
11768         }
11769     }
11770     {
11771         if (!wxPyCheckForApp()) SWIG_fail;
11772         PyThreadState* __tstate = wxPyBeginAllowThreads();
11773         result = (wxPyVListBox *)new wxPyVListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
11774
11775         wxPyEndAllowThreads(__tstate);
11776         if (PyErr_Occurred()) SWIG_fail;
11777     }
11778     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVListBox, 1);
11779     {
11780         if (temp6)
11781         delete arg6;
11782     }
11783     return resultobj;
11784     fail:
11785     {
11786         if (temp6)
11787         delete arg6;
11788     }
11789     return NULL;
11790 }
11791
11792
11793 static PyObject *_wrap_new_PreVListBox(PyObject *, PyObject *args, PyObject *kwargs) {
11794     PyObject *resultobj;
11795     wxPyVListBox *result;
11796     char *kwnames[] = {
11797         NULL
11798     };
11799
11800     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreVListBox",kwnames)) goto fail;
11801     {
11802         if (!wxPyCheckForApp()) SWIG_fail;
11803         PyThreadState* __tstate = wxPyBeginAllowThreads();
11804         result = (wxPyVListBox *)new wxPyVListBox();
11805
11806         wxPyEndAllowThreads(__tstate);
11807         if (PyErr_Occurred()) SWIG_fail;
11808     }
11809     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVListBox, 1);
11810     return resultobj;
11811     fail:
11812     return NULL;
11813 }
11814
11815
11816 static PyObject *_wrap_VListBox__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11817     PyObject *resultobj;
11818     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11819     PyObject *arg2 = (PyObject *) 0 ;
11820     PyObject *arg3 = (PyObject *) 0 ;
11821     PyObject * obj0 = 0 ;
11822     PyObject * obj1 = 0 ;
11823     PyObject * obj2 = 0 ;
11824     char *kwnames[] = {
11825         (char *) "self",(char *) "self",(char *) "_class", NULL
11826     };
11827
11828     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11829     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11830     if (SWIG_arg_fail(1)) SWIG_fail;
11831     arg2 = obj1;
11832     arg3 = obj2;
11833     {
11834         PyThreadState* __tstate = wxPyBeginAllowThreads();
11835         (arg1)->_setCallbackInfo(arg2,arg3);
11836
11837         wxPyEndAllowThreads(__tstate);
11838         if (PyErr_Occurred()) SWIG_fail;
11839     }
11840     Py_INCREF(Py_None); resultobj = Py_None;
11841     return resultobj;
11842     fail:
11843     return NULL;
11844 }
11845
11846
11847 static PyObject *_wrap_VListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11848     PyObject *resultobj;
11849     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11850     wxWindow *arg2 = (wxWindow *) 0 ;
11851     int arg3 = (int) wxID_ANY ;
11852     wxPoint const &arg4_defvalue = wxDefaultPosition ;
11853     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
11854     wxSize const &arg5_defvalue = wxDefaultSize ;
11855     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
11856     long arg6 = (long) 0 ;
11857     wxString const &arg7_defvalue = wxPyVListBoxNameStr ;
11858     wxString *arg7 = (wxString *) &arg7_defvalue ;
11859     bool result;
11860     wxPoint temp4 ;
11861     wxSize temp5 ;
11862     bool temp7 = false ;
11863     PyObject * obj0 = 0 ;
11864     PyObject * obj1 = 0 ;
11865     PyObject * obj2 = 0 ;
11866     PyObject * obj3 = 0 ;
11867     PyObject * obj4 = 0 ;
11868     PyObject * obj5 = 0 ;
11869     PyObject * obj6 = 0 ;
11870     char *kwnames[] = {
11871         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11872     };
11873
11874     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:VListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
11875     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11876     if (SWIG_arg_fail(1)) SWIG_fail;
11877     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11878     if (SWIG_arg_fail(2)) SWIG_fail;
11879     if (obj2) {
11880         {
11881             arg3 = (int)(SWIG_As_int(obj2));
11882             if (SWIG_arg_fail(3)) SWIG_fail;
11883         }
11884     }
11885     if (obj3) {
11886         {
11887             arg4 = &temp4;
11888             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
11889         }
11890     }
11891     if (obj4) {
11892         {
11893             arg5 = &temp5;
11894             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
11895         }
11896     }
11897     if (obj5) {
11898         {
11899             arg6 = (long)(SWIG_As_long(obj5));
11900             if (SWIG_arg_fail(6)) SWIG_fail;
11901         }
11902     }
11903     if (obj6) {
11904         {
11905             arg7 = wxString_in_helper(obj6);
11906             if (arg7 == NULL) SWIG_fail;
11907             temp7 = true;
11908         }
11909     }
11910     {
11911         PyThreadState* __tstate = wxPyBeginAllowThreads();
11912         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
11913
11914         wxPyEndAllowThreads(__tstate);
11915         if (PyErr_Occurred()) SWIG_fail;
11916     }
11917     {
11918         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11919     }
11920     {
11921         if (temp7)
11922         delete arg7;
11923     }
11924     return resultobj;
11925     fail:
11926     {
11927         if (temp7)
11928         delete arg7;
11929     }
11930     return NULL;
11931 }
11932
11933
11934 static PyObject *_wrap_VListBox_GetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
11935     PyObject *resultobj;
11936     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11937     size_t result;
11938     PyObject * obj0 = 0 ;
11939     char *kwnames[] = {
11940         (char *) "self", NULL
11941     };
11942
11943     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetItemCount",kwnames,&obj0)) goto fail;
11944     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11945     if (SWIG_arg_fail(1)) SWIG_fail;
11946     {
11947         PyThreadState* __tstate = wxPyBeginAllowThreads();
11948         result = (size_t)((wxPyVListBox const *)arg1)->GetItemCount();
11949
11950         wxPyEndAllowThreads(__tstate);
11951         if (PyErr_Occurred()) SWIG_fail;
11952     }
11953     {
11954         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11955     }
11956     return resultobj;
11957     fail:
11958     return NULL;
11959 }
11960
11961
11962 static PyObject *_wrap_VListBox_HasMultipleSelection(PyObject *, PyObject *args, PyObject *kwargs) {
11963     PyObject *resultobj;
11964     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11965     bool result;
11966     PyObject * obj0 = 0 ;
11967     char *kwnames[] = {
11968         (char *) "self", NULL
11969     };
11970
11971     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_HasMultipleSelection",kwnames,&obj0)) goto fail;
11972     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11973     if (SWIG_arg_fail(1)) SWIG_fail;
11974     {
11975         PyThreadState* __tstate = wxPyBeginAllowThreads();
11976         result = (bool)((wxPyVListBox const *)arg1)->HasMultipleSelection();
11977
11978         wxPyEndAllowThreads(__tstate);
11979         if (PyErr_Occurred()) SWIG_fail;
11980     }
11981     {
11982         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11983     }
11984     return resultobj;
11985     fail:
11986     return NULL;
11987 }
11988
11989
11990 static PyObject *_wrap_VListBox_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
11991     PyObject *resultobj;
11992     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11993     int result;
11994     PyObject * obj0 = 0 ;
11995     char *kwnames[] = {
11996         (char *) "self", NULL
11997     };
11998
11999     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelection",kwnames,&obj0)) goto fail;
12000     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12001     if (SWIG_arg_fail(1)) SWIG_fail;
12002     {
12003         PyThreadState* __tstate = wxPyBeginAllowThreads();
12004         result = (int)((wxPyVListBox const *)arg1)->GetSelection();
12005
12006         wxPyEndAllowThreads(__tstate);
12007         if (PyErr_Occurred()) SWIG_fail;
12008     }
12009     {
12010         resultobj = SWIG_From_int((int)(result));
12011     }
12012     return resultobj;
12013     fail:
12014     return NULL;
12015 }
12016
12017
12018 static PyObject *_wrap_VListBox_IsCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
12019     PyObject *resultobj;
12020     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12021     size_t arg2 ;
12022     bool result;
12023     PyObject * obj0 = 0 ;
12024     PyObject * obj1 = 0 ;
12025     char *kwnames[] = {
12026         (char *) "self",(char *) "item", NULL
12027     };
12028
12029     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_IsCurrent",kwnames,&obj0,&obj1)) goto fail;
12030     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12031     if (SWIG_arg_fail(1)) SWIG_fail;
12032     {
12033         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12034         if (SWIG_arg_fail(2)) SWIG_fail;
12035     }
12036     {
12037         PyThreadState* __tstate = wxPyBeginAllowThreads();
12038         result = (bool)((wxPyVListBox const *)arg1)->IsCurrent(arg2);
12039
12040         wxPyEndAllowThreads(__tstate);
12041         if (PyErr_Occurred()) SWIG_fail;
12042     }
12043     {
12044         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12045     }
12046     return resultobj;
12047     fail:
12048     return NULL;
12049 }
12050
12051
12052 static PyObject *_wrap_VListBox_IsSelected(PyObject *, PyObject *args, PyObject *kwargs) {
12053     PyObject *resultobj;
12054     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12055     size_t arg2 ;
12056     bool result;
12057     PyObject * obj0 = 0 ;
12058     PyObject * obj1 = 0 ;
12059     char *kwnames[] = {
12060         (char *) "self",(char *) "item", NULL
12061     };
12062
12063     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_IsSelected",kwnames,&obj0,&obj1)) goto fail;
12064     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12065     if (SWIG_arg_fail(1)) SWIG_fail;
12066     {
12067         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12068         if (SWIG_arg_fail(2)) SWIG_fail;
12069     }
12070     {
12071         PyThreadState* __tstate = wxPyBeginAllowThreads();
12072         result = (bool)((wxPyVListBox const *)arg1)->IsSelected(arg2);
12073
12074         wxPyEndAllowThreads(__tstate);
12075         if (PyErr_Occurred()) SWIG_fail;
12076     }
12077     {
12078         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12079     }
12080     return resultobj;
12081     fail:
12082     return NULL;
12083 }
12084
12085
12086 static PyObject *_wrap_VListBox_GetSelectedCount(PyObject *, PyObject *args, PyObject *kwargs) {
12087     PyObject *resultobj;
12088     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12089     size_t result;
12090     PyObject * obj0 = 0 ;
12091     char *kwnames[] = {
12092         (char *) "self", NULL
12093     };
12094
12095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelectedCount",kwnames,&obj0)) goto fail;
12096     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12097     if (SWIG_arg_fail(1)) SWIG_fail;
12098     {
12099         PyThreadState* __tstate = wxPyBeginAllowThreads();
12100         result = (size_t)((wxPyVListBox const *)arg1)->GetSelectedCount();
12101
12102         wxPyEndAllowThreads(__tstate);
12103         if (PyErr_Occurred()) SWIG_fail;
12104     }
12105     {
12106         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
12107     }
12108     return resultobj;
12109     fail:
12110     return NULL;
12111 }
12112
12113
12114 static PyObject *_wrap_VListBox_GetFirstSelected(PyObject *, PyObject *args, PyObject *kwargs) {
12115     PyObject *resultobj;
12116     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12117     PyObject *result;
12118     PyObject * obj0 = 0 ;
12119     char *kwnames[] = {
12120         (char *) "self", NULL
12121     };
12122
12123     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetFirstSelected",kwnames,&obj0)) goto fail;
12124     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12125     if (SWIG_arg_fail(1)) SWIG_fail;
12126     {
12127         PyThreadState* __tstate = wxPyBeginAllowThreads();
12128         result = (PyObject *)wxPyVListBox_GetFirstSelected(arg1);
12129
12130         wxPyEndAllowThreads(__tstate);
12131         if (PyErr_Occurred()) SWIG_fail;
12132     }
12133     resultobj = result;
12134     return resultobj;
12135     fail:
12136     return NULL;
12137 }
12138
12139
12140 static PyObject *_wrap_VListBox_GetNextSelected(PyObject *, PyObject *args, PyObject *kwargs) {
12141     PyObject *resultobj;
12142     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12143     unsigned long arg2 ;
12144     PyObject *result;
12145     PyObject * obj0 = 0 ;
12146     PyObject * obj1 = 0 ;
12147     char *kwnames[] = {
12148         (char *) "self",(char *) "cookie", NULL
12149     };
12150
12151     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_GetNextSelected",kwnames,&obj0,&obj1)) goto fail;
12152     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12153     if (SWIG_arg_fail(1)) SWIG_fail;
12154     {
12155         arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
12156         if (SWIG_arg_fail(2)) SWIG_fail;
12157     }
12158     {
12159         PyThreadState* __tstate = wxPyBeginAllowThreads();
12160         result = (PyObject *)wxPyVListBox_GetNextSelected(arg1,arg2);
12161
12162         wxPyEndAllowThreads(__tstate);
12163         if (PyErr_Occurred()) SWIG_fail;
12164     }
12165     resultobj = result;
12166     return resultobj;
12167     fail:
12168     return NULL;
12169 }
12170
12171
12172 static PyObject *_wrap_VListBox_GetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
12173     PyObject *resultobj;
12174     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12175     wxPoint result;
12176     PyObject * obj0 = 0 ;
12177     char *kwnames[] = {
12178         (char *) "self", NULL
12179     };
12180
12181     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetMargins",kwnames,&obj0)) goto fail;
12182     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12183     if (SWIG_arg_fail(1)) SWIG_fail;
12184     {
12185         PyThreadState* __tstate = wxPyBeginAllowThreads();
12186         result = ((wxPyVListBox const *)arg1)->GetMargins();
12187
12188         wxPyEndAllowThreads(__tstate);
12189         if (PyErr_Occurred()) SWIG_fail;
12190     }
12191     {
12192         wxPoint * resultptr;
12193         resultptr = new wxPoint((wxPoint &)(result));
12194         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12195     }
12196     return resultobj;
12197     fail:
12198     return NULL;
12199 }
12200
12201
12202 static PyObject *_wrap_VListBox_GetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
12203     PyObject *resultobj;
12204     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12205     wxColour *result;
12206     PyObject * obj0 = 0 ;
12207     char *kwnames[] = {
12208         (char *) "self", NULL
12209     };
12210
12211     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelectionBackground",kwnames,&obj0)) goto fail;
12212     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12213     if (SWIG_arg_fail(1)) SWIG_fail;
12214     {
12215         PyThreadState* __tstate = wxPyBeginAllowThreads();
12216         {
12217             wxColour const &_result_ref = ((wxPyVListBox const *)arg1)->GetSelectionBackground();
12218             result = (wxColour *) &_result_ref;
12219         }
12220
12221         wxPyEndAllowThreads(__tstate);
12222         if (PyErr_Occurred()) SWIG_fail;
12223     }
12224     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
12225     return resultobj;
12226     fail:
12227     return NULL;
12228 }
12229
12230
12231 static PyObject *_wrap_VListBox_SetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
12232     PyObject *resultobj;
12233     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12234     size_t arg2 ;
12235     PyObject * obj0 = 0 ;
12236     PyObject * obj1 = 0 ;
12237     char *kwnames[] = {
12238         (char *) "self",(char *) "count", NULL
12239     };
12240
12241     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetItemCount",kwnames,&obj0,&obj1)) goto fail;
12242     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12243     if (SWIG_arg_fail(1)) SWIG_fail;
12244     {
12245         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12246         if (SWIG_arg_fail(2)) SWIG_fail;
12247     }
12248     {
12249         PyThreadState* __tstate = wxPyBeginAllowThreads();
12250         (arg1)->SetItemCount(arg2);
12251
12252         wxPyEndAllowThreads(__tstate);
12253         if (PyErr_Occurred()) SWIG_fail;
12254     }
12255     Py_INCREF(Py_None); resultobj = Py_None;
12256     return resultobj;
12257     fail:
12258     return NULL;
12259 }
12260
12261
12262 static PyObject *_wrap_VListBox_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
12263     PyObject *resultobj;
12264     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12265     PyObject * obj0 = 0 ;
12266     char *kwnames[] = {
12267         (char *) "self", NULL
12268     };
12269
12270     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_Clear",kwnames,&obj0)) goto fail;
12271     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12272     if (SWIG_arg_fail(1)) SWIG_fail;
12273     {
12274         PyThreadState* __tstate = wxPyBeginAllowThreads();
12275         (arg1)->Clear();
12276
12277         wxPyEndAllowThreads(__tstate);
12278         if (PyErr_Occurred()) SWIG_fail;
12279     }
12280     Py_INCREF(Py_None); resultobj = Py_None;
12281     return resultobj;
12282     fail:
12283     return NULL;
12284 }
12285
12286
12287 static PyObject *_wrap_VListBox_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
12288     PyObject *resultobj;
12289     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12290     int arg2 ;
12291     PyObject * obj0 = 0 ;
12292     PyObject * obj1 = 0 ;
12293     char *kwnames[] = {
12294         (char *) "self",(char *) "selection", NULL
12295     };
12296
12297     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetSelection",kwnames,&obj0,&obj1)) goto fail;
12298     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12299     if (SWIG_arg_fail(1)) SWIG_fail;
12300     {
12301         arg2 = (int)(SWIG_As_int(obj1));
12302         if (SWIG_arg_fail(2)) SWIG_fail;
12303     }
12304     {
12305         PyThreadState* __tstate = wxPyBeginAllowThreads();
12306         (arg1)->SetSelection(arg2);
12307
12308         wxPyEndAllowThreads(__tstate);
12309         if (PyErr_Occurred()) SWIG_fail;
12310     }
12311     Py_INCREF(Py_None); resultobj = Py_None;
12312     return resultobj;
12313     fail:
12314     return NULL;
12315 }
12316
12317
12318 static PyObject *_wrap_VListBox_Select(PyObject *, PyObject *args, PyObject *kwargs) {
12319     PyObject *resultobj;
12320     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12321     size_t arg2 ;
12322     bool arg3 = (bool) true ;
12323     bool result;
12324     PyObject * obj0 = 0 ;
12325     PyObject * obj1 = 0 ;
12326     PyObject * obj2 = 0 ;
12327     char *kwnames[] = {
12328         (char *) "self",(char *) "item",(char *) "select", NULL
12329     };
12330
12331     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:VListBox_Select",kwnames,&obj0,&obj1,&obj2)) goto fail;
12332     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12333     if (SWIG_arg_fail(1)) SWIG_fail;
12334     {
12335         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12336         if (SWIG_arg_fail(2)) SWIG_fail;
12337     }
12338     if (obj2) {
12339         {
12340             arg3 = (bool)(SWIG_As_bool(obj2));
12341             if (SWIG_arg_fail(3)) SWIG_fail;
12342         }
12343     }
12344     {
12345         PyThreadState* __tstate = wxPyBeginAllowThreads();
12346         result = (bool)(arg1)->Select(arg2,arg3);
12347
12348         wxPyEndAllowThreads(__tstate);
12349         if (PyErr_Occurred()) SWIG_fail;
12350     }
12351     {
12352         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12353     }
12354     return resultobj;
12355     fail:
12356     return NULL;
12357 }
12358
12359
12360 static PyObject *_wrap_VListBox_SelectRange(PyObject *, PyObject *args, PyObject *kwargs) {
12361     PyObject *resultobj;
12362     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12363     size_t arg2 ;
12364     size_t arg3 ;
12365     bool result;
12366     PyObject * obj0 = 0 ;
12367     PyObject * obj1 = 0 ;
12368     PyObject * obj2 = 0 ;
12369     char *kwnames[] = {
12370         (char *) "self",(char *) "from",(char *) "to", NULL
12371     };
12372
12373     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox_SelectRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
12374     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12375     if (SWIG_arg_fail(1)) SWIG_fail;
12376     {
12377         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12378         if (SWIG_arg_fail(2)) SWIG_fail;
12379     }
12380     {
12381         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12382         if (SWIG_arg_fail(3)) SWIG_fail;
12383     }
12384     {
12385         PyThreadState* __tstate = wxPyBeginAllowThreads();
12386         result = (bool)(arg1)->SelectRange(arg2,arg3);
12387
12388         wxPyEndAllowThreads(__tstate);
12389         if (PyErr_Occurred()) SWIG_fail;
12390     }
12391     {
12392         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12393     }
12394     return resultobj;
12395     fail:
12396     return NULL;
12397 }
12398
12399
12400 static PyObject *_wrap_VListBox_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
12401     PyObject *resultobj;
12402     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12403     size_t arg2 ;
12404     PyObject * obj0 = 0 ;
12405     PyObject * obj1 = 0 ;
12406     char *kwnames[] = {
12407         (char *) "self",(char *) "item", NULL
12408     };
12409
12410     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_Toggle",kwnames,&obj0,&obj1)) goto fail;
12411     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12412     if (SWIG_arg_fail(1)) SWIG_fail;
12413     {
12414         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12415         if (SWIG_arg_fail(2)) SWIG_fail;
12416     }
12417     {
12418         PyThreadState* __tstate = wxPyBeginAllowThreads();
12419         (arg1)->Toggle(arg2);
12420
12421         wxPyEndAllowThreads(__tstate);
12422         if (PyErr_Occurred()) SWIG_fail;
12423     }
12424     Py_INCREF(Py_None); resultobj = Py_None;
12425     return resultobj;
12426     fail:
12427     return NULL;
12428 }
12429
12430
12431 static PyObject *_wrap_VListBox_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
12432     PyObject *resultobj;
12433     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12434     bool result;
12435     PyObject * obj0 = 0 ;
12436     char *kwnames[] = {
12437         (char *) "self", NULL
12438     };
12439
12440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_SelectAll",kwnames,&obj0)) goto fail;
12441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12442     if (SWIG_arg_fail(1)) SWIG_fail;
12443     {
12444         PyThreadState* __tstate = wxPyBeginAllowThreads();
12445         result = (bool)(arg1)->SelectAll();
12446
12447         wxPyEndAllowThreads(__tstate);
12448         if (PyErr_Occurred()) SWIG_fail;
12449     }
12450     {
12451         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12452     }
12453     return resultobj;
12454     fail:
12455     return NULL;
12456 }
12457
12458
12459 static PyObject *_wrap_VListBox_DeselectAll(PyObject *, PyObject *args, PyObject *kwargs) {
12460     PyObject *resultobj;
12461     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12462     bool result;
12463     PyObject * obj0 = 0 ;
12464     char *kwnames[] = {
12465         (char *) "self", NULL
12466     };
12467
12468     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_DeselectAll",kwnames,&obj0)) goto fail;
12469     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12470     if (SWIG_arg_fail(1)) SWIG_fail;
12471     {
12472         PyThreadState* __tstate = wxPyBeginAllowThreads();
12473         result = (bool)(arg1)->DeselectAll();
12474
12475         wxPyEndAllowThreads(__tstate);
12476         if (PyErr_Occurred()) SWIG_fail;
12477     }
12478     {
12479         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12480     }
12481     return resultobj;
12482     fail:
12483     return NULL;
12484 }
12485
12486
12487 static PyObject *_wrap_VListBox_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
12488     PyObject *resultobj;
12489     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12490     wxPoint *arg2 = 0 ;
12491     wxPoint temp2 ;
12492     PyObject * obj0 = 0 ;
12493     PyObject * obj1 = 0 ;
12494     char *kwnames[] = {
12495         (char *) "self",(char *) "pt", NULL
12496     };
12497
12498     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetMargins",kwnames,&obj0,&obj1)) goto fail;
12499     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12500     if (SWIG_arg_fail(1)) SWIG_fail;
12501     {
12502         arg2 = &temp2;
12503         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12504     }
12505     {
12506         PyThreadState* __tstate = wxPyBeginAllowThreads();
12507         (arg1)->SetMargins((wxPoint const &)*arg2);
12508
12509         wxPyEndAllowThreads(__tstate);
12510         if (PyErr_Occurred()) SWIG_fail;
12511     }
12512     Py_INCREF(Py_None); resultobj = Py_None;
12513     return resultobj;
12514     fail:
12515     return NULL;
12516 }
12517
12518
12519 static PyObject *_wrap_VListBox_SetMarginsXY(PyObject *, PyObject *args, PyObject *kwargs) {
12520     PyObject *resultobj;
12521     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12522     int arg2 ;
12523     int arg3 ;
12524     PyObject * obj0 = 0 ;
12525     PyObject * obj1 = 0 ;
12526     PyObject * obj2 = 0 ;
12527     char *kwnames[] = {
12528         (char *) "self",(char *) "x",(char *) "y", NULL
12529     };
12530
12531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox_SetMarginsXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
12532     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12533     if (SWIG_arg_fail(1)) SWIG_fail;
12534     {
12535         arg2 = (int)(SWIG_As_int(obj1));
12536         if (SWIG_arg_fail(2)) SWIG_fail;
12537     }
12538     {
12539         arg3 = (int)(SWIG_As_int(obj2));
12540         if (SWIG_arg_fail(3)) SWIG_fail;
12541     }
12542     {
12543         PyThreadState* __tstate = wxPyBeginAllowThreads();
12544         (arg1)->SetMargins(arg2,arg3);
12545
12546         wxPyEndAllowThreads(__tstate);
12547         if (PyErr_Occurred()) SWIG_fail;
12548     }
12549     Py_INCREF(Py_None); resultobj = Py_None;
12550     return resultobj;
12551     fail:
12552     return NULL;
12553 }
12554
12555
12556 static PyObject *_wrap_VListBox_SetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
12557     PyObject *resultobj;
12558     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12559     wxColour *arg2 = 0 ;
12560     wxColour temp2 ;
12561     PyObject * obj0 = 0 ;
12562     PyObject * obj1 = 0 ;
12563     char *kwnames[] = {
12564         (char *) "self",(char *) "col", NULL
12565     };
12566
12567     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetSelectionBackground",kwnames,&obj0,&obj1)) goto fail;
12568     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12569     if (SWIG_arg_fail(1)) SWIG_fail;
12570     {
12571         arg2 = &temp2;
12572         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12573     }
12574     {
12575         PyThreadState* __tstate = wxPyBeginAllowThreads();
12576         (arg1)->SetSelectionBackground((wxColour const &)*arg2);
12577
12578         wxPyEndAllowThreads(__tstate);
12579         if (PyErr_Occurred()) SWIG_fail;
12580     }
12581     Py_INCREF(Py_None); resultobj = Py_None;
12582     return resultobj;
12583     fail:
12584     return NULL;
12585 }
12586
12587
12588 static PyObject * VListBox_swigregister(PyObject *, PyObject *args) {
12589     PyObject *obj;
12590     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12591     SWIG_TypeClientData(SWIGTYPE_p_wxPyVListBox, obj);
12592     Py_INCREF(obj);
12593     return Py_BuildValue((char *)"");
12594 }
12595 static PyObject *_wrap_new_HtmlListBox(PyObject *, PyObject *args, PyObject *kwargs) {
12596     PyObject *resultobj;
12597     wxWindow *arg1 = (wxWindow *) 0 ;
12598     int arg2 = (int) wxID_ANY ;
12599     wxPoint const &arg3_defvalue = wxDefaultPosition ;
12600     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
12601     wxSize const &arg4_defvalue = wxDefaultSize ;
12602     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
12603     long arg5 = (long) 0 ;
12604     wxString const &arg6_defvalue = wxPyVListBoxNameStr ;
12605     wxString *arg6 = (wxString *) &arg6_defvalue ;
12606     wxPyHtmlListBox *result;
12607     wxPoint temp3 ;
12608     wxSize temp4 ;
12609     bool temp6 = false ;
12610     PyObject * obj0 = 0 ;
12611     PyObject * obj1 = 0 ;
12612     PyObject * obj2 = 0 ;
12613     PyObject * obj3 = 0 ;
12614     PyObject * obj4 = 0 ;
12615     PyObject * obj5 = 0 ;
12616     char *kwnames[] = {
12617         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12618     };
12619
12620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_HtmlListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12621     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12622     if (SWIG_arg_fail(1)) SWIG_fail;
12623     if (obj1) {
12624         {
12625             arg2 = (int)(SWIG_As_int(obj1));
12626             if (SWIG_arg_fail(2)) SWIG_fail;
12627         }
12628     }
12629     if (obj2) {
12630         {
12631             arg3 = &temp3;
12632             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12633         }
12634     }
12635     if (obj3) {
12636         {
12637             arg4 = &temp4;
12638             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
12639         }
12640     }
12641     if (obj4) {
12642         {
12643             arg5 = (long)(SWIG_As_long(obj4));
12644             if (SWIG_arg_fail(5)) SWIG_fail;
12645         }
12646     }
12647     if (obj5) {
12648         {
12649             arg6 = wxString_in_helper(obj5);
12650             if (arg6 == NULL) SWIG_fail;
12651             temp6 = true;
12652         }
12653     }
12654     {
12655         if (!wxPyCheckForApp()) SWIG_fail;
12656         PyThreadState* __tstate = wxPyBeginAllowThreads();
12657         result = (wxPyHtmlListBox *)new wxPyHtmlListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
12658
12659         wxPyEndAllowThreads(__tstate);
12660         if (PyErr_Occurred()) SWIG_fail;
12661     }
12662     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyHtmlListBox, 1);
12663     {
12664         if (temp6)
12665         delete arg6;
12666     }
12667     return resultobj;
12668     fail:
12669     {
12670         if (temp6)
12671         delete arg6;
12672     }
12673     return NULL;
12674 }
12675
12676
12677 static PyObject *_wrap_new_PreHtmlListBox(PyObject *, PyObject *args, PyObject *kwargs) {
12678     PyObject *resultobj;
12679     wxPyHtmlListBox *result;
12680     char *kwnames[] = {
12681         NULL
12682     };
12683
12684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreHtmlListBox",kwnames)) goto fail;
12685     {
12686         if (!wxPyCheckForApp()) SWIG_fail;
12687         PyThreadState* __tstate = wxPyBeginAllowThreads();
12688         result = (wxPyHtmlListBox *)new wxPyHtmlListBox();
12689
12690         wxPyEndAllowThreads(__tstate);
12691         if (PyErr_Occurred()) SWIG_fail;
12692     }
12693     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyHtmlListBox, 1);
12694     return resultobj;
12695     fail:
12696     return NULL;
12697 }
12698
12699
12700 static PyObject *_wrap_HtmlListBox__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12701     PyObject *resultobj;
12702     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12703     PyObject *arg2 = (PyObject *) 0 ;
12704     PyObject *arg3 = (PyObject *) 0 ;
12705     PyObject * obj0 = 0 ;
12706     PyObject * obj1 = 0 ;
12707     PyObject * obj2 = 0 ;
12708     char *kwnames[] = {
12709         (char *) "self",(char *) "self",(char *) "_class", NULL
12710     };
12711
12712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:HtmlListBox__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
12713     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12714     if (SWIG_arg_fail(1)) SWIG_fail;
12715     arg2 = obj1;
12716     arg3 = obj2;
12717     {
12718         PyThreadState* __tstate = wxPyBeginAllowThreads();
12719         (arg1)->_setCallbackInfo(arg2,arg3);
12720
12721         wxPyEndAllowThreads(__tstate);
12722         if (PyErr_Occurred()) SWIG_fail;
12723     }
12724     Py_INCREF(Py_None); resultobj = Py_None;
12725     return resultobj;
12726     fail:
12727     return NULL;
12728 }
12729
12730
12731 static PyObject *_wrap_HtmlListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
12732     PyObject *resultobj;
12733     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12734     wxWindow *arg2 = (wxWindow *) 0 ;
12735     int arg3 = (int) wxID_ANY ;
12736     wxPoint const &arg4_defvalue = wxDefaultPosition ;
12737     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
12738     wxSize const &arg5_defvalue = wxDefaultSize ;
12739     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
12740     long arg6 = (long) 0 ;
12741     wxString const &arg7_defvalue = wxPyVListBoxNameStr ;
12742     wxString *arg7 = (wxString *) &arg7_defvalue ;
12743     bool result;
12744     wxPoint temp4 ;
12745     wxSize temp5 ;
12746     bool temp7 = false ;
12747     PyObject * obj0 = 0 ;
12748     PyObject * obj1 = 0 ;
12749     PyObject * obj2 = 0 ;
12750     PyObject * obj3 = 0 ;
12751     PyObject * obj4 = 0 ;
12752     PyObject * obj5 = 0 ;
12753     PyObject * obj6 = 0 ;
12754     char *kwnames[] = {
12755         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12756     };
12757
12758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:HtmlListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12759     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12760     if (SWIG_arg_fail(1)) SWIG_fail;
12761     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12762     if (SWIG_arg_fail(2)) SWIG_fail;
12763     if (obj2) {
12764         {
12765             arg3 = (int)(SWIG_As_int(obj2));
12766             if (SWIG_arg_fail(3)) SWIG_fail;
12767         }
12768     }
12769     if (obj3) {
12770         {
12771             arg4 = &temp4;
12772             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12773         }
12774     }
12775     if (obj4) {
12776         {
12777             arg5 = &temp5;
12778             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
12779         }
12780     }
12781     if (obj5) {
12782         {
12783             arg6 = (long)(SWIG_As_long(obj5));
12784             if (SWIG_arg_fail(6)) SWIG_fail;
12785         }
12786     }
12787     if (obj6) {
12788         {
12789             arg7 = wxString_in_helper(obj6);
12790             if (arg7 == NULL) SWIG_fail;
12791             temp7 = true;
12792         }
12793     }
12794     {
12795         PyThreadState* __tstate = wxPyBeginAllowThreads();
12796         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
12797
12798         wxPyEndAllowThreads(__tstate);
12799         if (PyErr_Occurred()) SWIG_fail;
12800     }
12801     {
12802         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12803     }
12804     {
12805         if (temp7)
12806         delete arg7;
12807     }
12808     return resultobj;
12809     fail:
12810     {
12811         if (temp7)
12812         delete arg7;
12813     }
12814     return NULL;
12815 }
12816
12817
12818 static PyObject *_wrap_HtmlListBox_RefreshAll(PyObject *, PyObject *args, PyObject *kwargs) {
12819     PyObject *resultobj;
12820     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12821     PyObject * obj0 = 0 ;
12822     char *kwnames[] = {
12823         (char *) "self", NULL
12824     };
12825
12826     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HtmlListBox_RefreshAll",kwnames,&obj0)) goto fail;
12827     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12828     if (SWIG_arg_fail(1)) SWIG_fail;
12829     {
12830         PyThreadState* __tstate = wxPyBeginAllowThreads();
12831         (arg1)->RefreshAll();
12832
12833         wxPyEndAllowThreads(__tstate);
12834         if (PyErr_Occurred()) SWIG_fail;
12835     }
12836     Py_INCREF(Py_None); resultobj = Py_None;
12837     return resultobj;
12838     fail:
12839     return NULL;
12840 }
12841
12842
12843 static PyObject *_wrap_HtmlListBox_SetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
12844     PyObject *resultobj;
12845     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12846     size_t arg2 ;
12847     PyObject * obj0 = 0 ;
12848     PyObject * obj1 = 0 ;
12849     char *kwnames[] = {
12850         (char *) "self",(char *) "count", NULL
12851     };
12852
12853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HtmlListBox_SetItemCount",kwnames,&obj0,&obj1)) goto fail;
12854     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12855     if (SWIG_arg_fail(1)) SWIG_fail;
12856     {
12857         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12858         if (SWIG_arg_fail(2)) SWIG_fail;
12859     }
12860     {
12861         PyThreadState* __tstate = wxPyBeginAllowThreads();
12862         (arg1)->SetItemCount(arg2);
12863
12864         wxPyEndAllowThreads(__tstate);
12865         if (PyErr_Occurred()) SWIG_fail;
12866     }
12867     Py_INCREF(Py_None); resultobj = Py_None;
12868     return resultobj;
12869     fail:
12870     return NULL;
12871 }
12872
12873
12874 static PyObject *_wrap_HtmlListBox_GetFileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
12875     PyObject *resultobj;
12876     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12877     wxFileSystem *result;
12878     PyObject * obj0 = 0 ;
12879     char *kwnames[] = {
12880         (char *) "self", NULL
12881     };
12882
12883     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HtmlListBox_GetFileSystem",kwnames,&obj0)) goto fail;
12884     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12885     if (SWIG_arg_fail(1)) SWIG_fail;
12886     {
12887         PyThreadState* __tstate = wxPyBeginAllowThreads();
12888         {
12889             wxFileSystem &_result_ref = (arg1)->GetFileSystem();
12890             result = (wxFileSystem *) &_result_ref;
12891         }
12892
12893         wxPyEndAllowThreads(__tstate);
12894         if (PyErr_Occurred()) SWIG_fail;
12895     }
12896     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileSystem, 0);
12897     return resultobj;
12898     fail:
12899     return NULL;
12900 }
12901
12902
12903 static PyObject * HtmlListBox_swigregister(PyObject *, PyObject *args) {
12904     PyObject *obj;
12905     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12906     SWIG_TypeClientData(SWIGTYPE_p_wxPyHtmlListBox, obj);
12907     Py_INCREF(obj);
12908     return Py_BuildValue((char *)"");
12909 }
12910 static PyObject *_wrap_new_TaskBarIcon(PyObject *, PyObject *args, PyObject *kwargs) {
12911     PyObject *resultobj;
12912     wxPyTaskBarIcon *result;
12913     char *kwnames[] = {
12914         NULL
12915     };
12916
12917     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TaskBarIcon",kwnames)) goto fail;
12918     {
12919         if (!wxPyCheckForApp()) SWIG_fail;
12920         PyThreadState* __tstate = wxPyBeginAllowThreads();
12921         result = (wxPyTaskBarIcon *)new wxPyTaskBarIcon();
12922
12923         wxPyEndAllowThreads(__tstate);
12924         if (PyErr_Occurred()) SWIG_fail;
12925     }
12926     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTaskBarIcon, 1);
12927     return resultobj;
12928     fail:
12929     return NULL;
12930 }
12931
12932
12933 static PyObject *_wrap_TaskBarIcon__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12934     PyObject *resultobj;
12935     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12936     PyObject *arg2 = (PyObject *) 0 ;
12937     PyObject *arg3 = (PyObject *) 0 ;
12938     int arg4 ;
12939     PyObject * obj0 = 0 ;
12940     PyObject * obj1 = 0 ;
12941     PyObject * obj2 = 0 ;
12942     PyObject * obj3 = 0 ;
12943     char *kwnames[] = {
12944         (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
12945     };
12946
12947     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TaskBarIcon__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12948     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12949     if (SWIG_arg_fail(1)) SWIG_fail;
12950     arg2 = obj1;
12951     arg3 = obj2;
12952     {
12953         arg4 = (int)(SWIG_As_int(obj3));
12954         if (SWIG_arg_fail(4)) SWIG_fail;
12955     }
12956     {
12957         PyThreadState* __tstate = wxPyBeginAllowThreads();
12958         (arg1)->_setCallbackInfo(arg2,arg3,arg4);
12959
12960         wxPyEndAllowThreads(__tstate);
12961         if (PyErr_Occurred()) SWIG_fail;
12962     }
12963     Py_INCREF(Py_None); resultobj = Py_None;
12964     return resultobj;
12965     fail:
12966     return NULL;
12967 }
12968
12969
12970 static PyObject *_wrap_TaskBarIcon_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
12971     PyObject *resultobj;
12972     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12973     PyObject * obj0 = 0 ;
12974     char *kwnames[] = {
12975         (char *) "self", NULL
12976     };
12977
12978     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_Destroy",kwnames,&obj0)) goto fail;
12979     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12980     if (SWIG_arg_fail(1)) SWIG_fail;
12981     {
12982         PyThreadState* __tstate = wxPyBeginAllowThreads();
12983         wxPyTaskBarIcon_Destroy(arg1);
12984
12985         wxPyEndAllowThreads(__tstate);
12986         if (PyErr_Occurred()) SWIG_fail;
12987     }
12988     Py_INCREF(Py_None); resultobj = Py_None;
12989     return resultobj;
12990     fail:
12991     return NULL;
12992 }
12993
12994
12995 static PyObject *_wrap_TaskBarIcon_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12996     PyObject *resultobj;
12997     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12998     bool result;
12999     PyObject * obj0 = 0 ;
13000     char *kwnames[] = {
13001         (char *) "self", NULL
13002     };
13003
13004     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_IsOk",kwnames,&obj0)) goto fail;
13005     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13006     if (SWIG_arg_fail(1)) SWIG_fail;
13007     {
13008         PyThreadState* __tstate = wxPyBeginAllowThreads();
13009         result = (bool)((wxPyTaskBarIcon const *)arg1)->IsOk();
13010
13011         wxPyEndAllowThreads(__tstate);
13012         if (PyErr_Occurred()) SWIG_fail;
13013     }
13014     {
13015         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13016     }
13017     return resultobj;
13018     fail:
13019     return NULL;
13020 }
13021
13022
13023 static PyObject *_wrap_TaskBarIcon_IsIconInstalled(PyObject *, PyObject *args, PyObject *kwargs) {
13024     PyObject *resultobj;
13025     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13026     bool result;
13027     PyObject * obj0 = 0 ;
13028     char *kwnames[] = {
13029         (char *) "self", NULL
13030     };
13031
13032     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_IsIconInstalled",kwnames,&obj0)) goto fail;
13033     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13034     if (SWIG_arg_fail(1)) SWIG_fail;
13035     {
13036         PyThreadState* __tstate = wxPyBeginAllowThreads();
13037         result = (bool)((wxPyTaskBarIcon const *)arg1)->IsIconInstalled();
13038
13039         wxPyEndAllowThreads(__tstate);
13040         if (PyErr_Occurred()) SWIG_fail;
13041     }
13042     {
13043         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13044     }
13045     return resultobj;
13046     fail:
13047     return NULL;
13048 }
13049
13050
13051 static PyObject *_wrap_TaskBarIcon_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13052     PyObject *resultobj;
13053     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13054     wxIcon *arg2 = 0 ;
13055     wxString const &arg3_defvalue = wxPyEmptyString ;
13056     wxString *arg3 = (wxString *) &arg3_defvalue ;
13057     bool result;
13058     bool temp3 = false ;
13059     PyObject * obj0 = 0 ;
13060     PyObject * obj1 = 0 ;
13061     PyObject * obj2 = 0 ;
13062     char *kwnames[] = {
13063         (char *) "self",(char *) "icon",(char *) "tooltip", NULL
13064     };
13065
13066     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TaskBarIcon_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13067     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13068     if (SWIG_arg_fail(1)) SWIG_fail;
13069     {
13070         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13071         if (SWIG_arg_fail(2)) SWIG_fail;
13072         if (arg2 == NULL) {
13073             SWIG_null_ref("wxIcon");
13074         }
13075         if (SWIG_arg_fail(2)) SWIG_fail;
13076     }
13077     if (obj2) {
13078         {
13079             arg3 = wxString_in_helper(obj2);
13080             if (arg3 == NULL) SWIG_fail;
13081             temp3 = true;
13082         }
13083     }
13084     {
13085         PyThreadState* __tstate = wxPyBeginAllowThreads();
13086         result = (bool)(arg1)->SetIcon((wxIcon const &)*arg2,(wxString const &)*arg3);
13087
13088         wxPyEndAllowThreads(__tstate);
13089         if (PyErr_Occurred()) SWIG_fail;
13090     }
13091     {
13092         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13093     }
13094     {
13095         if (temp3)
13096         delete arg3;
13097     }
13098     return resultobj;
13099     fail:
13100     {
13101         if (temp3)
13102         delete arg3;
13103     }
13104     return NULL;
13105 }
13106
13107
13108 static PyObject *_wrap_TaskBarIcon_RemoveIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13109     PyObject *resultobj;
13110     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13111     bool result;
13112     PyObject * obj0 = 0 ;
13113     char *kwnames[] = {
13114         (char *) "self", NULL
13115     };
13116
13117     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_RemoveIcon",kwnames,&obj0)) goto fail;
13118     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13119     if (SWIG_arg_fail(1)) SWIG_fail;
13120     {
13121         PyThreadState* __tstate = wxPyBeginAllowThreads();
13122         result = (bool)(arg1)->RemoveIcon();
13123
13124         wxPyEndAllowThreads(__tstate);
13125         if (PyErr_Occurred()) SWIG_fail;
13126     }
13127     {
13128         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13129     }
13130     return resultobj;
13131     fail:
13132     return NULL;
13133 }
13134
13135
13136 static PyObject *_wrap_TaskBarIcon_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
13137     PyObject *resultobj;
13138     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13139     wxMenu *arg2 = (wxMenu *) 0 ;
13140     bool result;
13141     PyObject * obj0 = 0 ;
13142     PyObject * obj1 = 0 ;
13143     char *kwnames[] = {
13144         (char *) "self",(char *) "menu", NULL
13145     };
13146
13147     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TaskBarIcon_PopupMenu",kwnames,&obj0,&obj1)) goto fail;
13148     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13149     if (SWIG_arg_fail(1)) SWIG_fail;
13150     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
13151     if (SWIG_arg_fail(2)) SWIG_fail;
13152     {
13153         PyThreadState* __tstate = wxPyBeginAllowThreads();
13154         result = (bool)(arg1)->PopupMenu(arg2);
13155
13156         wxPyEndAllowThreads(__tstate);
13157         if (PyErr_Occurred()) SWIG_fail;
13158     }
13159     {
13160         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13161     }
13162     return resultobj;
13163     fail:
13164     return NULL;
13165 }
13166
13167
13168 static PyObject * TaskBarIcon_swigregister(PyObject *, PyObject *args) {
13169     PyObject *obj;
13170     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13171     SWIG_TypeClientData(SWIGTYPE_p_wxPyTaskBarIcon, obj);
13172     Py_INCREF(obj);
13173     return Py_BuildValue((char *)"");
13174 }
13175 static PyObject *_wrap_new_TaskBarIconEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13176     PyObject *resultobj;
13177     wxEventType arg1 ;
13178     wxTaskBarIcon *arg2 = (wxTaskBarIcon *) 0 ;
13179     wxTaskBarIconEvent *result;
13180     PyObject * obj0 = 0 ;
13181     PyObject * obj1 = 0 ;
13182     char *kwnames[] = {
13183         (char *) "evtType",(char *) "tbIcon", NULL
13184     };
13185
13186     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_TaskBarIconEvent",kwnames,&obj0,&obj1)) goto fail;
13187     {
13188         arg1 = (wxEventType)(SWIG_As_int(obj0));
13189         if (SWIG_arg_fail(1)) SWIG_fail;
13190     }
13191     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13192     if (SWIG_arg_fail(2)) SWIG_fail;
13193     {
13194         PyThreadState* __tstate = wxPyBeginAllowThreads();
13195         result = (wxTaskBarIconEvent *)new wxTaskBarIconEvent(arg1,arg2);
13196
13197         wxPyEndAllowThreads(__tstate);
13198         if (PyErr_Occurred()) SWIG_fail;
13199     }
13200     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTaskBarIconEvent, 1);
13201     return resultobj;
13202     fail:
13203     return NULL;
13204 }
13205
13206
13207 static PyObject * TaskBarIconEvent_swigregister(PyObject *, PyObject *args) {
13208     PyObject *obj;
13209     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13210     SWIG_TypeClientData(SWIGTYPE_p_wxTaskBarIconEvent, obj);
13211     Py_INCREF(obj);
13212     return Py_BuildValue((char *)"");
13213 }
13214 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
13215     PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
13216     return 1;
13217 }
13218
13219
13220 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
13221     PyObject *pyobj;
13222
13223     {
13224 #if wxUSE_UNICODE
13225         pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
13226 #else
13227         pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
13228 #endif
13229     }
13230     return pyobj;
13231 }
13232
13233
13234 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
13235     PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
13236     return 1;
13237 }
13238
13239
13240 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
13241     PyObject *pyobj;
13242
13243     {
13244 #if wxUSE_UNICODE
13245         pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
13246 #else
13247         pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
13248 #endif
13249     }
13250     return pyobj;
13251 }
13252
13253
13254 static int _wrap_DirDialogNameStr_set(PyObject *) {
13255     PyErr_SetString(PyExc_TypeError,"Variable DirDialogNameStr is read-only.");
13256     return 1;
13257 }
13258
13259
13260 static PyObject *_wrap_DirDialogNameStr_get(void) {
13261     PyObject *pyobj;
13262
13263     {
13264 #if wxUSE_UNICODE
13265         pyobj = PyUnicode_FromWideChar((&wxPyDirDialogNameStr)->c_str(), (&wxPyDirDialogNameStr)->Len());
13266 #else
13267         pyobj = PyString_FromStringAndSize((&wxPyDirDialogNameStr)->c_str(), (&wxPyDirDialogNameStr)->Len());
13268 #endif
13269     }
13270     return pyobj;
13271 }
13272
13273
13274 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
13275     PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
13276     return 1;
13277 }
13278
13279
13280 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
13281     PyObject *pyobj;
13282
13283     {
13284 #if wxUSE_UNICODE
13285         pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
13286 #else
13287         pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
13288 #endif
13289     }
13290     return pyobj;
13291 }
13292
13293
13294 static int _wrap_GetTextFromUserPromptStr_set(PyObject *) {
13295     PyErr_SetString(PyExc_TypeError,"Variable GetTextFromUserPromptStr is read-only.");
13296     return 1;
13297 }
13298
13299
13300 static PyObject *_wrap_GetTextFromUserPromptStr_get(void) {
13301     PyObject *pyobj;
13302
13303     {
13304 #if wxUSE_UNICODE
13305         pyobj = PyUnicode_FromWideChar((&wxPyGetTextFromUserPromptStr)->c_str(), (&wxPyGetTextFromUserPromptStr)->Len());
13306 #else
13307         pyobj = PyString_FromStringAndSize((&wxPyGetTextFromUserPromptStr)->c_str(), (&wxPyGetTextFromUserPromptStr)->Len());
13308 #endif
13309     }
13310     return pyobj;
13311 }
13312
13313
13314 static int _wrap_MessageBoxCaptionStr_set(PyObject *) {
13315     PyErr_SetString(PyExc_TypeError,"Variable MessageBoxCaptionStr is read-only.");
13316     return 1;
13317 }
13318
13319
13320 static PyObject *_wrap_MessageBoxCaptionStr_get(void) {
13321     PyObject *pyobj;
13322
13323     {
13324 #if wxUSE_UNICODE
13325         pyobj = PyUnicode_FromWideChar((&wxPyMessageBoxCaptionStr)->c_str(), (&wxPyMessageBoxCaptionStr)->Len());
13326 #else
13327         pyobj = PyString_FromStringAndSize((&wxPyMessageBoxCaptionStr)->c_str(), (&wxPyMessageBoxCaptionStr)->Len());
13328 #endif
13329     }
13330     return pyobj;
13331 }
13332
13333
13334 static PyObject *_wrap_new_ColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13335     PyObject *resultobj;
13336     wxColourData *result;
13337     char *kwnames[] = {
13338         NULL
13339     };
13340
13341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourData",kwnames)) goto fail;
13342     {
13343         PyThreadState* __tstate = wxPyBeginAllowThreads();
13344         result = (wxColourData *)new wxColourData();
13345
13346         wxPyEndAllowThreads(__tstate);
13347         if (PyErr_Occurred()) SWIG_fail;
13348     }
13349     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourData, 1);
13350     return resultobj;
13351     fail:
13352     return NULL;
13353 }
13354
13355
13356 static PyObject *_wrap_delete_ColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13357     PyObject *resultobj;
13358     wxColourData *arg1 = (wxColourData *) 0 ;
13359     PyObject * obj0 = 0 ;
13360     char *kwnames[] = {
13361         (char *) "self", NULL
13362     };
13363
13364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourData",kwnames,&obj0)) goto fail;
13365     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13366     if (SWIG_arg_fail(1)) SWIG_fail;
13367     {
13368         PyThreadState* __tstate = wxPyBeginAllowThreads();
13369         delete arg1;
13370
13371         wxPyEndAllowThreads(__tstate);
13372         if (PyErr_Occurred()) SWIG_fail;
13373     }
13374     Py_INCREF(Py_None); resultobj = Py_None;
13375     return resultobj;
13376     fail:
13377     return NULL;
13378 }
13379
13380
13381 static PyObject *_wrap_ColourData_GetChooseFull(PyObject *, PyObject *args, PyObject *kwargs) {
13382     PyObject *resultobj;
13383     wxColourData *arg1 = (wxColourData *) 0 ;
13384     bool result;
13385     PyObject * obj0 = 0 ;
13386     char *kwnames[] = {
13387         (char *) "self", NULL
13388     };
13389
13390     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourData_GetChooseFull",kwnames,&obj0)) goto fail;
13391     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13392     if (SWIG_arg_fail(1)) SWIG_fail;
13393     {
13394         PyThreadState* __tstate = wxPyBeginAllowThreads();
13395         result = (bool)(arg1)->GetChooseFull();
13396
13397         wxPyEndAllowThreads(__tstate);
13398         if (PyErr_Occurred()) SWIG_fail;
13399     }
13400     {
13401         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13402     }
13403     return resultobj;
13404     fail:
13405     return NULL;
13406 }
13407
13408
13409 static PyObject *_wrap_ColourData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
13410     PyObject *resultobj;
13411     wxColourData *arg1 = (wxColourData *) 0 ;
13412     wxColour result;
13413     PyObject * obj0 = 0 ;
13414     char *kwnames[] = {
13415         (char *) "self", NULL
13416     };
13417
13418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourData_GetColour",kwnames,&obj0)) goto fail;
13419     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13420     if (SWIG_arg_fail(1)) SWIG_fail;
13421     {
13422         PyThreadState* __tstate = wxPyBeginAllowThreads();
13423         result = (arg1)->GetColour();
13424
13425         wxPyEndAllowThreads(__tstate);
13426         if (PyErr_Occurred()) SWIG_fail;
13427     }
13428     {
13429         wxColour * resultptr;
13430         resultptr = new wxColour((wxColour &)(result));
13431         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13432     }
13433     return resultobj;
13434     fail:
13435     return NULL;
13436 }
13437
13438
13439 static PyObject *_wrap_ColourData_GetCustomColour(PyObject *, PyObject *args, PyObject *kwargs) {
13440     PyObject *resultobj;
13441     wxColourData *arg1 = (wxColourData *) 0 ;
13442     int arg2 ;
13443     wxColour result;
13444     PyObject * obj0 = 0 ;
13445     PyObject * obj1 = 0 ;
13446     char *kwnames[] = {
13447         (char *) "self",(char *) "i", NULL
13448     };
13449
13450     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_GetCustomColour",kwnames,&obj0,&obj1)) goto fail;
13451     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13452     if (SWIG_arg_fail(1)) SWIG_fail;
13453     {
13454         arg2 = (int)(SWIG_As_int(obj1));
13455         if (SWIG_arg_fail(2)) SWIG_fail;
13456     }
13457     {
13458         PyThreadState* __tstate = wxPyBeginAllowThreads();
13459         result = (arg1)->GetCustomColour(arg2);
13460
13461         wxPyEndAllowThreads(__tstate);
13462         if (PyErr_Occurred()) SWIG_fail;
13463     }
13464     {
13465         wxColour * resultptr;
13466         resultptr = new wxColour((wxColour &)(result));
13467         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13468     }
13469     return resultobj;
13470     fail:
13471     return NULL;
13472 }
13473
13474
13475 static PyObject *_wrap_ColourData_SetChooseFull(PyObject *, PyObject *args, PyObject *kwargs) {
13476     PyObject *resultobj;
13477     wxColourData *arg1 = (wxColourData *) 0 ;
13478     int arg2 ;
13479     PyObject * obj0 = 0 ;
13480     PyObject * obj1 = 0 ;
13481     char *kwnames[] = {
13482         (char *) "self",(char *) "flag", NULL
13483     };
13484
13485     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_SetChooseFull",kwnames,&obj0,&obj1)) goto fail;
13486     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13487     if (SWIG_arg_fail(1)) SWIG_fail;
13488     {
13489         arg2 = (int)(SWIG_As_int(obj1));
13490         if (SWIG_arg_fail(2)) SWIG_fail;
13491     }
13492     {
13493         PyThreadState* __tstate = wxPyBeginAllowThreads();
13494         (arg1)->SetChooseFull(arg2);
13495
13496         wxPyEndAllowThreads(__tstate);
13497         if (PyErr_Occurred()) SWIG_fail;
13498     }
13499     Py_INCREF(Py_None); resultobj = Py_None;
13500     return resultobj;
13501     fail:
13502     return NULL;
13503 }
13504
13505
13506 static PyObject *_wrap_ColourData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
13507     PyObject *resultobj;
13508     wxColourData *arg1 = (wxColourData *) 0 ;
13509     wxColour *arg2 = 0 ;
13510     wxColour temp2 ;
13511     PyObject * obj0 = 0 ;
13512     PyObject * obj1 = 0 ;
13513     char *kwnames[] = {
13514         (char *) "self",(char *) "colour", NULL
13515     };
13516
13517     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_SetColour",kwnames,&obj0,&obj1)) goto fail;
13518     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13519     if (SWIG_arg_fail(1)) SWIG_fail;
13520     {
13521         arg2 = &temp2;
13522         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13523     }
13524     {
13525         PyThreadState* __tstate = wxPyBeginAllowThreads();
13526         (arg1)->SetColour((wxColour const &)*arg2);
13527
13528         wxPyEndAllowThreads(__tstate);
13529         if (PyErr_Occurred()) SWIG_fail;
13530     }
13531     Py_INCREF(Py_None); resultobj = Py_None;
13532     return resultobj;
13533     fail:
13534     return NULL;
13535 }
13536
13537
13538 static PyObject *_wrap_ColourData_SetCustomColour(PyObject *, PyObject *args, PyObject *kwargs) {
13539     PyObject *resultobj;
13540     wxColourData *arg1 = (wxColourData *) 0 ;
13541     int arg2 ;
13542     wxColour *arg3 = 0 ;
13543     wxColour temp3 ;
13544     PyObject * obj0 = 0 ;
13545     PyObject * obj1 = 0 ;
13546     PyObject * obj2 = 0 ;
13547     char *kwnames[] = {
13548         (char *) "self",(char *) "i",(char *) "colour", NULL
13549     };
13550
13551     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourData_SetCustomColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13552     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13553     if (SWIG_arg_fail(1)) SWIG_fail;
13554     {
13555         arg2 = (int)(SWIG_As_int(obj1));
13556         if (SWIG_arg_fail(2)) SWIG_fail;
13557     }
13558     {
13559         arg3 = &temp3;
13560         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13561     }
13562     {
13563         PyThreadState* __tstate = wxPyBeginAllowThreads();
13564         (arg1)->SetCustomColour(arg2,(wxColour const &)*arg3);
13565
13566         wxPyEndAllowThreads(__tstate);
13567         if (PyErr_Occurred()) SWIG_fail;
13568     }
13569     Py_INCREF(Py_None); resultobj = Py_None;
13570     return resultobj;
13571     fail:
13572     return NULL;
13573 }
13574
13575
13576 static PyObject * ColourData_swigregister(PyObject *, PyObject *args) {
13577     PyObject *obj;
13578     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13579     SWIG_TypeClientData(SWIGTYPE_p_wxColourData, obj);
13580     Py_INCREF(obj);
13581     return Py_BuildValue((char *)"");
13582 }
13583 static PyObject *_wrap_new_ColourDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13584     PyObject *resultobj;
13585     wxWindow *arg1 = (wxWindow *) 0 ;
13586     wxColourData *arg2 = (wxColourData *) NULL ;
13587     wxColourDialog *result;
13588     PyObject * obj0 = 0 ;
13589     PyObject * obj1 = 0 ;
13590     char *kwnames[] = {
13591         (char *) "parent",(char *) "data", NULL
13592     };
13593
13594     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_ColourDialog",kwnames,&obj0,&obj1)) goto fail;
13595     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13596     if (SWIG_arg_fail(1)) SWIG_fail;
13597     if (obj1) {
13598         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13599         if (SWIG_arg_fail(2)) SWIG_fail;
13600     }
13601     {
13602         if (!wxPyCheckForApp()) SWIG_fail;
13603         PyThreadState* __tstate = wxPyBeginAllowThreads();
13604         result = (wxColourDialog *)new wxColourDialog(arg1,arg2);
13605
13606         wxPyEndAllowThreads(__tstate);
13607         if (PyErr_Occurred()) SWIG_fail;
13608     }
13609     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDialog, 1);
13610     return resultobj;
13611     fail:
13612     return NULL;
13613 }
13614
13615
13616 static PyObject *_wrap_ColourDialog_GetColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13617     PyObject *resultobj;
13618     wxColourDialog *arg1 = (wxColourDialog *) 0 ;
13619     wxColourData *result;
13620     PyObject * obj0 = 0 ;
13621     char *kwnames[] = {
13622         (char *) "self", NULL
13623     };
13624
13625     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourDialog_GetColourData",kwnames,&obj0)) goto fail;
13626     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDialog, SWIG_POINTER_EXCEPTION | 0);
13627     if (SWIG_arg_fail(1)) SWIG_fail;
13628     {
13629         PyThreadState* __tstate = wxPyBeginAllowThreads();
13630         {
13631             wxColourData &_result_ref = (arg1)->GetColourData();
13632             result = (wxColourData *) &_result_ref;
13633         }
13634
13635         wxPyEndAllowThreads(__tstate);
13636         if (PyErr_Occurred()) SWIG_fail;
13637     }
13638     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourData, 0);
13639     return resultobj;
13640     fail:
13641     return NULL;
13642 }
13643
13644
13645 static PyObject * ColourDialog_swigregister(PyObject *, PyObject *args) {
13646     PyObject *obj;
13647     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13648     SWIG_TypeClientData(SWIGTYPE_p_wxColourDialog, obj);
13649     Py_INCREF(obj);
13650     return Py_BuildValue((char *)"");
13651 }
13652 static PyObject *_wrap_new_DirDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13653     PyObject *resultobj;
13654     wxWindow *arg1 = (wxWindow *) 0 ;
13655     wxString const &arg2_defvalue = wxPyDirSelectorPromptStr ;
13656     wxString *arg2 = (wxString *) &arg2_defvalue ;
13657     wxString const &arg3_defvalue = wxPyEmptyString ;
13658     wxString *arg3 = (wxString *) &arg3_defvalue ;
13659     long arg4 = (long) 0 ;
13660     wxPoint const &arg5_defvalue = wxDefaultPosition ;
13661     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
13662     wxSize const &arg6_defvalue = wxDefaultSize ;
13663     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
13664     wxString const &arg7_defvalue = wxPyDirDialogNameStr ;
13665     wxString *arg7 = (wxString *) &arg7_defvalue ;
13666     wxDirDialog *result;
13667     bool temp2 = false ;
13668     bool temp3 = false ;
13669     wxPoint temp5 ;
13670     wxSize temp6 ;
13671     bool temp7 = false ;
13672     PyObject * obj0 = 0 ;
13673     PyObject * obj1 = 0 ;
13674     PyObject * obj2 = 0 ;
13675     PyObject * obj3 = 0 ;
13676     PyObject * obj4 = 0 ;
13677     PyObject * obj5 = 0 ;
13678     PyObject * obj6 = 0 ;
13679     char *kwnames[] = {
13680         (char *) "parent",(char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "size",(char *) "name", NULL
13681     };
13682
13683     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DirDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13684     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13685     if (SWIG_arg_fail(1)) SWIG_fail;
13686     if (obj1) {
13687         {
13688             arg2 = wxString_in_helper(obj1);
13689             if (arg2 == NULL) SWIG_fail;
13690             temp2 = true;
13691         }
13692     }
13693     if (obj2) {
13694         {
13695             arg3 = wxString_in_helper(obj2);
13696             if (arg3 == NULL) SWIG_fail;
13697             temp3 = true;
13698         }
13699     }
13700     if (obj3) {
13701         {
13702             arg4 = (long)(SWIG_As_long(obj3));
13703             if (SWIG_arg_fail(4)) SWIG_fail;
13704         }
13705     }
13706     if (obj4) {
13707         {
13708             arg5 = &temp5;
13709             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13710         }
13711     }
13712     if (obj5) {
13713         {
13714             arg6 = &temp6;
13715             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
13716         }
13717     }
13718     if (obj6) {
13719         {
13720             arg7 = wxString_in_helper(obj6);
13721             if (arg7 == NULL) SWIG_fail;
13722             temp7 = true;
13723         }
13724     }
13725     {
13726         if (!wxPyCheckForApp()) SWIG_fail;
13727         PyThreadState* __tstate = wxPyBeginAllowThreads();
13728         result = (wxDirDialog *)new wxDirDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,(wxString const &)*arg7);
13729
13730         wxPyEndAllowThreads(__tstate);
13731         if (PyErr_Occurred()) SWIG_fail;
13732     }
13733     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDirDialog, 1);
13734     {
13735         if (temp2)
13736         delete arg2;
13737     }
13738     {
13739         if (temp3)
13740         delete arg3;
13741     }
13742     {
13743         if (temp7)
13744         delete arg7;
13745     }
13746     return resultobj;
13747     fail:
13748     {
13749         if (temp2)
13750         delete arg2;
13751     }
13752     {
13753         if (temp3)
13754         delete arg3;
13755     }
13756     {
13757         if (temp7)
13758         delete arg7;
13759     }
13760     return NULL;
13761 }
13762
13763
13764 static PyObject *_wrap_DirDialog_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
13765     PyObject *resultobj;
13766     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13767     wxString result;
13768     PyObject * obj0 = 0 ;
13769     char *kwnames[] = {
13770         (char *) "self", NULL
13771     };
13772
13773     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetPath",kwnames,&obj0)) goto fail;
13774     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13775     if (SWIG_arg_fail(1)) SWIG_fail;
13776     {
13777         PyThreadState* __tstate = wxPyBeginAllowThreads();
13778         result = (arg1)->GetPath();
13779
13780         wxPyEndAllowThreads(__tstate);
13781         if (PyErr_Occurred()) SWIG_fail;
13782     }
13783     {
13784 #if wxUSE_UNICODE
13785         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13786 #else
13787         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13788 #endif
13789     }
13790     return resultobj;
13791     fail:
13792     return NULL;
13793 }
13794
13795
13796 static PyObject *_wrap_DirDialog_GetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
13797     PyObject *resultobj;
13798     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13799     wxString result;
13800     PyObject * obj0 = 0 ;
13801     char *kwnames[] = {
13802         (char *) "self", NULL
13803     };
13804
13805     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetMessage",kwnames,&obj0)) goto fail;
13806     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13807     if (SWIG_arg_fail(1)) SWIG_fail;
13808     {
13809         PyThreadState* __tstate = wxPyBeginAllowThreads();
13810         result = (arg1)->GetMessage();
13811
13812         wxPyEndAllowThreads(__tstate);
13813         if (PyErr_Occurred()) SWIG_fail;
13814     }
13815     {
13816 #if wxUSE_UNICODE
13817         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13818 #else
13819         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13820 #endif
13821     }
13822     return resultobj;
13823     fail:
13824     return NULL;
13825 }
13826
13827
13828 static PyObject *_wrap_DirDialog_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
13829     PyObject *resultobj;
13830     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13831     long result;
13832     PyObject * obj0 = 0 ;
13833     char *kwnames[] = {
13834         (char *) "self", NULL
13835     };
13836
13837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetStyle",kwnames,&obj0)) goto fail;
13838     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13839     if (SWIG_arg_fail(1)) SWIG_fail;
13840     {
13841         PyThreadState* __tstate = wxPyBeginAllowThreads();
13842         result = (long)(arg1)->GetStyle();
13843
13844         wxPyEndAllowThreads(__tstate);
13845         if (PyErr_Occurred()) SWIG_fail;
13846     }
13847     {
13848         resultobj = SWIG_From_long((long)(result));
13849     }
13850     return resultobj;
13851     fail:
13852     return NULL;
13853 }
13854
13855
13856 static PyObject *_wrap_DirDialog_SetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
13857     PyObject *resultobj;
13858     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13859     wxString *arg2 = 0 ;
13860     bool temp2 = false ;
13861     PyObject * obj0 = 0 ;
13862     PyObject * obj1 = 0 ;
13863     char *kwnames[] = {
13864         (char *) "self",(char *) "message", NULL
13865     };
13866
13867     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirDialog_SetMessage",kwnames,&obj0,&obj1)) goto fail;
13868     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13869     if (SWIG_arg_fail(1)) SWIG_fail;
13870     {
13871         arg2 = wxString_in_helper(obj1);
13872         if (arg2 == NULL) SWIG_fail;
13873         temp2 = true;
13874     }
13875     {
13876         PyThreadState* __tstate = wxPyBeginAllowThreads();
13877         (arg1)->SetMessage((wxString const &)*arg2);
13878
13879         wxPyEndAllowThreads(__tstate);
13880         if (PyErr_Occurred()) SWIG_fail;
13881     }
13882     Py_INCREF(Py_None); resultobj = Py_None;
13883     {
13884         if (temp2)
13885         delete arg2;
13886     }
13887     return resultobj;
13888     fail:
13889     {
13890         if (temp2)
13891         delete arg2;
13892     }
13893     return NULL;
13894 }
13895
13896
13897 static PyObject *_wrap_DirDialog_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
13898     PyObject *resultobj;
13899     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13900     wxString *arg2 = 0 ;
13901     bool temp2 = false ;
13902     PyObject * obj0 = 0 ;
13903     PyObject * obj1 = 0 ;
13904     char *kwnames[] = {
13905         (char *) "self",(char *) "path", NULL
13906     };
13907
13908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirDialog_SetPath",kwnames,&obj0,&obj1)) goto fail;
13909     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13910     if (SWIG_arg_fail(1)) SWIG_fail;
13911     {
13912         arg2 = wxString_in_helper(obj1);
13913         if (arg2 == NULL) SWIG_fail;
13914         temp2 = true;
13915     }
13916     {
13917         PyThreadState* __tstate = wxPyBeginAllowThreads();
13918         (arg1)->SetPath((wxString const &)*arg2);
13919
13920         wxPyEndAllowThreads(__tstate);
13921         if (PyErr_Occurred()) SWIG_fail;
13922     }
13923     Py_INCREF(Py_None); resultobj = Py_None;
13924     {
13925         if (temp2)
13926         delete arg2;
13927     }
13928     return resultobj;
13929     fail:
13930     {
13931         if (temp2)
13932         delete arg2;
13933     }
13934     return NULL;
13935 }
13936
13937
13938 static PyObject * DirDialog_swigregister(PyObject *, PyObject *args) {
13939     PyObject *obj;
13940     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13941     SWIG_TypeClientData(SWIGTYPE_p_wxDirDialog, obj);
13942     Py_INCREF(obj);
13943     return Py_BuildValue((char *)"");
13944 }
13945 static PyObject *_wrap_new_FileDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13946     PyObject *resultobj;
13947     wxWindow *arg1 = (wxWindow *) 0 ;
13948     wxString const &arg2_defvalue = wxPyFileSelectorPromptStr ;
13949     wxString *arg2 = (wxString *) &arg2_defvalue ;
13950     wxString const &arg3_defvalue = wxPyEmptyString ;
13951     wxString *arg3 = (wxString *) &arg3_defvalue ;
13952     wxString const &arg4_defvalue = wxPyEmptyString ;
13953     wxString *arg4 = (wxString *) &arg4_defvalue ;
13954     wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
13955     wxString *arg5 = (wxString *) &arg5_defvalue ;
13956     long arg6 = (long) 0 ;
13957     wxPoint const &arg7_defvalue = wxDefaultPosition ;
13958     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
13959     wxFileDialog *result;
13960     bool temp2 = false ;
13961     bool temp3 = false ;
13962     bool temp4 = false ;
13963     bool temp5 = false ;
13964     wxPoint temp7 ;
13965     PyObject * obj0 = 0 ;
13966     PyObject * obj1 = 0 ;
13967     PyObject * obj2 = 0 ;
13968     PyObject * obj3 = 0 ;
13969     PyObject * obj4 = 0 ;
13970     PyObject * obj5 = 0 ;
13971     PyObject * obj6 = 0 ;
13972     char *kwnames[] = {
13973         (char *) "parent",(char *) "message",(char *) "defaultDir",(char *) "defaultFile",(char *) "wildcard",(char *) "style",(char *) "pos", NULL
13974     };
13975
13976     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_FileDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13977     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13978     if (SWIG_arg_fail(1)) SWIG_fail;
13979     if (obj1) {
13980         {
13981             arg2 = wxString_in_helper(obj1);
13982             if (arg2 == NULL) SWIG_fail;
13983             temp2 = true;
13984         }
13985     }
13986     if (obj2) {
13987         {
13988             arg3 = wxString_in_helper(obj2);
13989             if (arg3 == NULL) SWIG_fail;
13990             temp3 = true;
13991         }
13992     }
13993     if (obj3) {
13994         {
13995             arg4 = wxString_in_helper(obj3);
13996             if (arg4 == NULL) SWIG_fail;
13997             temp4 = true;
13998         }
13999     }
14000     if (obj4) {
14001         {
14002             arg5 = wxString_in_helper(obj4);
14003             if (arg5 == NULL) SWIG_fail;
14004             temp5 = true;
14005         }
14006     }
14007     if (obj5) {
14008         {
14009             arg6 = (long)(SWIG_As_long(obj5));
14010             if (SWIG_arg_fail(6)) SWIG_fail;
14011         }
14012     }
14013     if (obj6) {
14014         {
14015             arg7 = &temp7;
14016             if ( ! wxPoint_helper(obj6, &arg7)) SWIG_fail;
14017         }
14018     }
14019     {
14020         if (!wxPyCheckForApp()) SWIG_fail;
14021         PyThreadState* __tstate = wxPyBeginAllowThreads();
14022         result = (wxFileDialog *)new wxFileDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,(wxPoint const &)*arg7);
14023
14024         wxPyEndAllowThreads(__tstate);
14025         if (PyErr_Occurred()) SWIG_fail;
14026     }
14027     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDialog, 1);
14028     {
14029         if (temp2)
14030         delete arg2;
14031     }
14032     {
14033         if (temp3)
14034         delete arg3;
14035     }
14036     {
14037         if (temp4)
14038         delete arg4;
14039     }
14040     {
14041         if (temp5)
14042         delete arg5;
14043     }
14044     return resultobj;
14045     fail:
14046     {
14047         if (temp2)
14048         delete arg2;
14049     }
14050     {
14051         if (temp3)
14052         delete arg3;
14053     }
14054     {
14055         if (temp4)
14056         delete arg4;
14057     }
14058     {
14059         if (temp5)
14060         delete arg5;
14061     }
14062     return NULL;
14063 }
14064
14065
14066 static PyObject *_wrap_FileDialog_SetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
14067     PyObject *resultobj;
14068     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14069     wxString *arg2 = 0 ;
14070     bool temp2 = false ;
14071     PyObject * obj0 = 0 ;
14072     PyObject * obj1 = 0 ;
14073     char *kwnames[] = {
14074         (char *) "self",(char *) "message", NULL
14075     };
14076
14077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetMessage",kwnames,&obj0,&obj1)) goto fail;
14078     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14079     if (SWIG_arg_fail(1)) SWIG_fail;
14080     {
14081         arg2 = wxString_in_helper(obj1);
14082         if (arg2 == NULL) SWIG_fail;
14083         temp2 = true;
14084     }
14085     {
14086         PyThreadState* __tstate = wxPyBeginAllowThreads();
14087         (arg1)->SetMessage((wxString const &)*arg2);
14088
14089         wxPyEndAllowThreads(__tstate);
14090         if (PyErr_Occurred()) SWIG_fail;
14091     }
14092     Py_INCREF(Py_None); resultobj = Py_None;
14093     {
14094         if (temp2)
14095         delete arg2;
14096     }
14097     return resultobj;
14098     fail:
14099     {
14100         if (temp2)
14101         delete arg2;
14102     }
14103     return NULL;
14104 }
14105
14106
14107 static PyObject *_wrap_FileDialog_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
14108     PyObject *resultobj;
14109     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14110     wxString *arg2 = 0 ;
14111     bool temp2 = false ;
14112     PyObject * obj0 = 0 ;
14113     PyObject * obj1 = 0 ;
14114     char *kwnames[] = {
14115         (char *) "self",(char *) "path", NULL
14116     };
14117
14118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetPath",kwnames,&obj0,&obj1)) goto fail;
14119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14120     if (SWIG_arg_fail(1)) SWIG_fail;
14121     {
14122         arg2 = wxString_in_helper(obj1);
14123         if (arg2 == NULL) SWIG_fail;
14124         temp2 = true;
14125     }
14126     {
14127         PyThreadState* __tstate = wxPyBeginAllowThreads();
14128         (arg1)->SetPath((wxString const &)*arg2);
14129
14130         wxPyEndAllowThreads(__tstate);
14131         if (PyErr_Occurred()) SWIG_fail;
14132     }
14133     Py_INCREF(Py_None); resultobj = Py_None;
14134     {
14135         if (temp2)
14136         delete arg2;
14137     }
14138     return resultobj;
14139     fail:
14140     {
14141         if (temp2)
14142         delete arg2;
14143     }
14144     return NULL;
14145 }
14146
14147
14148 static PyObject *_wrap_FileDialog_SetDirectory(PyObject *, PyObject *args, PyObject *kwargs) {
14149     PyObject *resultobj;
14150     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14151     wxString *arg2 = 0 ;
14152     bool temp2 = false ;
14153     PyObject * obj0 = 0 ;
14154     PyObject * obj1 = 0 ;
14155     char *kwnames[] = {
14156         (char *) "self",(char *) "dir", NULL
14157     };
14158
14159     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetDirectory",kwnames,&obj0,&obj1)) goto fail;
14160     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14161     if (SWIG_arg_fail(1)) SWIG_fail;
14162     {
14163         arg2 = wxString_in_helper(obj1);
14164         if (arg2 == NULL) SWIG_fail;
14165         temp2 = true;
14166     }
14167     {
14168         PyThreadState* __tstate = wxPyBeginAllowThreads();
14169         (arg1)->SetDirectory((wxString const &)*arg2);
14170
14171         wxPyEndAllowThreads(__tstate);
14172         if (PyErr_Occurred()) SWIG_fail;
14173     }
14174     Py_INCREF(Py_None); resultobj = Py_None;
14175     {
14176         if (temp2)
14177         delete arg2;
14178     }
14179     return resultobj;
14180     fail:
14181     {
14182         if (temp2)
14183         delete arg2;
14184     }
14185     return NULL;
14186 }
14187
14188
14189 static PyObject *_wrap_FileDialog_SetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
14190     PyObject *resultobj;
14191     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14192     wxString *arg2 = 0 ;
14193     bool temp2 = false ;
14194     PyObject * obj0 = 0 ;
14195     PyObject * obj1 = 0 ;
14196     char *kwnames[] = {
14197         (char *) "self",(char *) "name", NULL
14198     };
14199
14200     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetFilename",kwnames,&obj0,&obj1)) goto fail;
14201     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14202     if (SWIG_arg_fail(1)) SWIG_fail;
14203     {
14204         arg2 = wxString_in_helper(obj1);
14205         if (arg2 == NULL) SWIG_fail;
14206         temp2 = true;
14207     }
14208     {
14209         PyThreadState* __tstate = wxPyBeginAllowThreads();
14210         (arg1)->SetFilename((wxString const &)*arg2);
14211
14212         wxPyEndAllowThreads(__tstate);
14213         if (PyErr_Occurred()) SWIG_fail;
14214     }
14215     Py_INCREF(Py_None); resultobj = Py_None;
14216     {
14217         if (temp2)
14218         delete arg2;
14219     }
14220     return resultobj;
14221     fail:
14222     {
14223         if (temp2)
14224         delete arg2;
14225     }
14226     return NULL;
14227 }
14228
14229
14230 static PyObject *_wrap_FileDialog_SetWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14231     PyObject *resultobj;
14232     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14233     wxString *arg2 = 0 ;
14234     bool temp2 = false ;
14235     PyObject * obj0 = 0 ;
14236     PyObject * obj1 = 0 ;
14237     char *kwnames[] = {
14238         (char *) "self",(char *) "wildCard", NULL
14239     };
14240
14241     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetWildcard",kwnames,&obj0,&obj1)) goto fail;
14242     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14243     if (SWIG_arg_fail(1)) SWIG_fail;
14244     {
14245         arg2 = wxString_in_helper(obj1);
14246         if (arg2 == NULL) SWIG_fail;
14247         temp2 = true;
14248     }
14249     {
14250         PyThreadState* __tstate = wxPyBeginAllowThreads();
14251         (arg1)->SetWildcard((wxString const &)*arg2);
14252
14253         wxPyEndAllowThreads(__tstate);
14254         if (PyErr_Occurred()) SWIG_fail;
14255     }
14256     Py_INCREF(Py_None); resultobj = Py_None;
14257     {
14258         if (temp2)
14259         delete arg2;
14260     }
14261     return resultobj;
14262     fail:
14263     {
14264         if (temp2)
14265         delete arg2;
14266     }
14267     return NULL;
14268 }
14269
14270
14271 static PyObject *_wrap_FileDialog_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
14272     PyObject *resultobj;
14273     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14274     long arg2 ;
14275     PyObject * obj0 = 0 ;
14276     PyObject * obj1 = 0 ;
14277     char *kwnames[] = {
14278         (char *) "self",(char *) "style", NULL
14279     };
14280
14281     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetStyle",kwnames,&obj0,&obj1)) goto fail;
14282     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14283     if (SWIG_arg_fail(1)) SWIG_fail;
14284     {
14285         arg2 = (long)(SWIG_As_long(obj1));
14286         if (SWIG_arg_fail(2)) SWIG_fail;
14287     }
14288     {
14289         PyThreadState* __tstate = wxPyBeginAllowThreads();
14290         (arg1)->SetStyle(arg2);
14291
14292         wxPyEndAllowThreads(__tstate);
14293         if (PyErr_Occurred()) SWIG_fail;
14294     }
14295     Py_INCREF(Py_None); resultobj = Py_None;
14296     return resultobj;
14297     fail:
14298     return NULL;
14299 }
14300
14301
14302 static PyObject *_wrap_FileDialog_SetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14303     PyObject *resultobj;
14304     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14305     int arg2 ;
14306     PyObject * obj0 = 0 ;
14307     PyObject * obj1 = 0 ;
14308     char *kwnames[] = {
14309         (char *) "self",(char *) "filterIndex", NULL
14310     };
14311
14312     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetFilterIndex",kwnames,&obj0,&obj1)) goto fail;
14313     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14314     if (SWIG_arg_fail(1)) SWIG_fail;
14315     {
14316         arg2 = (int)(SWIG_As_int(obj1));
14317         if (SWIG_arg_fail(2)) SWIG_fail;
14318     }
14319     {
14320         PyThreadState* __tstate = wxPyBeginAllowThreads();
14321         (arg1)->SetFilterIndex(arg2);
14322
14323         wxPyEndAllowThreads(__tstate);
14324         if (PyErr_Occurred()) SWIG_fail;
14325     }
14326     Py_INCREF(Py_None); resultobj = Py_None;
14327     return resultobj;
14328     fail:
14329     return NULL;
14330 }
14331
14332
14333 static PyObject *_wrap_FileDialog_GetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
14334     PyObject *resultobj;
14335     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14336     wxString result;
14337     PyObject * obj0 = 0 ;
14338     char *kwnames[] = {
14339         (char *) "self", NULL
14340     };
14341
14342     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetMessage",kwnames,&obj0)) goto fail;
14343     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14344     if (SWIG_arg_fail(1)) SWIG_fail;
14345     {
14346         PyThreadState* __tstate = wxPyBeginAllowThreads();
14347         result = ((wxFileDialog const *)arg1)->GetMessage();
14348
14349         wxPyEndAllowThreads(__tstate);
14350         if (PyErr_Occurred()) SWIG_fail;
14351     }
14352     {
14353 #if wxUSE_UNICODE
14354         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14355 #else
14356         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14357 #endif
14358     }
14359     return resultobj;
14360     fail:
14361     return NULL;
14362 }
14363
14364
14365 static PyObject *_wrap_FileDialog_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
14366     PyObject *resultobj;
14367     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14368     wxString result;
14369     PyObject * obj0 = 0 ;
14370     char *kwnames[] = {
14371         (char *) "self", NULL
14372     };
14373
14374     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetPath",kwnames,&obj0)) goto fail;
14375     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14376     if (SWIG_arg_fail(1)) SWIG_fail;
14377     {
14378         PyThreadState* __tstate = wxPyBeginAllowThreads();
14379         result = ((wxFileDialog const *)arg1)->GetPath();
14380
14381         wxPyEndAllowThreads(__tstate);
14382         if (PyErr_Occurred()) SWIG_fail;
14383     }
14384     {
14385 #if wxUSE_UNICODE
14386         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14387 #else
14388         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14389 #endif
14390     }
14391     return resultobj;
14392     fail:
14393     return NULL;
14394 }
14395
14396
14397 static PyObject *_wrap_FileDialog_GetDirectory(PyObject *, PyObject *args, PyObject *kwargs) {
14398     PyObject *resultobj;
14399     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14400     wxString result;
14401     PyObject * obj0 = 0 ;
14402     char *kwnames[] = {
14403         (char *) "self", NULL
14404     };
14405
14406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetDirectory",kwnames,&obj0)) goto fail;
14407     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14408     if (SWIG_arg_fail(1)) SWIG_fail;
14409     {
14410         PyThreadState* __tstate = wxPyBeginAllowThreads();
14411         result = ((wxFileDialog const *)arg1)->GetDirectory();
14412
14413         wxPyEndAllowThreads(__tstate);
14414         if (PyErr_Occurred()) SWIG_fail;
14415     }
14416     {
14417 #if wxUSE_UNICODE
14418         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14419 #else
14420         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14421 #endif
14422     }
14423     return resultobj;
14424     fail:
14425     return NULL;
14426 }
14427
14428
14429 static PyObject *_wrap_FileDialog_GetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
14430     PyObject *resultobj;
14431     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14432     wxString result;
14433     PyObject * obj0 = 0 ;
14434     char *kwnames[] = {
14435         (char *) "self", NULL
14436     };
14437
14438     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilename",kwnames,&obj0)) goto fail;
14439     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14440     if (SWIG_arg_fail(1)) SWIG_fail;
14441     {
14442         PyThreadState* __tstate = wxPyBeginAllowThreads();
14443         result = ((wxFileDialog const *)arg1)->GetFilename();
14444
14445         wxPyEndAllowThreads(__tstate);
14446         if (PyErr_Occurred()) SWIG_fail;
14447     }
14448     {
14449 #if wxUSE_UNICODE
14450         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14451 #else
14452         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14453 #endif
14454     }
14455     return resultobj;
14456     fail:
14457     return NULL;
14458 }
14459
14460
14461 static PyObject *_wrap_FileDialog_GetWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14462     PyObject *resultobj;
14463     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14464     wxString result;
14465     PyObject * obj0 = 0 ;
14466     char *kwnames[] = {
14467         (char *) "self", NULL
14468     };
14469
14470     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetWildcard",kwnames,&obj0)) goto fail;
14471     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14472     if (SWIG_arg_fail(1)) SWIG_fail;
14473     {
14474         PyThreadState* __tstate = wxPyBeginAllowThreads();
14475         result = ((wxFileDialog const *)arg1)->GetWildcard();
14476
14477         wxPyEndAllowThreads(__tstate);
14478         if (PyErr_Occurred()) SWIG_fail;
14479     }
14480     {
14481 #if wxUSE_UNICODE
14482         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14483 #else
14484         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14485 #endif
14486     }
14487     return resultobj;
14488     fail:
14489     return NULL;
14490 }
14491
14492
14493 static PyObject *_wrap_FileDialog_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
14494     PyObject *resultobj;
14495     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14496     long result;
14497     PyObject * obj0 = 0 ;
14498     char *kwnames[] = {
14499         (char *) "self", NULL
14500     };
14501
14502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetStyle",kwnames,&obj0)) goto fail;
14503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14504     if (SWIG_arg_fail(1)) SWIG_fail;
14505     {
14506         PyThreadState* __tstate = wxPyBeginAllowThreads();
14507         result = (long)((wxFileDialog const *)arg1)->GetStyle();
14508
14509         wxPyEndAllowThreads(__tstate);
14510         if (PyErr_Occurred()) SWIG_fail;
14511     }
14512     {
14513         resultobj = SWIG_From_long((long)(result));
14514     }
14515     return resultobj;
14516     fail:
14517     return NULL;
14518 }
14519
14520
14521 static PyObject *_wrap_FileDialog_GetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14522     PyObject *resultobj;
14523     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14524     int result;
14525     PyObject * obj0 = 0 ;
14526     char *kwnames[] = {
14527         (char *) "self", NULL
14528     };
14529
14530     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilterIndex",kwnames,&obj0)) goto fail;
14531     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14532     if (SWIG_arg_fail(1)) SWIG_fail;
14533     {
14534         PyThreadState* __tstate = wxPyBeginAllowThreads();
14535         result = (int)((wxFileDialog const *)arg1)->GetFilterIndex();
14536
14537         wxPyEndAllowThreads(__tstate);
14538         if (PyErr_Occurred()) SWIG_fail;
14539     }
14540     {
14541         resultobj = SWIG_From_int((int)(result));
14542     }
14543     return resultobj;
14544     fail:
14545     return NULL;
14546 }
14547
14548
14549 static PyObject *_wrap_FileDialog_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
14550     PyObject *resultobj;
14551     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14552     PyObject *result;
14553     PyObject * obj0 = 0 ;
14554     char *kwnames[] = {
14555         (char *) "self", NULL
14556     };
14557
14558     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilenames",kwnames,&obj0)) goto fail;
14559     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14560     if (SWIG_arg_fail(1)) SWIG_fail;
14561     {
14562         PyThreadState* __tstate = wxPyBeginAllowThreads();
14563         result = (PyObject *)wxFileDialog_GetFilenames(arg1);
14564
14565         wxPyEndAllowThreads(__tstate);
14566         if (PyErr_Occurred()) SWIG_fail;
14567     }
14568     resultobj = result;
14569     return resultobj;
14570     fail:
14571     return NULL;
14572 }
14573
14574
14575 static PyObject *_wrap_FileDialog_GetPaths(PyObject *, PyObject *args, PyObject *kwargs) {
14576     PyObject *resultobj;
14577     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14578     PyObject *result;
14579     PyObject * obj0 = 0 ;
14580     char *kwnames[] = {
14581         (char *) "self", NULL
14582     };
14583
14584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetPaths",kwnames,&obj0)) goto fail;
14585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14586     if (SWIG_arg_fail(1)) SWIG_fail;
14587     {
14588         PyThreadState* __tstate = wxPyBeginAllowThreads();
14589         result = (PyObject *)wxFileDialog_GetPaths(arg1);
14590
14591         wxPyEndAllowThreads(__tstate);
14592         if (PyErr_Occurred()) SWIG_fail;
14593     }
14594     resultobj = result;
14595     return resultobj;
14596     fail:
14597     return NULL;
14598 }
14599
14600
14601 static PyObject * FileDialog_swigregister(PyObject *, PyObject *args) {
14602     PyObject *obj;
14603     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14604     SWIG_TypeClientData(SWIGTYPE_p_wxFileDialog, obj);
14605     Py_INCREF(obj);
14606     return Py_BuildValue((char *)"");
14607 }
14608 static PyObject *_wrap_new_MultiChoiceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14609     PyObject *resultobj;
14610     wxWindow *arg1 = (wxWindow *) 0 ;
14611     wxString *arg2 = 0 ;
14612     wxString *arg3 = 0 ;
14613     int arg4 = (int) 0 ;
14614     wxString *arg5 = (wxString *) NULL ;
14615     long arg6 = (long) wxCHOICEDLG_STYLE ;
14616     wxPoint const &arg7_defvalue = wxDefaultPosition ;
14617     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
14618     wxMultiChoiceDialog *result;
14619     bool temp2 = false ;
14620     bool temp3 = false ;
14621     wxPoint temp7 ;
14622     PyObject * obj0 = 0 ;
14623     PyObject * obj1 = 0 ;
14624     PyObject * obj2 = 0 ;
14625     PyObject * obj3 = 0 ;
14626     PyObject * obj4 = 0 ;
14627     PyObject * obj5 = 0 ;
14628     char *kwnames[] = {
14629         (char *) "parent",(char *) "message",(char *) "caption",(char *) "choices",(char *) "style",(char *) "pos", NULL
14630     };
14631
14632     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:new_MultiChoiceDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14633     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14634     if (SWIG_arg_fail(1)) SWIG_fail;
14635     {
14636         arg2 = wxString_in_helper(obj1);
14637         if (arg2 == NULL) SWIG_fail;
14638         temp2 = true;
14639     }
14640     {
14641         arg3 = wxString_in_helper(obj2);
14642         if (arg3 == NULL) SWIG_fail;
14643         temp3 = true;
14644     }
14645     if (obj3) {
14646         {
14647             arg4 = PyList_Size(obj3);
14648             arg5 = wxString_LIST_helper(obj3);
14649             if (arg5 == NULL) SWIG_fail;
14650         }
14651     }
14652     if (obj4) {
14653         {
14654             arg6 = (long)(SWIG_As_long(obj4));
14655             if (SWIG_arg_fail(6)) SWIG_fail;
14656         }
14657     }
14658     if (obj5) {
14659         {
14660             arg7 = &temp7;
14661             if ( ! wxPoint_helper(obj5, &arg7)) SWIG_fail;
14662         }
14663     }
14664     {
14665         if (!wxPyCheckForApp()) SWIG_fail;
14666         PyThreadState* __tstate = wxPyBeginAllowThreads();
14667         result = (wxMultiChoiceDialog *)new wxMultiChoiceDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,(wxPoint const &)*arg7);
14668
14669         wxPyEndAllowThreads(__tstate);
14670         if (PyErr_Occurred()) SWIG_fail;
14671     }
14672     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMultiChoiceDialog, 1);
14673     {
14674         if (temp2)
14675         delete arg2;
14676     }
14677     {
14678         if (temp3)
14679         delete arg3;
14680     }
14681     {
14682         if (arg5) delete [] arg5;
14683     }
14684     return resultobj;
14685     fail:
14686     {
14687         if (temp2)
14688         delete arg2;
14689     }
14690     {
14691         if (temp3)
14692         delete arg3;
14693     }
14694     {
14695         if (arg5) delete [] arg5;
14696     }
14697     return NULL;
14698 }
14699
14700
14701 static PyObject *_wrap_MultiChoiceDialog_SetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
14702     PyObject *resultobj;
14703     wxMultiChoiceDialog *arg1 = (wxMultiChoiceDialog *) 0 ;
14704     wxArrayInt *arg2 = 0 ;
14705     bool temp2 = false ;
14706     PyObject * obj0 = 0 ;
14707     PyObject * obj1 = 0 ;
14708     char *kwnames[] = {
14709         (char *) "self",(char *) "selections", NULL
14710     };
14711
14712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MultiChoiceDialog_SetSelections",kwnames,&obj0,&obj1)) goto fail;
14713     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMultiChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14714     if (SWIG_arg_fail(1)) SWIG_fail;
14715     {
14716         if (! PySequence_Check(obj1)) {
14717             PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
14718             SWIG_fail;
14719         }
14720         arg2 = new wxArrayInt;
14721         temp2 = true;
14722         int i, len=PySequence_Length(obj1);
14723         for (i=0; i<len; i++) {
14724             PyObject* item = PySequence_GetItem(obj1, i);
14725             PyObject* number  = PyNumber_Int(item);
14726             arg2->Add(PyInt_AS_LONG(number));
14727             Py_DECREF(item);
14728             Py_DECREF(number);
14729         }
14730     }
14731     {
14732         PyThreadState* __tstate = wxPyBeginAllowThreads();
14733         (arg1)->SetSelections((wxArrayInt const &)*arg2);
14734
14735         wxPyEndAllowThreads(__tstate);
14736         if (PyErr_Occurred()) SWIG_fail;
14737     }
14738     Py_INCREF(Py_None); resultobj = Py_None;
14739     {
14740         if (temp2) delete arg2;
14741     }
14742     return resultobj;
14743     fail:
14744     {
14745         if (temp2) delete arg2;
14746     }
14747     return NULL;
14748 }
14749
14750
14751 static PyObject *_wrap_MultiChoiceDialog_GetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
14752     PyObject *resultobj;
14753     wxMultiChoiceDialog *arg1 = (wxMultiChoiceDialog *) 0 ;
14754     PyObject *result;
14755     PyObject * obj0 = 0 ;
14756     char *kwnames[] = {
14757         (char *) "self", NULL
14758     };
14759
14760     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MultiChoiceDialog_GetSelections",kwnames,&obj0)) goto fail;
14761     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMultiChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14762     if (SWIG_arg_fail(1)) SWIG_fail;
14763     {
14764         PyThreadState* __tstate = wxPyBeginAllowThreads();
14765         result = (PyObject *)wxMultiChoiceDialog_GetSelections(arg1);
14766
14767         wxPyEndAllowThreads(__tstate);
14768         if (PyErr_Occurred()) SWIG_fail;
14769     }
14770     resultobj = result;
14771     return resultobj;
14772     fail:
14773     return NULL;
14774 }
14775
14776
14777 static PyObject * MultiChoiceDialog_swigregister(PyObject *, PyObject *args) {
14778     PyObject *obj;
14779     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14780     SWIG_TypeClientData(SWIGTYPE_p_wxMultiChoiceDialog, obj);
14781     Py_INCREF(obj);
14782     return Py_BuildValue((char *)"");
14783 }
14784 static PyObject *_wrap_new_SingleChoiceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14785     PyObject *resultobj;
14786     wxWindow *arg1 = (wxWindow *) 0 ;
14787     wxString *arg2 = 0 ;
14788     wxString *arg3 = 0 ;
14789     int arg4 ;
14790     wxString *arg5 = (wxString *) 0 ;
14791     long arg6 = (long) wxCHOICEDLG_STYLE ;
14792     wxPoint const &arg7_defvalue = wxDefaultPosition ;
14793     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
14794     wxSingleChoiceDialog *result;
14795     bool temp2 = false ;
14796     bool temp3 = false ;
14797     wxPoint temp7 ;
14798     PyObject * obj0 = 0 ;
14799     PyObject * obj1 = 0 ;
14800     PyObject * obj2 = 0 ;
14801     PyObject * obj3 = 0 ;
14802     PyObject * obj4 = 0 ;
14803     PyObject * obj5 = 0 ;
14804     char *kwnames[] = {
14805         (char *) "parent",(char *) "message",(char *) "caption",(char *) "choices",(char *) "style",(char *) "pos", NULL
14806     };
14807
14808     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:new_SingleChoiceDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14809     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14810     if (SWIG_arg_fail(1)) SWIG_fail;
14811     {
14812         arg2 = wxString_in_helper(obj1);
14813         if (arg2 == NULL) SWIG_fail;
14814         temp2 = true;
14815     }
14816     {
14817         arg3 = wxString_in_helper(obj2);
14818         if (arg3 == NULL) SWIG_fail;
14819         temp3 = true;
14820     }
14821     {
14822         arg4 = PyList_Size(obj3);
14823         arg5 = wxString_LIST_helper(obj3);
14824         if (arg5 == NULL) SWIG_fail;
14825     }
14826     if (obj4) {
14827         {
14828             arg6 = (long)(SWIG_As_long(obj4));
14829             if (SWIG_arg_fail(6)) SWIG_fail;
14830         }
14831     }
14832     if (obj5) {
14833         {
14834             arg7 = &temp7;
14835             if ( ! wxPoint_helper(obj5, &arg7)) SWIG_fail;
14836         }
14837     }
14838     {
14839         if (!wxPyCheckForApp()) SWIG_fail;
14840         PyThreadState* __tstate = wxPyBeginAllowThreads();
14841         result = (wxSingleChoiceDialog *)new_wxSingleChoiceDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,(wxPoint const &)*arg7);
14842
14843         wxPyEndAllowThreads(__tstate);
14844         if (PyErr_Occurred()) SWIG_fail;
14845     }
14846     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleChoiceDialog, 1);
14847     {
14848         if (temp2)
14849         delete arg2;
14850     }
14851     {
14852         if (temp3)
14853         delete arg3;
14854     }
14855     {
14856         if (arg5) delete [] arg5;
14857     }
14858     return resultobj;
14859     fail:
14860     {
14861         if (temp2)
14862         delete arg2;
14863     }
14864     {
14865         if (temp3)
14866         delete arg3;
14867     }
14868     {
14869         if (arg5) delete [] arg5;
14870     }
14871     return NULL;
14872 }
14873
14874
14875 static PyObject *_wrap_SingleChoiceDialog_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14876     PyObject *resultobj;
14877     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14878     int result;
14879     PyObject * obj0 = 0 ;
14880     char *kwnames[] = {
14881         (char *) "self", NULL
14882     };
14883
14884     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleChoiceDialog_GetSelection",kwnames,&obj0)) goto fail;
14885     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14886     if (SWIG_arg_fail(1)) SWIG_fail;
14887     {
14888         PyThreadState* __tstate = wxPyBeginAllowThreads();
14889         result = (int)(arg1)->GetSelection();
14890
14891         wxPyEndAllowThreads(__tstate);
14892         if (PyErr_Occurred()) SWIG_fail;
14893     }
14894     {
14895         resultobj = SWIG_From_int((int)(result));
14896     }
14897     return resultobj;
14898     fail:
14899     return NULL;
14900 }
14901
14902
14903 static PyObject *_wrap_SingleChoiceDialog_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14904     PyObject *resultobj;
14905     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14906     wxString result;
14907     PyObject * obj0 = 0 ;
14908     char *kwnames[] = {
14909         (char *) "self", NULL
14910     };
14911
14912     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleChoiceDialog_GetStringSelection",kwnames,&obj0)) goto fail;
14913     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14914     if (SWIG_arg_fail(1)) SWIG_fail;
14915     {
14916         PyThreadState* __tstate = wxPyBeginAllowThreads();
14917         result = (arg1)->GetStringSelection();
14918
14919         wxPyEndAllowThreads(__tstate);
14920         if (PyErr_Occurred()) SWIG_fail;
14921     }
14922     {
14923 #if wxUSE_UNICODE
14924         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14925 #else
14926         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14927 #endif
14928     }
14929     return resultobj;
14930     fail:
14931     return NULL;
14932 }
14933
14934
14935 static PyObject *_wrap_SingleChoiceDialog_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14936     PyObject *resultobj;
14937     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14938     int arg2 ;
14939     PyObject * obj0 = 0 ;
14940     PyObject * obj1 = 0 ;
14941     char *kwnames[] = {
14942         (char *) "self",(char *) "sel", NULL
14943     };
14944
14945     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SingleChoiceDialog_SetSelection",kwnames,&obj0,&obj1)) goto fail;
14946     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14947     if (SWIG_arg_fail(1)) SWIG_fail;
14948     {
14949         arg2 = (int)(SWIG_As_int(obj1));
14950         if (SWIG_arg_fail(2)) SWIG_fail;
14951     }
14952     {
14953         PyThreadState* __tstate = wxPyBeginAllowThreads();
14954         (arg1)->SetSelection(arg2);
14955
14956         wxPyEndAllowThreads(__tstate);
14957         if (PyErr_Occurred()) SWIG_fail;
14958     }
14959     Py_INCREF(Py_None); resultobj = Py_None;
14960     return resultobj;
14961     fail:
14962     return NULL;
14963 }
14964
14965
14966 static PyObject * SingleChoiceDialog_swigregister(PyObject *, PyObject *args) {
14967     PyObject *obj;
14968     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14969     SWIG_TypeClientData(SWIGTYPE_p_wxSingleChoiceDialog, obj);
14970     Py_INCREF(obj);
14971     return Py_BuildValue((char *)"");
14972 }
14973 static PyObject *_wrap_new_TextEntryDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14974     PyObject *resultobj;
14975     wxWindow *arg1 = (wxWindow *) 0 ;
14976     wxString *arg2 = 0 ;
14977     wxString const &arg3_defvalue = wxPyGetTextFromUserPromptStr ;
14978     wxString *arg3 = (wxString *) &arg3_defvalue ;
14979     wxString const &arg4_defvalue = wxPyEmptyString ;
14980     wxString *arg4 = (wxString *) &arg4_defvalue ;
14981     long arg5 = (long) wxTextEntryDialogStyle ;
14982     wxPoint const &arg6_defvalue = wxDefaultPosition ;
14983     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
14984     wxTextEntryDialog *result;
14985     bool temp2 = false ;
14986     bool temp3 = false ;
14987     bool temp4 = false ;
14988     wxPoint temp6 ;
14989     PyObject * obj0 = 0 ;
14990     PyObject * obj1 = 0 ;
14991     PyObject * obj2 = 0 ;
14992     PyObject * obj3 = 0 ;
14993     PyObject * obj4 = 0 ;
14994     PyObject * obj5 = 0 ;
14995     char *kwnames[] = {
14996         (char *) "parent",(char *) "message",(char *) "caption",(char *) "defaultValue",(char *) "style",(char *) "pos", NULL
14997     };
14998
14999     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_TextEntryDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15000     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15001     if (SWIG_arg_fail(1)) SWIG_fail;
15002     {
15003         arg2 = wxString_in_helper(obj1);
15004         if (arg2 == NULL) SWIG_fail;
15005         temp2 = true;
15006     }
15007     if (obj2) {
15008         {
15009             arg3 = wxString_in_helper(obj2);
15010             if (arg3 == NULL) SWIG_fail;
15011             temp3 = true;
15012         }
15013     }
15014     if (obj3) {
15015         {
15016             arg4 = wxString_in_helper(obj3);
15017             if (arg4 == NULL) SWIG_fail;
15018             temp4 = true;
15019         }
15020     }
15021     if (obj4) {
15022         {
15023             arg5 = (long)(SWIG_As_long(obj4));
15024             if (SWIG_arg_fail(5)) SWIG_fail;
15025         }
15026     }
15027     if (obj5) {
15028         {
15029             arg6 = &temp6;
15030             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
15031         }
15032     }
15033     {
15034         if (!wxPyCheckForApp()) SWIG_fail;
15035         PyThreadState* __tstate = wxPyBeginAllowThreads();
15036         result = (wxTextEntryDialog *)new wxTextEntryDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,(wxPoint const &)*arg6);
15037
15038         wxPyEndAllowThreads(__tstate);
15039         if (PyErr_Occurred()) SWIG_fail;
15040     }
15041     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextEntryDialog, 1);
15042     {
15043         if (temp2)
15044         delete arg2;
15045     }
15046     {
15047         if (temp3)
15048         delete arg3;
15049     }
15050     {
15051         if (temp4)
15052         delete arg4;
15053     }
15054     return resultobj;
15055     fail:
15056     {
15057         if (temp2)
15058         delete arg2;
15059     }
15060     {
15061         if (temp3)
15062         delete arg3;
15063     }
15064     {
15065         if (temp4)
15066         delete arg4;
15067     }
15068     return NULL;
15069 }
15070
15071
15072 static PyObject *_wrap_TextEntryDialog_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15073     PyObject *resultobj;
15074     wxTextEntryDialog *arg1 = (wxTextEntryDialog *) 0 ;
15075     wxString result;
15076     PyObject * obj0 = 0 ;
15077     char *kwnames[] = {
15078         (char *) "self", NULL
15079     };
15080
15081     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextEntryDialog_GetValue",kwnames,&obj0)) goto fail;
15082     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextEntryDialog, SWIG_POINTER_EXCEPTION | 0);
15083     if (SWIG_arg_fail(1)) SWIG_fail;
15084     {
15085         PyThreadState* __tstate = wxPyBeginAllowThreads();
15086         result = (arg1)->GetValue();
15087
15088         wxPyEndAllowThreads(__tstate);
15089         if (PyErr_Occurred()) SWIG_fail;
15090     }
15091     {
15092 #if wxUSE_UNICODE
15093         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15094 #else
15095         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15096 #endif
15097     }
15098     return resultobj;
15099     fail:
15100     return NULL;
15101 }
15102
15103
15104 static PyObject *_wrap_TextEntryDialog_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15105     PyObject *resultobj;
15106     wxTextEntryDialog *arg1 = (wxTextEntryDialog *) 0 ;
15107     wxString *arg2 = 0 ;
15108     bool temp2 = false ;
15109     PyObject * obj0 = 0 ;
15110     PyObject * obj1 = 0 ;
15111     char *kwnames[] = {
15112         (char *) "self",(char *) "value", NULL
15113     };
15114
15115     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextEntryDialog_SetValue",kwnames,&obj0,&obj1)) goto fail;
15116     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextEntryDialog, SWIG_POINTER_EXCEPTION | 0);
15117     if (SWIG_arg_fail(1)) SWIG_fail;
15118     {
15119         arg2 = wxString_in_helper(obj1);
15120         if (arg2 == NULL) SWIG_fail;
15121         temp2 = true;
15122     }
15123     {
15124         PyThreadState* __tstate = wxPyBeginAllowThreads();
15125         (arg1)->SetValue((wxString const &)*arg2);
15126
15127         wxPyEndAllowThreads(__tstate);
15128         if (PyErr_Occurred()) SWIG_fail;
15129     }
15130     Py_INCREF(Py_None); resultobj = Py_None;
15131     {
15132         if (temp2)
15133         delete arg2;
15134     }
15135     return resultobj;
15136     fail:
15137     {
15138         if (temp2)
15139         delete arg2;
15140     }
15141     return NULL;
15142 }
15143
15144
15145 static PyObject * TextEntryDialog_swigregister(PyObject *, PyObject *args) {
15146     PyObject *obj;
15147     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15148     SWIG_TypeClientData(SWIGTYPE_p_wxTextEntryDialog, obj);
15149     Py_INCREF(obj);
15150     return Py_BuildValue((char *)"");
15151 }
15152 static int _wrap_GetPasswordFromUserPromptStr_set(PyObject *) {
15153     PyErr_SetString(PyExc_TypeError,"Variable GetPasswordFromUserPromptStr is read-only.");
15154     return 1;
15155 }
15156
15157
15158 static PyObject *_wrap_GetPasswordFromUserPromptStr_get(void) {
15159     PyObject *pyobj;
15160
15161     {
15162 #if wxUSE_UNICODE
15163         pyobj = PyUnicode_FromWideChar((&wxPyGetPasswordFromUserPromptStr)->c_str(), (&wxPyGetPasswordFromUserPromptStr)->Len());
15164 #else
15165         pyobj = PyString_FromStringAndSize((&wxPyGetPasswordFromUserPromptStr)->c_str(), (&wxPyGetPasswordFromUserPromptStr)->Len());
15166 #endif
15167     }
15168     return pyobj;
15169 }
15170
15171
15172 static PyObject *_wrap_new_PasswordEntryDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15173     PyObject *resultobj;
15174     wxWindow *arg1 = (wxWindow *) 0 ;
15175     wxString *arg2 = 0 ;
15176     wxString const &arg3_defvalue = wxPyGetPasswordFromUserPromptStr ;
15177     wxString *arg3 = (wxString *) &arg3_defvalue ;
15178     wxString const &arg4_defvalue = wxPyEmptyString ;
15179     wxString *arg4 = (wxString *) &arg4_defvalue ;
15180     long arg5 = (long) wxTextEntryDialogStyle ;
15181     wxPoint const &arg6_defvalue = wxDefaultPosition ;
15182     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
15183     wxPasswordEntryDialog *result;
15184     bool temp2 = false ;
15185     bool temp3 = false ;
15186     bool temp4 = false ;
15187     wxPoint temp6 ;
15188     PyObject * obj0 = 0 ;
15189     PyObject * obj1 = 0 ;
15190     PyObject * obj2 = 0 ;
15191     PyObject * obj3 = 0 ;
15192     PyObject * obj4 = 0 ;
15193     PyObject * obj5 = 0 ;
15194     char *kwnames[] = {
15195         (char *) "parent",(char *) "message",(char *) "caption",(char *) "value",(char *) "style",(char *) "pos", NULL
15196     };
15197
15198     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_PasswordEntryDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15199     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15200     if (SWIG_arg_fail(1)) SWIG_fail;
15201     {
15202         arg2 = wxString_in_helper(obj1);
15203         if (arg2 == NULL) SWIG_fail;
15204         temp2 = true;
15205     }
15206     if (obj2) {
15207         {
15208             arg3 = wxString_in_helper(obj2);
15209             if (arg3 == NULL) SWIG_fail;
15210             temp3 = true;
15211         }
15212     }
15213     if (obj3) {
15214         {
15215             arg4 = wxString_in_helper(obj3);
15216             if (arg4 == NULL) SWIG_fail;
15217             temp4 = true;
15218         }
15219     }
15220     if (obj4) {
15221         {
15222             arg5 = (long)(SWIG_As_long(obj4));
15223             if (SWIG_arg_fail(5)) SWIG_fail;
15224         }
15225     }
15226     if (obj5) {
15227         {
15228             arg6 = &temp6;
15229             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
15230         }
15231     }
15232     {
15233         PyThreadState* __tstate = wxPyBeginAllowThreads();
15234         result = (wxPasswordEntryDialog *)new wxPasswordEntryDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,(wxPoint const &)*arg6);
15235
15236         wxPyEndAllowThreads(__tstate);
15237         if (PyErr_Occurred()) SWIG_fail;
15238     }
15239     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPasswordEntryDialog, 1);
15240     {
15241         if (temp2)
15242         delete arg2;
15243     }
15244     {
15245         if (temp3)
15246         delete arg3;
15247     }
15248     {
15249         if (temp4)
15250         delete arg4;
15251     }
15252     return resultobj;
15253     fail:
15254     {
15255         if (temp2)
15256         delete arg2;
15257     }
15258     {
15259         if (temp3)
15260         delete arg3;
15261     }
15262     {
15263         if (temp4)
15264         delete arg4;
15265     }
15266     return NULL;
15267 }
15268
15269
15270 static PyObject * PasswordEntryDialog_swigregister(PyObject *, PyObject *args) {
15271     PyObject *obj;
15272     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15273     SWIG_TypeClientData(SWIGTYPE_p_wxPasswordEntryDialog, obj);
15274     Py_INCREF(obj);
15275     return Py_BuildValue((char *)"");
15276 }
15277 static PyObject *_wrap_new_FontData(PyObject *, PyObject *args, PyObject *kwargs) {
15278     PyObject *resultobj;
15279     wxFontData *result;
15280     char *kwnames[] = {
15281         NULL
15282     };
15283
15284     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontData",kwnames)) goto fail;
15285     {
15286         PyThreadState* __tstate = wxPyBeginAllowThreads();
15287         result = (wxFontData *)new wxFontData();
15288
15289         wxPyEndAllowThreads(__tstate);
15290         if (PyErr_Occurred()) SWIG_fail;
15291     }
15292     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontData, 1);
15293     return resultobj;
15294     fail:
15295     return NULL;
15296 }
15297
15298
15299 static PyObject *_wrap_delete_FontData(PyObject *, PyObject *args, PyObject *kwargs) {
15300     PyObject *resultobj;
15301     wxFontData *arg1 = (wxFontData *) 0 ;
15302     PyObject * obj0 = 0 ;
15303     char *kwnames[] = {
15304         (char *) "self", NULL
15305     };
15306
15307     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontData",kwnames,&obj0)) goto fail;
15308     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15309     if (SWIG_arg_fail(1)) SWIG_fail;
15310     {
15311         PyThreadState* __tstate = wxPyBeginAllowThreads();
15312         delete arg1;
15313
15314         wxPyEndAllowThreads(__tstate);
15315         if (PyErr_Occurred()) SWIG_fail;
15316     }
15317     Py_INCREF(Py_None); resultobj = Py_None;
15318     return resultobj;
15319     fail:
15320     return NULL;
15321 }
15322
15323
15324 static PyObject *_wrap_FontData_EnableEffects(PyObject *, PyObject *args, PyObject *kwargs) {
15325     PyObject *resultobj;
15326     wxFontData *arg1 = (wxFontData *) 0 ;
15327     bool arg2 ;
15328     PyObject * obj0 = 0 ;
15329     PyObject * obj1 = 0 ;
15330     char *kwnames[] = {
15331         (char *) "self",(char *) "enable", NULL
15332     };
15333
15334     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_EnableEffects",kwnames,&obj0,&obj1)) goto fail;
15335     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15336     if (SWIG_arg_fail(1)) SWIG_fail;
15337     {
15338         arg2 = (bool)(SWIG_As_bool(obj1));
15339         if (SWIG_arg_fail(2)) SWIG_fail;
15340     }
15341     {
15342         PyThreadState* __tstate = wxPyBeginAllowThreads();
15343         (arg1)->EnableEffects(arg2);
15344
15345         wxPyEndAllowThreads(__tstate);
15346         if (PyErr_Occurred()) SWIG_fail;
15347     }
15348     Py_INCREF(Py_None); resultobj = Py_None;
15349     return resultobj;
15350     fail:
15351     return NULL;
15352 }
15353
15354
15355 static PyObject *_wrap_FontData_GetAllowSymbols(PyObject *, PyObject *args, PyObject *kwargs) {
15356     PyObject *resultobj;
15357     wxFontData *arg1 = (wxFontData *) 0 ;
15358     bool result;
15359     PyObject * obj0 = 0 ;
15360     char *kwnames[] = {
15361         (char *) "self", NULL
15362     };
15363
15364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetAllowSymbols",kwnames,&obj0)) goto fail;
15365     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15366     if (SWIG_arg_fail(1)) SWIG_fail;
15367     {
15368         PyThreadState* __tstate = wxPyBeginAllowThreads();
15369         result = (bool)(arg1)->GetAllowSymbols();
15370
15371         wxPyEndAllowThreads(__tstate);
15372         if (PyErr_Occurred()) SWIG_fail;
15373     }
15374     {
15375         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15376     }
15377     return resultobj;
15378     fail:
15379     return NULL;
15380 }
15381
15382
15383 static PyObject *_wrap_FontData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
15384     PyObject *resultobj;
15385     wxFontData *arg1 = (wxFontData *) 0 ;
15386     wxColour result;
15387     PyObject * obj0 = 0 ;
15388     char *kwnames[] = {
15389         (char *) "self", NULL
15390     };
15391
15392     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetColour",kwnames,&obj0)) goto fail;
15393     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15394     if (SWIG_arg_fail(1)) SWIG_fail;
15395     {
15396         PyThreadState* __tstate = wxPyBeginAllowThreads();
15397         result = (arg1)->GetColour();
15398
15399         wxPyEndAllowThreads(__tstate);
15400         if (PyErr_Occurred()) SWIG_fail;
15401     }
15402     {
15403         wxColour * resultptr;
15404         resultptr = new wxColour((wxColour &)(result));
15405         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15406     }
15407     return resultobj;
15408     fail:
15409     return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_FontData_GetChosenFont(PyObject *, PyObject *args, PyObject *kwargs) {
15414     PyObject *resultobj;
15415     wxFontData *arg1 = (wxFontData *) 0 ;
15416     wxFont result;
15417     PyObject * obj0 = 0 ;
15418     char *kwnames[] = {
15419         (char *) "self", NULL
15420     };
15421
15422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetChosenFont",kwnames,&obj0)) goto fail;
15423     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15424     if (SWIG_arg_fail(1)) SWIG_fail;
15425     {
15426         PyThreadState* __tstate = wxPyBeginAllowThreads();
15427         result = (arg1)->GetChosenFont();
15428
15429         wxPyEndAllowThreads(__tstate);
15430         if (PyErr_Occurred()) SWIG_fail;
15431     }
15432     {
15433         wxFont * resultptr;
15434         resultptr = new wxFont((wxFont &)(result));
15435         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
15436     }
15437     return resultobj;
15438     fail:
15439     return NULL;
15440 }
15441
15442
15443 static PyObject *_wrap_FontData_GetEnableEffects(PyObject *, PyObject *args, PyObject *kwargs) {
15444     PyObject *resultobj;
15445     wxFontData *arg1 = (wxFontData *) 0 ;
15446     bool result;
15447     PyObject * obj0 = 0 ;
15448     char *kwnames[] = {
15449         (char *) "self", NULL
15450     };
15451
15452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetEnableEffects",kwnames,&obj0)) goto fail;
15453     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15454     if (SWIG_arg_fail(1)) SWIG_fail;
15455     {
15456         PyThreadState* __tstate = wxPyBeginAllowThreads();
15457         result = (bool)(arg1)->GetEnableEffects();
15458
15459         wxPyEndAllowThreads(__tstate);
15460         if (PyErr_Occurred()) SWIG_fail;
15461     }
15462     {
15463         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15464     }
15465     return resultobj;
15466     fail:
15467     return NULL;
15468 }
15469
15470
15471 static PyObject *_wrap_FontData_GetInitialFont(PyObject *, PyObject *args, PyObject *kwargs) {
15472     PyObject *resultobj;
15473     wxFontData *arg1 = (wxFontData *) 0 ;
15474     wxFont result;
15475     PyObject * obj0 = 0 ;
15476     char *kwnames[] = {
15477         (char *) "self", NULL
15478     };
15479
15480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetInitialFont",kwnames,&obj0)) goto fail;
15481     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15482     if (SWIG_arg_fail(1)) SWIG_fail;
15483     {
15484         PyThreadState* __tstate = wxPyBeginAllowThreads();
15485         result = (arg1)->GetInitialFont();
15486
15487         wxPyEndAllowThreads(__tstate);
15488         if (PyErr_Occurred()) SWIG_fail;
15489     }
15490     {
15491         wxFont * resultptr;
15492         resultptr = new wxFont((wxFont &)(result));
15493         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
15494     }
15495     return resultobj;
15496     fail:
15497     return NULL;
15498 }
15499
15500
15501 static PyObject *_wrap_FontData_GetShowHelp(PyObject *, PyObject *args, PyObject *kwargs) {
15502     PyObject *resultobj;
15503     wxFontData *arg1 = (wxFontData *) 0 ;
15504     bool result;
15505     PyObject * obj0 = 0 ;
15506     char *kwnames[] = {
15507         (char *) "self", NULL
15508     };
15509
15510     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetShowHelp",kwnames,&obj0)) goto fail;
15511     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15512     if (SWIG_arg_fail(1)) SWIG_fail;
15513     {
15514         PyThreadState* __tstate = wxPyBeginAllowThreads();
15515         result = (bool)(arg1)->GetShowHelp();
15516
15517         wxPyEndAllowThreads(__tstate);
15518         if (PyErr_Occurred()) SWIG_fail;
15519     }
15520     {
15521         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15522     }
15523     return resultobj;
15524     fail:
15525     return NULL;
15526 }
15527
15528
15529 static PyObject *_wrap_FontData_SetAllowSymbols(PyObject *, PyObject *args, PyObject *kwargs) {
15530     PyObject *resultobj;
15531     wxFontData *arg1 = (wxFontData *) 0 ;
15532     bool arg2 ;
15533     PyObject * obj0 = 0 ;
15534     PyObject * obj1 = 0 ;
15535     char *kwnames[] = {
15536         (char *) "self",(char *) "allowSymbols", NULL
15537     };
15538
15539     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetAllowSymbols",kwnames,&obj0,&obj1)) goto fail;
15540     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15541     if (SWIG_arg_fail(1)) SWIG_fail;
15542     {
15543         arg2 = (bool)(SWIG_As_bool(obj1));
15544         if (SWIG_arg_fail(2)) SWIG_fail;
15545     }
15546     {
15547         PyThreadState* __tstate = wxPyBeginAllowThreads();
15548         (arg1)->SetAllowSymbols(arg2);
15549
15550         wxPyEndAllowThreads(__tstate);
15551         if (PyErr_Occurred()) SWIG_fail;
15552     }
15553     Py_INCREF(Py_None); resultobj = Py_None;
15554     return resultobj;
15555     fail:
15556     return NULL;
15557 }
15558
15559
15560 static PyObject *_wrap_FontData_SetChosenFont(PyObject *, PyObject *args, PyObject *kwargs) {
15561     PyObject *resultobj;
15562     wxFontData *arg1 = (wxFontData *) 0 ;
15563     wxFont *arg2 = 0 ;
15564     PyObject * obj0 = 0 ;
15565     PyObject * obj1 = 0 ;
15566     char *kwnames[] = {
15567         (char *) "self",(char *) "font", NULL
15568     };
15569
15570     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetChosenFont",kwnames,&obj0,&obj1)) goto fail;
15571     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15572     if (SWIG_arg_fail(1)) SWIG_fail;
15573     {
15574         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15575         if (SWIG_arg_fail(2)) SWIG_fail;
15576         if (arg2 == NULL) {
15577             SWIG_null_ref("wxFont");
15578         }
15579         if (SWIG_arg_fail(2)) SWIG_fail;
15580     }
15581     {
15582         PyThreadState* __tstate = wxPyBeginAllowThreads();
15583         (arg1)->SetChosenFont((wxFont const &)*arg2);
15584
15585         wxPyEndAllowThreads(__tstate);
15586         if (PyErr_Occurred()) SWIG_fail;
15587     }
15588     Py_INCREF(Py_None); resultobj = Py_None;
15589     return resultobj;
15590     fail:
15591     return NULL;
15592 }
15593
15594
15595 static PyObject *_wrap_FontData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
15596     PyObject *resultobj;
15597     wxFontData *arg1 = (wxFontData *) 0 ;
15598     wxColour *arg2 = 0 ;
15599     wxColour temp2 ;
15600     PyObject * obj0 = 0 ;
15601     PyObject * obj1 = 0 ;
15602     char *kwnames[] = {
15603         (char *) "self",(char *) "colour", NULL
15604     };
15605
15606     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetColour",kwnames,&obj0,&obj1)) goto fail;
15607     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15608     if (SWIG_arg_fail(1)) SWIG_fail;
15609     {
15610         arg2 = &temp2;
15611         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15612     }
15613     {
15614         PyThreadState* __tstate = wxPyBeginAllowThreads();
15615         (arg1)->SetColour((wxColour const &)*arg2);
15616
15617         wxPyEndAllowThreads(__tstate);
15618         if (PyErr_Occurred()) SWIG_fail;
15619     }
15620     Py_INCREF(Py_None); resultobj = Py_None;
15621     return resultobj;
15622     fail:
15623     return NULL;
15624 }
15625
15626
15627 static PyObject *_wrap_FontData_SetInitialFont(PyObject *, PyObject *args, PyObject *kwargs) {
15628     PyObject *resultobj;
15629     wxFontData *arg1 = (wxFontData *) 0 ;
15630     wxFont *arg2 = 0 ;
15631     PyObject * obj0 = 0 ;
15632     PyObject * obj1 = 0 ;
15633     char *kwnames[] = {
15634         (char *) "self",(char *) "font", NULL
15635     };
15636
15637     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetInitialFont",kwnames,&obj0,&obj1)) goto fail;
15638     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15639     if (SWIG_arg_fail(1)) SWIG_fail;
15640     {
15641         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15642         if (SWIG_arg_fail(2)) SWIG_fail;
15643         if (arg2 == NULL) {
15644             SWIG_null_ref("wxFont");
15645         }
15646         if (SWIG_arg_fail(2)) SWIG_fail;
15647     }
15648     {
15649         PyThreadState* __tstate = wxPyBeginAllowThreads();
15650         (arg1)->SetInitialFont((wxFont const &)*arg2);
15651
15652         wxPyEndAllowThreads(__tstate);
15653         if (PyErr_Occurred()) SWIG_fail;
15654     }
15655     Py_INCREF(Py_None); resultobj = Py_None;
15656     return resultobj;
15657     fail:
15658     return NULL;
15659 }
15660
15661
15662 static PyObject *_wrap_FontData_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
15663     PyObject *resultobj;
15664     wxFontData *arg1 = (wxFontData *) 0 ;
15665     int arg2 ;
15666     int arg3 ;
15667     PyObject * obj0 = 0 ;
15668     PyObject * obj1 = 0 ;
15669     PyObject * obj2 = 0 ;
15670     char *kwnames[] = {
15671         (char *) "self",(char *) "min",(char *) "max", NULL
15672     };
15673
15674     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FontData_SetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
15675     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15676     if (SWIG_arg_fail(1)) SWIG_fail;
15677     {
15678         arg2 = (int)(SWIG_As_int(obj1));
15679         if (SWIG_arg_fail(2)) SWIG_fail;
15680     }
15681     {
15682         arg3 = (int)(SWIG_As_int(obj2));
15683         if (SWIG_arg_fail(3)) SWIG_fail;
15684     }
15685     {
15686         PyThreadState* __tstate = wxPyBeginAllowThreads();
15687         (arg1)->SetRange(arg2,arg3);
15688
15689         wxPyEndAllowThreads(__tstate);
15690         if (PyErr_Occurred()) SWIG_fail;
15691     }
15692     Py_INCREF(Py_None); resultobj = Py_None;
15693     return resultobj;
15694     fail:
15695     return NULL;
15696 }
15697
15698
15699 static PyObject *_wrap_FontData_SetShowHelp(PyObject *, PyObject *args, PyObject *kwargs) {
15700     PyObject *resultobj;
15701     wxFontData *arg1 = (wxFontData *) 0 ;
15702     bool arg2 ;
15703     PyObject * obj0 = 0 ;
15704     PyObject * obj1 = 0 ;
15705     char *kwnames[] = {
15706         (char *) "self",(char *) "showHelp", NULL
15707     };
15708
15709     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetShowHelp",kwnames,&obj0,&obj1)) goto fail;
15710     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15711     if (SWIG_arg_fail(1)) SWIG_fail;
15712     {
15713         arg2 = (bool)(SWIG_As_bool(obj1));
15714         if (SWIG_arg_fail(2)) SWIG_fail;
15715     }
15716     {
15717         PyThreadState* __tstate = wxPyBeginAllowThreads();
15718         (arg1)->SetShowHelp(arg2);
15719
15720         wxPyEndAllowThreads(__tstate);
15721         if (PyErr_Occurred()) SWIG_fail;
15722     }
15723     Py_INCREF(Py_None); resultobj = Py_None;
15724     return resultobj;
15725     fail:
15726     return NULL;
15727 }
15728
15729
15730 static PyObject * FontData_swigregister(PyObject *, PyObject *args) {
15731     PyObject *obj;
15732     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15733     SWIG_TypeClientData(SWIGTYPE_p_wxFontData, obj);
15734     Py_INCREF(obj);
15735     return Py_BuildValue((char *)"");
15736 }
15737 static PyObject *_wrap_new_FontDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15738     PyObject *resultobj;
15739     wxWindow *arg1 = (wxWindow *) 0 ;
15740     wxFontData *arg2 = 0 ;
15741     wxFontDialog *result;
15742     PyObject * obj0 = 0 ;
15743     PyObject * obj1 = 0 ;
15744     char *kwnames[] = {
15745         (char *) "parent",(char *) "data", NULL
15746     };
15747
15748     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_FontDialog",kwnames,&obj0,&obj1)) goto fail;
15749     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15750     if (SWIG_arg_fail(1)) SWIG_fail;
15751     {
15752         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15753         if (SWIG_arg_fail(2)) SWIG_fail;
15754         if (arg2 == NULL) {
15755             SWIG_null_ref("wxFontData");
15756         }
15757         if (SWIG_arg_fail(2)) SWIG_fail;
15758     }
15759     {
15760         if (!wxPyCheckForApp()) SWIG_fail;
15761         PyThreadState* __tstate = wxPyBeginAllowThreads();
15762         result = (wxFontDialog *)new wxFontDialog(arg1,(wxFontData const &)*arg2);
15763
15764         wxPyEndAllowThreads(__tstate);
15765         if (PyErr_Occurred()) SWIG_fail;
15766     }
15767     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontDialog, 1);
15768     return resultobj;
15769     fail:
15770     return NULL;
15771 }
15772
15773
15774 static PyObject *_wrap_FontDialog_GetFontData(PyObject *, PyObject *args, PyObject *kwargs) {
15775     PyObject *resultobj;
15776     wxFontDialog *arg1 = (wxFontDialog *) 0 ;
15777     wxFontData *result;
15778     PyObject * obj0 = 0 ;
15779     char *kwnames[] = {
15780         (char *) "self", NULL
15781     };
15782
15783     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontDialog_GetFontData",kwnames,&obj0)) goto fail;
15784     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontDialog, SWIG_POINTER_EXCEPTION | 0);
15785     if (SWIG_arg_fail(1)) SWIG_fail;
15786     {
15787         PyThreadState* __tstate = wxPyBeginAllowThreads();
15788         {
15789             wxFontData &_result_ref = (arg1)->GetFontData();
15790             result = (wxFontData *) &_result_ref;
15791         }
15792
15793         wxPyEndAllowThreads(__tstate);
15794         if (PyErr_Occurred()) SWIG_fail;
15795     }
15796     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontData, 0);
15797     return resultobj;
15798     fail:
15799     return NULL;
15800 }
15801
15802
15803 static PyObject * FontDialog_swigregister(PyObject *, PyObject *args) {
15804     PyObject *obj;
15805     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15806     SWIG_TypeClientData(SWIGTYPE_p_wxFontDialog, obj);
15807     Py_INCREF(obj);
15808     return Py_BuildValue((char *)"");
15809 }
15810 static PyObject *_wrap_new_MessageDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15811     PyObject *resultobj;
15812     wxWindow *arg1 = (wxWindow *) 0 ;
15813     wxString *arg2 = 0 ;
15814     wxString const &arg3_defvalue = wxPyMessageBoxCaptionStr ;
15815     wxString *arg3 = (wxString *) &arg3_defvalue ;
15816     long arg4 = (long) wxOK|wxCANCEL|wxCENTRE ;
15817     wxPoint const &arg5_defvalue = wxDefaultPosition ;
15818     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
15819     wxMessageDialog *result;
15820     bool temp2 = false ;
15821     bool temp3 = false ;
15822     wxPoint temp5 ;
15823     PyObject * obj0 = 0 ;
15824     PyObject * obj1 = 0 ;
15825     PyObject * obj2 = 0 ;
15826     PyObject * obj3 = 0 ;
15827     PyObject * obj4 = 0 ;
15828     char *kwnames[] = {
15829         (char *) "parent",(char *) "message",(char *) "caption",(char *) "style",(char *) "pos", NULL
15830     };
15831
15832     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_MessageDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15833     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15834     if (SWIG_arg_fail(1)) SWIG_fail;
15835     {
15836         arg2 = wxString_in_helper(obj1);
15837         if (arg2 == NULL) SWIG_fail;
15838         temp2 = true;
15839     }
15840     if (obj2) {
15841         {
15842             arg3 = wxString_in_helper(obj2);
15843             if (arg3 == NULL) SWIG_fail;
15844             temp3 = true;
15845         }
15846     }
15847     if (obj3) {
15848         {
15849             arg4 = (long)(SWIG_As_long(obj3));
15850             if (SWIG_arg_fail(4)) SWIG_fail;
15851         }
15852     }
15853     if (obj4) {
15854         {
15855             arg5 = &temp5;
15856             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
15857         }
15858     }
15859     {
15860         if (!wxPyCheckForApp()) SWIG_fail;
15861         PyThreadState* __tstate = wxPyBeginAllowThreads();
15862         result = (wxMessageDialog *)new wxMessageDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,(wxPoint const &)*arg5);
15863
15864         wxPyEndAllowThreads(__tstate);
15865         if (PyErr_Occurred()) SWIG_fail;
15866     }
15867     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMessageDialog, 1);
15868     {
15869         if (temp2)
15870         delete arg2;
15871     }
15872     {
15873         if (temp3)
15874         delete arg3;
15875     }
15876     return resultobj;
15877     fail:
15878     {
15879         if (temp2)
15880         delete arg2;
15881     }
15882     {
15883         if (temp3)
15884         delete arg3;
15885     }
15886     return NULL;
15887 }
15888
15889
15890 static PyObject * MessageDialog_swigregister(PyObject *, PyObject *args) {
15891     PyObject *obj;
15892     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15893     SWIG_TypeClientData(SWIGTYPE_p_wxMessageDialog, obj);
15894     Py_INCREF(obj);
15895     return Py_BuildValue((char *)"");
15896 }
15897 static PyObject *_wrap_new_ProgressDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15898     PyObject *resultobj;
15899     wxString *arg1 = 0 ;
15900     wxString *arg2 = 0 ;
15901     int arg3 = (int) 100 ;
15902     wxWindow *arg4 = (wxWindow *) NULL ;
15903     int arg5 = (int) wxPD_AUTO_HIDE|wxPD_APP_MODAL ;
15904     wxProgressDialog *result;
15905     bool temp1 = false ;
15906     bool temp2 = false ;
15907     PyObject * obj0 = 0 ;
15908     PyObject * obj1 = 0 ;
15909     PyObject * obj2 = 0 ;
15910     PyObject * obj3 = 0 ;
15911     PyObject * obj4 = 0 ;
15912     char *kwnames[] = {
15913         (char *) "title",(char *) "message",(char *) "maximum",(char *) "parent",(char *) "style", NULL
15914     };
15915
15916     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_ProgressDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15917     {
15918         arg1 = wxString_in_helper(obj0);
15919         if (arg1 == NULL) SWIG_fail;
15920         temp1 = true;
15921     }
15922     {
15923         arg2 = wxString_in_helper(obj1);
15924         if (arg2 == NULL) SWIG_fail;
15925         temp2 = true;
15926     }
15927     if (obj2) {
15928         {
15929             arg3 = (int)(SWIG_As_int(obj2));
15930             if (SWIG_arg_fail(3)) SWIG_fail;
15931         }
15932     }
15933     if (obj3) {
15934         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15935         if (SWIG_arg_fail(4)) SWIG_fail;
15936     }
15937     if (obj4) {
15938         {
15939             arg5 = (int)(SWIG_As_int(obj4));
15940             if (SWIG_arg_fail(5)) SWIG_fail;
15941         }
15942     }
15943     {
15944         if (!wxPyCheckForApp()) SWIG_fail;
15945         PyThreadState* __tstate = wxPyBeginAllowThreads();
15946         result = (wxProgressDialog *)new wxProgressDialog((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5);
15947
15948         wxPyEndAllowThreads(__tstate);
15949         if (PyErr_Occurred()) SWIG_fail;
15950     }
15951     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProgressDialog, 1);
15952     {
15953         if (temp1)
15954         delete arg1;
15955     }
15956     {
15957         if (temp2)
15958         delete arg2;
15959     }
15960     return resultobj;
15961     fail:
15962     {
15963         if (temp1)
15964         delete arg1;
15965     }
15966     {
15967         if (temp2)
15968         delete arg2;
15969     }
15970     return NULL;
15971 }
15972
15973
15974 static PyObject *_wrap_ProgressDialog_Update(PyObject *, PyObject *args, PyObject *kwargs) {
15975     PyObject *resultobj;
15976     wxProgressDialog *arg1 = (wxProgressDialog *) 0 ;
15977     int arg2 ;
15978     wxString const &arg3_defvalue = wxPyEmptyString ;
15979     wxString *arg3 = (wxString *) &arg3_defvalue ;
15980     bool result;
15981     bool temp3 = false ;
15982     PyObject * obj0 = 0 ;
15983     PyObject * obj1 = 0 ;
15984     PyObject * obj2 = 0 ;
15985     char *kwnames[] = {
15986         (char *) "self",(char *) "value",(char *) "newmsg", NULL
15987     };
15988
15989     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ProgressDialog_Update",kwnames,&obj0,&obj1,&obj2)) goto fail;
15990     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProgressDialog, SWIG_POINTER_EXCEPTION | 0);
15991     if (SWIG_arg_fail(1)) SWIG_fail;
15992     {
15993         arg2 = (int)(SWIG_As_int(obj1));
15994         if (SWIG_arg_fail(2)) SWIG_fail;
15995     }
15996     if (obj2) {
15997         {
15998             arg3 = wxString_in_helper(obj2);
15999             if (arg3 == NULL) SWIG_fail;
16000             temp3 = true;
16001         }
16002     }
16003     {
16004         PyThreadState* __tstate = wxPyBeginAllowThreads();
16005         result = (bool)(arg1)->Update(arg2,(wxString const &)*arg3);
16006
16007         wxPyEndAllowThreads(__tstate);
16008         if (PyErr_Occurred()) SWIG_fail;
16009     }
16010     {
16011         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16012     }
16013     {
16014         if (temp3)
16015         delete arg3;
16016     }
16017     return resultobj;
16018     fail:
16019     {
16020         if (temp3)
16021         delete arg3;
16022     }
16023     return NULL;
16024 }
16025
16026
16027 static PyObject *_wrap_ProgressDialog_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
16028     PyObject *resultobj;
16029     wxProgressDialog *arg1 = (wxProgressDialog *) 0 ;
16030     PyObject * obj0 = 0 ;
16031     char *kwnames[] = {
16032         (char *) "self", NULL
16033     };
16034
16035     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProgressDialog_Resume",kwnames,&obj0)) goto fail;
16036     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProgressDialog, SWIG_POINTER_EXCEPTION | 0);
16037     if (SWIG_arg_fail(1)) SWIG_fail;
16038     {
16039         PyThreadState* __tstate = wxPyBeginAllowThreads();
16040         (arg1)->Resume();
16041
16042         wxPyEndAllowThreads(__tstate);
16043         if (PyErr_Occurred()) SWIG_fail;
16044     }
16045     Py_INCREF(Py_None); resultobj = Py_None;
16046     return resultobj;
16047     fail:
16048     return NULL;
16049 }
16050
16051
16052 static PyObject * ProgressDialog_swigregister(PyObject *, PyObject *args) {
16053     PyObject *obj;
16054     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16055     SWIG_TypeClientData(SWIGTYPE_p_wxProgressDialog, obj);
16056     Py_INCREF(obj);
16057     return Py_BuildValue((char *)"");
16058 }
16059 static PyObject *_wrap_new_FindDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16060     PyObject *resultobj;
16061     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16062     int arg2 = (int) 0 ;
16063     wxFindDialogEvent *result;
16064     PyObject * obj0 = 0 ;
16065     PyObject * obj1 = 0 ;
16066     char *kwnames[] = {
16067         (char *) "commandType",(char *) "id", NULL
16068     };
16069
16070     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FindDialogEvent",kwnames,&obj0,&obj1)) goto fail;
16071     if (obj0) {
16072         {
16073             arg1 = (wxEventType)(SWIG_As_int(obj0));
16074             if (SWIG_arg_fail(1)) SWIG_fail;
16075         }
16076     }
16077     if (obj1) {
16078         {
16079             arg2 = (int)(SWIG_As_int(obj1));
16080             if (SWIG_arg_fail(2)) SWIG_fail;
16081         }
16082     }
16083     {
16084         PyThreadState* __tstate = wxPyBeginAllowThreads();
16085         result = (wxFindDialogEvent *)new wxFindDialogEvent(arg1,arg2);
16086
16087         wxPyEndAllowThreads(__tstate);
16088         if (PyErr_Occurred()) SWIG_fail;
16089     }
16090     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindDialogEvent, 1);
16091     return resultobj;
16092     fail:
16093     return NULL;
16094 }
16095
16096
16097 static PyObject *_wrap_FindDialogEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16098     PyObject *resultobj;
16099     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16100     int result;
16101     PyObject * obj0 = 0 ;
16102     char *kwnames[] = {
16103         (char *) "self", NULL
16104     };
16105
16106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetFlags",kwnames,&obj0)) goto fail;
16107     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16108     if (SWIG_arg_fail(1)) SWIG_fail;
16109     {
16110         PyThreadState* __tstate = wxPyBeginAllowThreads();
16111         result = (int)(arg1)->GetFlags();
16112
16113         wxPyEndAllowThreads(__tstate);
16114         if (PyErr_Occurred()) SWIG_fail;
16115     }
16116     {
16117         resultobj = SWIG_From_int((int)(result));
16118     }
16119     return resultobj;
16120     fail:
16121     return NULL;
16122 }
16123
16124
16125 static PyObject *_wrap_FindDialogEvent_GetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16126     PyObject *resultobj;
16127     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16128     wxString *result;
16129     PyObject * obj0 = 0 ;
16130     char *kwnames[] = {
16131         (char *) "self", NULL
16132     };
16133
16134     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetFindString",kwnames,&obj0)) goto fail;
16135     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16136     if (SWIG_arg_fail(1)) SWIG_fail;
16137     {
16138         PyThreadState* __tstate = wxPyBeginAllowThreads();
16139         {
16140             wxString const &_result_ref = (arg1)->GetFindString();
16141             result = (wxString *) &_result_ref;
16142         }
16143
16144         wxPyEndAllowThreads(__tstate);
16145         if (PyErr_Occurred()) SWIG_fail;
16146     }
16147     {
16148 #if wxUSE_UNICODE
16149         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16150 #else
16151         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16152 #endif
16153     }
16154     return resultobj;
16155     fail:
16156     return NULL;
16157 }
16158
16159
16160 static PyObject *_wrap_FindDialogEvent_GetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16161     PyObject *resultobj;
16162     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16163     wxString *result;
16164     PyObject * obj0 = 0 ;
16165     char *kwnames[] = {
16166         (char *) "self", NULL
16167     };
16168
16169     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetReplaceString",kwnames,&obj0)) goto fail;
16170     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16171     if (SWIG_arg_fail(1)) SWIG_fail;
16172     {
16173         PyThreadState* __tstate = wxPyBeginAllowThreads();
16174         {
16175             wxString const &_result_ref = (arg1)->GetReplaceString();
16176             result = (wxString *) &_result_ref;
16177         }
16178
16179         wxPyEndAllowThreads(__tstate);
16180         if (PyErr_Occurred()) SWIG_fail;
16181     }
16182     {
16183 #if wxUSE_UNICODE
16184         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16185 #else
16186         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16187 #endif
16188     }
16189     return resultobj;
16190     fail:
16191     return NULL;
16192 }
16193
16194
16195 static PyObject *_wrap_FindDialogEvent_GetDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16196     PyObject *resultobj;
16197     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16198     wxFindReplaceDialog *result;
16199     PyObject * obj0 = 0 ;
16200     char *kwnames[] = {
16201         (char *) "self", NULL
16202     };
16203
16204     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetDialog",kwnames,&obj0)) goto fail;
16205     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16206     if (SWIG_arg_fail(1)) SWIG_fail;
16207     {
16208         PyThreadState* __tstate = wxPyBeginAllowThreads();
16209         result = (wxFindReplaceDialog *)(arg1)->GetDialog();
16210
16211         wxPyEndAllowThreads(__tstate);
16212         if (PyErr_Occurred()) SWIG_fail;
16213     }
16214     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 0);
16215     return resultobj;
16216     fail:
16217     return NULL;
16218 }
16219
16220
16221 static PyObject *_wrap_FindDialogEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16222     PyObject *resultobj;
16223     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16224     int arg2 ;
16225     PyObject * obj0 = 0 ;
16226     PyObject * obj1 = 0 ;
16227     char *kwnames[] = {
16228         (char *) "self",(char *) "flags", NULL
16229     };
16230
16231     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
16232     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16233     if (SWIG_arg_fail(1)) SWIG_fail;
16234     {
16235         arg2 = (int)(SWIG_As_int(obj1));
16236         if (SWIG_arg_fail(2)) SWIG_fail;
16237     }
16238     {
16239         PyThreadState* __tstate = wxPyBeginAllowThreads();
16240         (arg1)->SetFlags(arg2);
16241
16242         wxPyEndAllowThreads(__tstate);
16243         if (PyErr_Occurred()) SWIG_fail;
16244     }
16245     Py_INCREF(Py_None); resultobj = Py_None;
16246     return resultobj;
16247     fail:
16248     return NULL;
16249 }
16250
16251
16252 static PyObject *_wrap_FindDialogEvent_SetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16253     PyObject *resultobj;
16254     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16255     wxString *arg2 = 0 ;
16256     bool temp2 = false ;
16257     PyObject * obj0 = 0 ;
16258     PyObject * obj1 = 0 ;
16259     char *kwnames[] = {
16260         (char *) "self",(char *) "str", NULL
16261     };
16262
16263     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetFindString",kwnames,&obj0,&obj1)) goto fail;
16264     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16265     if (SWIG_arg_fail(1)) SWIG_fail;
16266     {
16267         arg2 = wxString_in_helper(obj1);
16268         if (arg2 == NULL) SWIG_fail;
16269         temp2 = true;
16270     }
16271     {
16272         PyThreadState* __tstate = wxPyBeginAllowThreads();
16273         (arg1)->SetFindString((wxString const &)*arg2);
16274
16275         wxPyEndAllowThreads(__tstate);
16276         if (PyErr_Occurred()) SWIG_fail;
16277     }
16278     Py_INCREF(Py_None); resultobj = Py_None;
16279     {
16280         if (temp2)
16281         delete arg2;
16282     }
16283     return resultobj;
16284     fail:
16285     {
16286         if (temp2)
16287         delete arg2;
16288     }
16289     return NULL;
16290 }
16291
16292
16293 static PyObject *_wrap_FindDialogEvent_SetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16294     PyObject *resultobj;
16295     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16296     wxString *arg2 = 0 ;
16297     bool temp2 = false ;
16298     PyObject * obj0 = 0 ;
16299     PyObject * obj1 = 0 ;
16300     char *kwnames[] = {
16301         (char *) "self",(char *) "str", NULL
16302     };
16303
16304     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetReplaceString",kwnames,&obj0,&obj1)) goto fail;
16305     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16306     if (SWIG_arg_fail(1)) SWIG_fail;
16307     {
16308         arg2 = wxString_in_helper(obj1);
16309         if (arg2 == NULL) SWIG_fail;
16310         temp2 = true;
16311     }
16312     {
16313         PyThreadState* __tstate = wxPyBeginAllowThreads();
16314         (arg1)->SetReplaceString((wxString const &)*arg2);
16315
16316         wxPyEndAllowThreads(__tstate);
16317         if (PyErr_Occurred()) SWIG_fail;
16318     }
16319     Py_INCREF(Py_None); resultobj = Py_None;
16320     {
16321         if (temp2)
16322         delete arg2;
16323     }
16324     return resultobj;
16325     fail:
16326     {
16327         if (temp2)
16328         delete arg2;
16329     }
16330     return NULL;
16331 }
16332
16333
16334 static PyObject * FindDialogEvent_swigregister(PyObject *, PyObject *args) {
16335     PyObject *obj;
16336     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16337     SWIG_TypeClientData(SWIGTYPE_p_wxFindDialogEvent, obj);
16338     Py_INCREF(obj);
16339     return Py_BuildValue((char *)"");
16340 }
16341 static PyObject *_wrap_new_FindReplaceData(PyObject *, PyObject *args, PyObject *kwargs) {
16342     PyObject *resultobj;
16343     int arg1 = (int) 0 ;
16344     wxFindReplaceData *result;
16345     PyObject * obj0 = 0 ;
16346     char *kwnames[] = {
16347         (char *) "flags", NULL
16348     };
16349
16350     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_FindReplaceData",kwnames,&obj0)) goto fail;
16351     if (obj0) {
16352         {
16353             arg1 = (int)(SWIG_As_int(obj0));
16354             if (SWIG_arg_fail(1)) SWIG_fail;
16355         }
16356     }
16357     {
16358         PyThreadState* __tstate = wxPyBeginAllowThreads();
16359         result = (wxFindReplaceData *)new wxFindReplaceData(arg1);
16360
16361         wxPyEndAllowThreads(__tstate);
16362         if (PyErr_Occurred()) SWIG_fail;
16363     }
16364     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceData, 1);
16365     return resultobj;
16366     fail:
16367     return NULL;
16368 }
16369
16370
16371 static PyObject *_wrap_delete_FindReplaceData(PyObject *, PyObject *args, PyObject *kwargs) {
16372     PyObject *resultobj;
16373     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16374     PyObject * obj0 = 0 ;
16375     char *kwnames[] = {
16376         (char *) "self", NULL
16377     };
16378
16379     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FindReplaceData",kwnames,&obj0)) goto fail;
16380     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16381     if (SWIG_arg_fail(1)) SWIG_fail;
16382     {
16383         PyThreadState* __tstate = wxPyBeginAllowThreads();
16384         delete arg1;
16385
16386         wxPyEndAllowThreads(__tstate);
16387         if (PyErr_Occurred()) SWIG_fail;
16388     }
16389     Py_INCREF(Py_None); resultobj = Py_None;
16390     return resultobj;
16391     fail:
16392     return NULL;
16393 }
16394
16395
16396 static PyObject *_wrap_FindReplaceData_GetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16397     PyObject *resultobj;
16398     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16399     wxString *result;
16400     PyObject * obj0 = 0 ;
16401     char *kwnames[] = {
16402         (char *) "self", NULL
16403     };
16404
16405     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetFindString",kwnames,&obj0)) goto fail;
16406     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16407     if (SWIG_arg_fail(1)) SWIG_fail;
16408     {
16409         PyThreadState* __tstate = wxPyBeginAllowThreads();
16410         {
16411             wxString const &_result_ref = (arg1)->GetFindString();
16412             result = (wxString *) &_result_ref;
16413         }
16414
16415         wxPyEndAllowThreads(__tstate);
16416         if (PyErr_Occurred()) SWIG_fail;
16417     }
16418     {
16419 #if wxUSE_UNICODE
16420         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16421 #else
16422         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16423 #endif
16424     }
16425     return resultobj;
16426     fail:
16427     return NULL;
16428 }
16429
16430
16431 static PyObject *_wrap_FindReplaceData_GetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16432     PyObject *resultobj;
16433     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16434     wxString *result;
16435     PyObject * obj0 = 0 ;
16436     char *kwnames[] = {
16437         (char *) "self", NULL
16438     };
16439
16440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetReplaceString",kwnames,&obj0)) goto fail;
16441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16442     if (SWIG_arg_fail(1)) SWIG_fail;
16443     {
16444         PyThreadState* __tstate = wxPyBeginAllowThreads();
16445         {
16446             wxString const &_result_ref = (arg1)->GetReplaceString();
16447             result = (wxString *) &_result_ref;
16448         }
16449
16450         wxPyEndAllowThreads(__tstate);
16451         if (PyErr_Occurred()) SWIG_fail;
16452     }
16453     {
16454 #if wxUSE_UNICODE
16455         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16456 #else
16457         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16458 #endif
16459     }
16460     return resultobj;
16461     fail:
16462     return NULL;
16463 }
16464
16465
16466 static PyObject *_wrap_FindReplaceData_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16467     PyObject *resultobj;
16468     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16469     int result;
16470     PyObject * obj0 = 0 ;
16471     char *kwnames[] = {
16472         (char *) "self", NULL
16473     };
16474
16475     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetFlags",kwnames,&obj0)) goto fail;
16476     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16477     if (SWIG_arg_fail(1)) SWIG_fail;
16478     {
16479         PyThreadState* __tstate = wxPyBeginAllowThreads();
16480         result = (int)(arg1)->GetFlags();
16481
16482         wxPyEndAllowThreads(__tstate);
16483         if (PyErr_Occurred()) SWIG_fail;
16484     }
16485     {
16486         resultobj = SWIG_From_int((int)(result));
16487     }
16488     return resultobj;
16489     fail:
16490     return NULL;
16491 }
16492
16493
16494 static PyObject *_wrap_FindReplaceData_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16495     PyObject *resultobj;
16496     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16497     int arg2 ;
16498     PyObject * obj0 = 0 ;
16499     PyObject * obj1 = 0 ;
16500     char *kwnames[] = {
16501         (char *) "self",(char *) "flags", NULL
16502     };
16503
16504     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetFlags",kwnames,&obj0,&obj1)) goto fail;
16505     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16506     if (SWIG_arg_fail(1)) SWIG_fail;
16507     {
16508         arg2 = (int)(SWIG_As_int(obj1));
16509         if (SWIG_arg_fail(2)) SWIG_fail;
16510     }
16511     {
16512         PyThreadState* __tstate = wxPyBeginAllowThreads();
16513         (arg1)->SetFlags(arg2);
16514
16515         wxPyEndAllowThreads(__tstate);
16516         if (PyErr_Occurred()) SWIG_fail;
16517     }
16518     Py_INCREF(Py_None); resultobj = Py_None;
16519     return resultobj;
16520     fail:
16521     return NULL;
16522 }
16523
16524
16525 static PyObject *_wrap_FindReplaceData_SetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16526     PyObject *resultobj;
16527     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16528     wxString *arg2 = 0 ;
16529     bool temp2 = false ;
16530     PyObject * obj0 = 0 ;
16531     PyObject * obj1 = 0 ;
16532     char *kwnames[] = {
16533         (char *) "self",(char *) "str", NULL
16534     };
16535
16536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetFindString",kwnames,&obj0,&obj1)) goto fail;
16537     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16538     if (SWIG_arg_fail(1)) SWIG_fail;
16539     {
16540         arg2 = wxString_in_helper(obj1);
16541         if (arg2 == NULL) SWIG_fail;
16542         temp2 = true;
16543     }
16544     {
16545         PyThreadState* __tstate = wxPyBeginAllowThreads();
16546         (arg1)->SetFindString((wxString const &)*arg2);
16547
16548         wxPyEndAllowThreads(__tstate);
16549         if (PyErr_Occurred()) SWIG_fail;
16550     }
16551     Py_INCREF(Py_None); resultobj = Py_None;
16552     {
16553         if (temp2)
16554         delete arg2;
16555     }
16556     return resultobj;
16557     fail:
16558     {
16559         if (temp2)
16560         delete arg2;
16561     }
16562     return NULL;
16563 }
16564
16565
16566 static PyObject *_wrap_FindReplaceData_SetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16567     PyObject *resultobj;
16568     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16569     wxString *arg2 = 0 ;
16570     bool temp2 = false ;
16571     PyObject * obj0 = 0 ;
16572     PyObject * obj1 = 0 ;
16573     char *kwnames[] = {
16574         (char *) "self",(char *) "str", NULL
16575     };
16576
16577     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetReplaceString",kwnames,&obj0,&obj1)) goto fail;
16578     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16579     if (SWIG_arg_fail(1)) SWIG_fail;
16580     {
16581         arg2 = wxString_in_helper(obj1);
16582         if (arg2 == NULL) SWIG_fail;
16583         temp2 = true;
16584     }
16585     {
16586         PyThreadState* __tstate = wxPyBeginAllowThreads();
16587         (arg1)->SetReplaceString((wxString const &)*arg2);
16588
16589         wxPyEndAllowThreads(__tstate);
16590         if (PyErr_Occurred()) SWIG_fail;
16591     }
16592     Py_INCREF(Py_None); resultobj = Py_None;
16593     {
16594         if (temp2)
16595         delete arg2;
16596     }
16597     return resultobj;
16598     fail:
16599     {
16600         if (temp2)
16601         delete arg2;
16602     }
16603     return NULL;
16604 }
16605
16606
16607 static PyObject * FindReplaceData_swigregister(PyObject *, PyObject *args) {
16608     PyObject *obj;
16609     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16610     SWIG_TypeClientData(SWIGTYPE_p_wxFindReplaceData, obj);
16611     Py_INCREF(obj);
16612     return Py_BuildValue((char *)"");
16613 }
16614 static PyObject *_wrap_new_FindReplaceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16615     PyObject *resultobj;
16616     wxWindow *arg1 = (wxWindow *) 0 ;
16617     wxFindReplaceData *arg2 = (wxFindReplaceData *) 0 ;
16618     wxString *arg3 = 0 ;
16619     int arg4 = (int) 0 ;
16620     wxFindReplaceDialog *result;
16621     bool temp3 = false ;
16622     PyObject * obj0 = 0 ;
16623     PyObject * obj1 = 0 ;
16624     PyObject * obj2 = 0 ;
16625     PyObject * obj3 = 0 ;
16626     char *kwnames[] = {
16627         (char *) "parent",(char *) "data",(char *) "title",(char *) "style", NULL
16628     };
16629
16630     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_FindReplaceDialog",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16631     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16632     if (SWIG_arg_fail(1)) SWIG_fail;
16633     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16634     if (SWIG_arg_fail(2)) SWIG_fail;
16635     {
16636         arg3 = wxString_in_helper(obj2);
16637         if (arg3 == NULL) SWIG_fail;
16638         temp3 = true;
16639     }
16640     if (obj3) {
16641         {
16642             arg4 = (int)(SWIG_As_int(obj3));
16643             if (SWIG_arg_fail(4)) SWIG_fail;
16644         }
16645     }
16646     {
16647         if (!wxPyCheckForApp()) SWIG_fail;
16648         PyThreadState* __tstate = wxPyBeginAllowThreads();
16649         result = (wxFindReplaceDialog *)new wxFindReplaceDialog(arg1,arg2,(wxString const &)*arg3,arg4);
16650
16651         wxPyEndAllowThreads(__tstate);
16652         if (PyErr_Occurred()) SWIG_fail;
16653     }
16654     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 1);
16655     {
16656         if (temp3)
16657         delete arg3;
16658     }
16659     return resultobj;
16660     fail:
16661     {
16662         if (temp3)
16663         delete arg3;
16664     }
16665     return NULL;
16666 }
16667
16668
16669 static PyObject *_wrap_new_PreFindReplaceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16670     PyObject *resultobj;
16671     wxFindReplaceDialog *result;
16672     char *kwnames[] = {
16673         NULL
16674     };
16675
16676     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreFindReplaceDialog",kwnames)) goto fail;
16677     {
16678         if (!wxPyCheckForApp()) SWIG_fail;
16679         PyThreadState* __tstate = wxPyBeginAllowThreads();
16680         result = (wxFindReplaceDialog *)new wxFindReplaceDialog();
16681
16682         wxPyEndAllowThreads(__tstate);
16683         if (PyErr_Occurred()) SWIG_fail;
16684     }
16685     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 1);
16686     return resultobj;
16687     fail:
16688     return NULL;
16689 }
16690
16691
16692 static PyObject *_wrap_FindReplaceDialog_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16693     PyObject *resultobj;
16694     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16695     wxWindow *arg2 = (wxWindow *) 0 ;
16696     wxFindReplaceData *arg3 = (wxFindReplaceData *) 0 ;
16697     wxString *arg4 = 0 ;
16698     int arg5 = (int) 0 ;
16699     bool result;
16700     bool temp4 = false ;
16701     PyObject * obj0 = 0 ;
16702     PyObject * obj1 = 0 ;
16703     PyObject * obj2 = 0 ;
16704     PyObject * obj3 = 0 ;
16705     PyObject * obj4 = 0 ;
16706     char *kwnames[] = {
16707         (char *) "self",(char *) "parent",(char *) "data",(char *) "title",(char *) "style", NULL
16708     };
16709
16710     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:FindReplaceDialog_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
16711     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16712     if (SWIG_arg_fail(1)) SWIG_fail;
16713     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16714     if (SWIG_arg_fail(2)) SWIG_fail;
16715     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16716     if (SWIG_arg_fail(3)) SWIG_fail;
16717     {
16718         arg4 = wxString_in_helper(obj3);
16719         if (arg4 == NULL) SWIG_fail;
16720         temp4 = true;
16721     }
16722     if (obj4) {
16723         {
16724             arg5 = (int)(SWIG_As_int(obj4));
16725             if (SWIG_arg_fail(5)) SWIG_fail;
16726         }
16727     }
16728     {
16729         PyThreadState* __tstate = wxPyBeginAllowThreads();
16730         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,arg5);
16731
16732         wxPyEndAllowThreads(__tstate);
16733         if (PyErr_Occurred()) SWIG_fail;
16734     }
16735     {
16736         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16737     }
16738     {
16739         if (temp4)
16740         delete arg4;
16741     }
16742     return resultobj;
16743     fail:
16744     {
16745         if (temp4)
16746         delete arg4;
16747     }
16748     return NULL;
16749 }
16750
16751
16752 static PyObject *_wrap_FindReplaceDialog_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
16753     PyObject *resultobj;
16754     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16755     wxFindReplaceData *result;
16756     PyObject * obj0 = 0 ;
16757     char *kwnames[] = {
16758         (char *) "self", NULL
16759     };
16760
16761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceDialog_GetData",kwnames,&obj0)) goto fail;
16762     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16763     if (SWIG_arg_fail(1)) SWIG_fail;
16764     {
16765         PyThreadState* __tstate = wxPyBeginAllowThreads();
16766         result = (wxFindReplaceData *)(arg1)->GetData();
16767
16768         wxPyEndAllowThreads(__tstate);
16769         if (PyErr_Occurred()) SWIG_fail;
16770     }
16771     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceData, 0);
16772     return resultobj;
16773     fail:
16774     return NULL;
16775 }
16776
16777
16778 static PyObject *_wrap_FindReplaceDialog_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
16779     PyObject *resultobj;
16780     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16781     wxFindReplaceData *arg2 = (wxFindReplaceData *) 0 ;
16782     PyObject * obj0 = 0 ;
16783     PyObject * obj1 = 0 ;
16784     char *kwnames[] = {
16785         (char *) "self",(char *) "data", NULL
16786     };
16787
16788     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceDialog_SetData",kwnames,&obj0,&obj1)) goto fail;
16789     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16790     if (SWIG_arg_fail(1)) SWIG_fail;
16791     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16792     if (SWIG_arg_fail(2)) SWIG_fail;
16793     {
16794         PyThreadState* __tstate = wxPyBeginAllowThreads();
16795         (arg1)->SetData(arg2);
16796
16797         wxPyEndAllowThreads(__tstate);
16798         if (PyErr_Occurred()) SWIG_fail;
16799     }
16800     Py_INCREF(Py_None); resultobj = Py_None;
16801     return resultobj;
16802     fail:
16803     return NULL;
16804 }
16805
16806
16807 static PyObject * FindReplaceDialog_swigregister(PyObject *, PyObject *args) {
16808     PyObject *obj;
16809     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16810     SWIG_TypeClientData(SWIGTYPE_p_wxFindReplaceDialog, obj);
16811     Py_INCREF(obj);
16812     return Py_BuildValue((char *)"");
16813 }
16814 static PyObject *_wrap_new_MDIParentFrame(PyObject *, PyObject *args, PyObject *kwargs) {
16815     PyObject *resultobj;
16816     wxWindow *arg1 = (wxWindow *) 0 ;
16817     int arg2 = (int) (int)-1 ;
16818     wxString const &arg3_defvalue = wxPyEmptyString ;
16819     wxString *arg3 = (wxString *) &arg3_defvalue ;
16820     wxPoint const &arg4_defvalue = wxDefaultPosition ;
16821     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
16822     wxSize const &arg5_defvalue = wxDefaultSize ;
16823     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
16824     long arg6 = (long) wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL ;
16825     wxString const &arg7_defvalue = wxPyFrameNameStr ;
16826     wxString *arg7 = (wxString *) &arg7_defvalue ;
16827     wxMDIParentFrame *result;
16828     bool temp3 = false ;
16829     wxPoint temp4 ;
16830     wxSize temp5 ;
16831     bool temp7 = false ;
16832     PyObject * obj0 = 0 ;
16833     PyObject * obj1 = 0 ;
16834     PyObject * obj2 = 0 ;
16835     PyObject * obj3 = 0 ;
16836     PyObject * obj4 = 0 ;
16837     PyObject * obj5 = 0 ;
16838     PyObject * obj6 = 0 ;
16839     char *kwnames[] = {
16840         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
16841     };
16842
16843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MDIParentFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
16844     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16845     if (SWIG_arg_fail(1)) SWIG_fail;
16846     if (obj1) {
16847         {
16848             arg2 = (int const)(SWIG_As_int(obj1));
16849             if (SWIG_arg_fail(2)) SWIG_fail;
16850         }
16851     }
16852     if (obj2) {
16853         {
16854             arg3 = wxString_in_helper(obj2);
16855             if (arg3 == NULL) SWIG_fail;
16856             temp3 = true;
16857         }
16858     }
16859     if (obj3) {
16860         {
16861             arg4 = &temp4;
16862             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
16863         }
16864     }
16865     if (obj4) {
16866         {
16867             arg5 = &temp5;
16868             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
16869         }
16870     }
16871     if (obj5) {
16872         {
16873             arg6 = (long)(SWIG_As_long(obj5));
16874             if (SWIG_arg_fail(6)) SWIG_fail;
16875         }
16876     }
16877     if (obj6) {
16878         {
16879             arg7 = wxString_in_helper(obj6);
16880             if (arg7 == NULL) SWIG_fail;
16881             temp7 = true;
16882         }
16883     }
16884     {
16885         if (!wxPyCheckForApp()) SWIG_fail;
16886         PyThreadState* __tstate = wxPyBeginAllowThreads();
16887         result = (wxMDIParentFrame *)new wxMDIParentFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
16888
16889         wxPyEndAllowThreads(__tstate);
16890         if (PyErr_Occurred()) SWIG_fail;
16891     }
16892     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIParentFrame, 1);
16893     {
16894         if (temp3)
16895         delete arg3;
16896     }
16897     {
16898         if (temp7)
16899         delete arg7;
16900     }
16901     return resultobj;
16902     fail:
16903     {
16904         if (temp3)
16905         delete arg3;
16906     }
16907     {
16908         if (temp7)
16909         delete arg7;
16910     }
16911     return NULL;
16912 }
16913
16914
16915 static PyObject *_wrap_new_PreMDIParentFrame(PyObject *, PyObject *args, PyObject *kwargs) {
16916     PyObject *resultobj;
16917     wxMDIParentFrame *result;
16918     char *kwnames[] = {
16919         NULL
16920     };
16921
16922     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIParentFrame",kwnames)) goto fail;
16923     {
16924         if (!wxPyCheckForApp()) SWIG_fail;
16925         PyThreadState* __tstate = wxPyBeginAllowThreads();
16926         result = (wxMDIParentFrame *)new wxMDIParentFrame();
16927
16928         wxPyEndAllowThreads(__tstate);
16929         if (PyErr_Occurred()) SWIG_fail;
16930     }
16931     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIParentFrame, 1);
16932     return resultobj;
16933     fail:
16934     return NULL;
16935 }
16936
16937
16938 static PyObject *_wrap_MDIParentFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16939     PyObject *resultobj;
16940     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
16941     wxWindow *arg2 = (wxWindow *) 0 ;
16942     int arg3 = (int) (int)-1 ;
16943     wxString const &arg4_defvalue = wxPyEmptyString ;
16944     wxString *arg4 = (wxString *) &arg4_defvalue ;
16945     wxPoint const &arg5_defvalue = wxDefaultPosition ;
16946     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
16947     wxSize const &arg6_defvalue = wxDefaultSize ;
16948     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
16949     long arg7 = (long) wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL ;
16950     wxString const &arg8_defvalue = wxPyFrameNameStr ;
16951     wxString *arg8 = (wxString *) &arg8_defvalue ;
16952     bool result;
16953     bool temp4 = false ;
16954     wxPoint temp5 ;
16955     wxSize temp6 ;
16956     bool temp8 = false ;
16957     PyObject * obj0 = 0 ;
16958     PyObject * obj1 = 0 ;
16959     PyObject * obj2 = 0 ;
16960     PyObject * obj3 = 0 ;
16961     PyObject * obj4 = 0 ;
16962     PyObject * obj5 = 0 ;
16963     PyObject * obj6 = 0 ;
16964     PyObject * obj7 = 0 ;
16965     char *kwnames[] = {
16966         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
16967     };
16968
16969     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MDIParentFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
16970     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
16971     if (SWIG_arg_fail(1)) SWIG_fail;
16972     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16973     if (SWIG_arg_fail(2)) SWIG_fail;
16974     if (obj2) {
16975         {
16976             arg3 = (int const)(SWIG_As_int(obj2));
16977             if (SWIG_arg_fail(3)) SWIG_fail;
16978         }
16979     }
16980     if (obj3) {
16981         {
16982             arg4 = wxString_in_helper(obj3);
16983             if (arg4 == NULL) SWIG_fail;
16984             temp4 = true;
16985         }
16986     }
16987     if (obj4) {
16988         {
16989             arg5 = &temp5;
16990             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
16991         }
16992     }
16993     if (obj5) {
16994         {
16995             arg6 = &temp6;
16996             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
16997         }
16998     }
16999     if (obj6) {
17000         {
17001             arg7 = (long)(SWIG_As_long(obj6));
17002             if (SWIG_arg_fail(7)) SWIG_fail;
17003         }
17004     }
17005     if (obj7) {
17006         {
17007             arg8 = wxString_in_helper(obj7);
17008             if (arg8 == NULL) SWIG_fail;
17009             temp8 = true;
17010         }
17011     }
17012     {
17013         PyThreadState* __tstate = wxPyBeginAllowThreads();
17014         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
17015
17016         wxPyEndAllowThreads(__tstate);
17017         if (PyErr_Occurred()) SWIG_fail;
17018     }
17019     {
17020         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17021     }
17022     {
17023         if (temp4)
17024         delete arg4;
17025     }
17026     {
17027         if (temp8)
17028         delete arg8;
17029     }
17030     return resultobj;
17031     fail:
17032     {
17033         if (temp4)
17034         delete arg4;
17035     }
17036     {
17037         if (temp8)
17038         delete arg8;
17039     }
17040     return NULL;
17041 }
17042
17043
17044 static PyObject *_wrap_MDIParentFrame_ActivateNext(PyObject *, PyObject *args, PyObject *kwargs) {
17045     PyObject *resultobj;
17046     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17047     PyObject * obj0 = 0 ;
17048     char *kwnames[] = {
17049         (char *) "self", NULL
17050     };
17051
17052     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ActivateNext",kwnames,&obj0)) goto fail;
17053     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17054     if (SWIG_arg_fail(1)) SWIG_fail;
17055     {
17056         PyThreadState* __tstate = wxPyBeginAllowThreads();
17057         (arg1)->ActivateNext();
17058
17059         wxPyEndAllowThreads(__tstate);
17060         if (PyErr_Occurred()) SWIG_fail;
17061     }
17062     Py_INCREF(Py_None); resultobj = Py_None;
17063     return resultobj;
17064     fail:
17065     return NULL;
17066 }
17067
17068
17069 static PyObject *_wrap_MDIParentFrame_ActivatePrevious(PyObject *, PyObject *args, PyObject *kwargs) {
17070     PyObject *resultobj;
17071     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17072     PyObject * obj0 = 0 ;
17073     char *kwnames[] = {
17074         (char *) "self", NULL
17075     };
17076
17077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ActivatePrevious",kwnames,&obj0)) goto fail;
17078     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17079     if (SWIG_arg_fail(1)) SWIG_fail;
17080     {
17081         PyThreadState* __tstate = wxPyBeginAllowThreads();
17082         (arg1)->ActivatePrevious();
17083
17084         wxPyEndAllowThreads(__tstate);
17085         if (PyErr_Occurred()) SWIG_fail;
17086     }
17087     Py_INCREF(Py_None); resultobj = Py_None;
17088     return resultobj;
17089     fail:
17090     return NULL;
17091 }
17092
17093
17094 static PyObject *_wrap_MDIParentFrame_ArrangeIcons(PyObject *, PyObject *args, PyObject *kwargs) {
17095     PyObject *resultobj;
17096     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17097     PyObject * obj0 = 0 ;
17098     char *kwnames[] = {
17099         (char *) "self", NULL
17100     };
17101
17102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ArrangeIcons",kwnames,&obj0)) goto fail;
17103     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17104     if (SWIG_arg_fail(1)) SWIG_fail;
17105     {
17106         PyThreadState* __tstate = wxPyBeginAllowThreads();
17107         (arg1)->ArrangeIcons();
17108
17109         wxPyEndAllowThreads(__tstate);
17110         if (PyErr_Occurred()) SWIG_fail;
17111     }
17112     Py_INCREF(Py_None); resultobj = Py_None;
17113     return resultobj;
17114     fail:
17115     return NULL;
17116 }
17117
17118
17119 static PyObject *_wrap_MDIParentFrame_Cascade(PyObject *, PyObject *args, PyObject *kwargs) {
17120     PyObject *resultobj;
17121     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17122     PyObject * obj0 = 0 ;
17123     char *kwnames[] = {
17124         (char *) "self", NULL
17125     };
17126
17127     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_Cascade",kwnames,&obj0)) goto fail;
17128     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17129     if (SWIG_arg_fail(1)) SWIG_fail;
17130     {
17131         PyThreadState* __tstate = wxPyBeginAllowThreads();
17132         (arg1)->Cascade();
17133
17134         wxPyEndAllowThreads(__tstate);
17135         if (PyErr_Occurred()) SWIG_fail;
17136     }
17137     Py_INCREF(Py_None); resultobj = Py_None;
17138     return resultobj;
17139     fail:
17140     return NULL;
17141 }
17142
17143
17144 static PyObject *_wrap_MDIParentFrame_GetActiveChild(PyObject *, PyObject *args, PyObject *kwargs) {
17145     PyObject *resultobj;
17146     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17147     wxMDIChildFrame *result;
17148     PyObject * obj0 = 0 ;
17149     char *kwnames[] = {
17150         (char *) "self", NULL
17151     };
17152
17153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetActiveChild",kwnames,&obj0)) goto fail;
17154     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17155     if (SWIG_arg_fail(1)) SWIG_fail;
17156     {
17157         PyThreadState* __tstate = wxPyBeginAllowThreads();
17158         result = (wxMDIChildFrame *)(arg1)->GetActiveChild();
17159
17160         wxPyEndAllowThreads(__tstate);
17161         if (PyErr_Occurred()) SWIG_fail;
17162     }
17163     {
17164         resultobj = wxPyMake_wxObject(result, 0);
17165     }
17166     return resultobj;
17167     fail:
17168     return NULL;
17169 }
17170
17171
17172 static PyObject *_wrap_MDIParentFrame_GetClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17173     PyObject *resultobj;
17174     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17175     wxMDIClientWindow *result;
17176     PyObject * obj0 = 0 ;
17177     char *kwnames[] = {
17178         (char *) "self", NULL
17179     };
17180
17181     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetClientWindow",kwnames,&obj0)) goto fail;
17182     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17183     if (SWIG_arg_fail(1)) SWIG_fail;
17184     {
17185         PyThreadState* __tstate = wxPyBeginAllowThreads();
17186         result = (wxMDIClientWindow *)(arg1)->GetClientWindow();
17187
17188         wxPyEndAllowThreads(__tstate);
17189         if (PyErr_Occurred()) SWIG_fail;
17190     }
17191     {
17192         resultobj = wxPyMake_wxObject(result, 0);
17193     }
17194     return resultobj;
17195     fail:
17196     return NULL;
17197 }
17198
17199
17200 static PyObject *_wrap_MDIParentFrame_GetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
17201     PyObject *resultobj;
17202     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17203     wxWindow *result;
17204     PyObject * obj0 = 0 ;
17205     char *kwnames[] = {
17206         (char *) "self", NULL
17207     };
17208
17209     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetToolBar",kwnames,&obj0)) goto fail;
17210     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17211     if (SWIG_arg_fail(1)) SWIG_fail;
17212     {
17213         PyThreadState* __tstate = wxPyBeginAllowThreads();
17214         result = (wxWindow *)(arg1)->GetToolBar();
17215
17216         wxPyEndAllowThreads(__tstate);
17217         if (PyErr_Occurred()) SWIG_fail;
17218     }
17219     {
17220         resultobj = wxPyMake_wxObject(result, 0);
17221     }
17222     return resultobj;
17223     fail:
17224     return NULL;
17225 }
17226
17227
17228 static PyObject *_wrap_MDIParentFrame_GetWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
17229     PyObject *resultobj;
17230     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17231     wxMenu *result;
17232     PyObject * obj0 = 0 ;
17233     char *kwnames[] = {
17234         (char *) "self", NULL
17235     };
17236
17237     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetWindowMenu",kwnames,&obj0)) goto fail;
17238     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17239     if (SWIG_arg_fail(1)) SWIG_fail;
17240     {
17241         PyThreadState* __tstate = wxPyBeginAllowThreads();
17242         result = (wxMenu *)(arg1)->GetWindowMenu();
17243
17244         wxPyEndAllowThreads(__tstate);
17245         if (PyErr_Occurred()) SWIG_fail;
17246     }
17247     {
17248         resultobj = wxPyMake_wxObject(result, 0);
17249     }
17250     return resultobj;
17251     fail:
17252     return NULL;
17253 }
17254
17255
17256 static PyObject *_wrap_MDIParentFrame_SetWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
17257     PyObject *resultobj;
17258     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17259     wxMenu *arg2 = (wxMenu *) 0 ;
17260     PyObject * obj0 = 0 ;
17261     PyObject * obj1 = 0 ;
17262     char *kwnames[] = {
17263         (char *) "self",(char *) "menu", NULL
17264     };
17265
17266     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MDIParentFrame_SetWindowMenu",kwnames,&obj0,&obj1)) goto fail;
17267     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17268     if (SWIG_arg_fail(1)) SWIG_fail;
17269     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
17270     if (SWIG_arg_fail(2)) SWIG_fail;
17271     {
17272         PyThreadState* __tstate = wxPyBeginAllowThreads();
17273         (arg1)->SetWindowMenu(arg2);
17274
17275         wxPyEndAllowThreads(__tstate);
17276         if (PyErr_Occurred()) SWIG_fail;
17277     }
17278     Py_INCREF(Py_None); resultobj = Py_None;
17279     return resultobj;
17280     fail:
17281     return NULL;
17282 }
17283
17284
17285 static PyObject *_wrap_MDIParentFrame_SetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
17286     PyObject *resultobj;
17287     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17288     wxToolBar *arg2 = (wxToolBar *) 0 ;
17289     PyObject * obj0 = 0 ;
17290     PyObject * obj1 = 0 ;
17291     char *kwnames[] = {
17292         (char *) "self",(char *) "toolbar", NULL
17293     };
17294
17295     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MDIParentFrame_SetToolBar",kwnames,&obj0,&obj1)) goto fail;
17296     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17297     if (SWIG_arg_fail(1)) SWIG_fail;
17298     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolBar, SWIG_POINTER_EXCEPTION | 0);
17299     if (SWIG_arg_fail(2)) SWIG_fail;
17300     {
17301         PyThreadState* __tstate = wxPyBeginAllowThreads();
17302         (arg1)->SetToolBar(arg2);
17303
17304         wxPyEndAllowThreads(__tstate);
17305         if (PyErr_Occurred()) SWIG_fail;
17306     }
17307     Py_INCREF(Py_None); resultobj = Py_None;
17308     return resultobj;
17309     fail:
17310     return NULL;
17311 }
17312
17313
17314 static PyObject *_wrap_MDIParentFrame_Tile(PyObject *, PyObject *args, PyObject *kwargs) {
17315     PyObject *resultobj;
17316     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17317     PyObject * obj0 = 0 ;
17318     char *kwnames[] = {
17319         (char *) "self", NULL
17320     };
17321
17322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_Tile",kwnames,&obj0)) goto fail;
17323     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17324     if (SWIG_arg_fail(1)) SWIG_fail;
17325     {
17326         PyThreadState* __tstate = wxPyBeginAllowThreads();
17327         (arg1)->Tile();
17328
17329         wxPyEndAllowThreads(__tstate);
17330         if (PyErr_Occurred()) SWIG_fail;
17331     }
17332     Py_INCREF(Py_None); resultobj = Py_None;
17333     return resultobj;
17334     fail:
17335     return NULL;
17336 }
17337
17338
17339 static PyObject * MDIParentFrame_swigregister(PyObject *, PyObject *args) {
17340     PyObject *obj;
17341     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17342     SWIG_TypeClientData(SWIGTYPE_p_wxMDIParentFrame, obj);
17343     Py_INCREF(obj);
17344     return Py_BuildValue((char *)"");
17345 }
17346 static PyObject *_wrap_new_MDIChildFrame(PyObject *, PyObject *args, PyObject *kwargs) {
17347     PyObject *resultobj;
17348     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17349     int arg2 = (int) (int)-1 ;
17350     wxString const &arg3_defvalue = wxPyEmptyString ;
17351     wxString *arg3 = (wxString *) &arg3_defvalue ;
17352     wxPoint const &arg4_defvalue = wxDefaultPosition ;
17353     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
17354     wxSize const &arg5_defvalue = wxDefaultSize ;
17355     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
17356     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
17357     wxString const &arg7_defvalue = wxPyFrameNameStr ;
17358     wxString *arg7 = (wxString *) &arg7_defvalue ;
17359     wxMDIChildFrame *result;
17360     bool temp3 = false ;
17361     wxPoint temp4 ;
17362     wxSize temp5 ;
17363     bool temp7 = false ;
17364     PyObject * obj0 = 0 ;
17365     PyObject * obj1 = 0 ;
17366     PyObject * obj2 = 0 ;
17367     PyObject * obj3 = 0 ;
17368     PyObject * obj4 = 0 ;
17369     PyObject * obj5 = 0 ;
17370     PyObject * obj6 = 0 ;
17371     char *kwnames[] = {
17372         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17373     };
17374
17375     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MDIChildFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
17376     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17377     if (SWIG_arg_fail(1)) SWIG_fail;
17378     if (obj1) {
17379         {
17380             arg2 = (int const)(SWIG_As_int(obj1));
17381             if (SWIG_arg_fail(2)) SWIG_fail;
17382         }
17383     }
17384     if (obj2) {
17385         {
17386             arg3 = wxString_in_helper(obj2);
17387             if (arg3 == NULL) SWIG_fail;
17388             temp3 = true;
17389         }
17390     }
17391     if (obj3) {
17392         {
17393             arg4 = &temp4;
17394             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17395         }
17396     }
17397     if (obj4) {
17398         {
17399             arg5 = &temp5;
17400             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
17401         }
17402     }
17403     if (obj5) {
17404         {
17405             arg6 = (long)(SWIG_As_long(obj5));
17406             if (SWIG_arg_fail(6)) SWIG_fail;
17407         }
17408     }
17409     if (obj6) {
17410         {
17411             arg7 = wxString_in_helper(obj6);
17412             if (arg7 == NULL) SWIG_fail;
17413             temp7 = true;
17414         }
17415     }
17416     {
17417         if (!wxPyCheckForApp()) SWIG_fail;
17418         PyThreadState* __tstate = wxPyBeginAllowThreads();
17419         result = (wxMDIChildFrame *)new wxMDIChildFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
17420
17421         wxPyEndAllowThreads(__tstate);
17422         if (PyErr_Occurred()) SWIG_fail;
17423     }
17424     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIChildFrame, 1);
17425     {
17426         if (temp3)
17427         delete arg3;
17428     }
17429     {
17430         if (temp7)
17431         delete arg7;
17432     }
17433     return resultobj;
17434     fail:
17435     {
17436         if (temp3)
17437         delete arg3;
17438     }
17439     {
17440         if (temp7)
17441         delete arg7;
17442     }
17443     return NULL;
17444 }
17445
17446
17447 static PyObject *_wrap_new_PreMDIChildFrame(PyObject *, PyObject *args, PyObject *kwargs) {
17448     PyObject *resultobj;
17449     wxMDIChildFrame *result;
17450     char *kwnames[] = {
17451         NULL
17452     };
17453
17454     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIChildFrame",kwnames)) goto fail;
17455     {
17456         if (!wxPyCheckForApp()) SWIG_fail;
17457         PyThreadState* __tstate = wxPyBeginAllowThreads();
17458         result = (wxMDIChildFrame *)new wxMDIChildFrame();
17459
17460         wxPyEndAllowThreads(__tstate);
17461         if (PyErr_Occurred()) SWIG_fail;
17462     }
17463     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIChildFrame, 1);
17464     return resultobj;
17465     fail:
17466     return NULL;
17467 }
17468
17469
17470 static PyObject *_wrap_MDIChildFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17471     PyObject *resultobj;
17472     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17473     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
17474     int arg3 = (int) (int)-1 ;
17475     wxString const &arg4_defvalue = wxPyEmptyString ;
17476     wxString *arg4 = (wxString *) &arg4_defvalue ;
17477     wxPoint const &arg5_defvalue = wxDefaultPosition ;
17478     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
17479     wxSize const &arg6_defvalue = wxDefaultSize ;
17480     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
17481     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
17482     wxString const &arg8_defvalue = wxPyFrameNameStr ;
17483     wxString *arg8 = (wxString *) &arg8_defvalue ;
17484     bool result;
17485     bool temp4 = false ;
17486     wxPoint temp5 ;
17487     wxSize temp6 ;
17488     bool temp8 = false ;
17489     PyObject * obj0 = 0 ;
17490     PyObject * obj1 = 0 ;
17491     PyObject * obj2 = 0 ;
17492     PyObject * obj3 = 0 ;
17493     PyObject * obj4 = 0 ;
17494     PyObject * obj5 = 0 ;
17495     PyObject * obj6 = 0 ;
17496     PyObject * obj7 = 0 ;
17497     char *kwnames[] = {
17498         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17499     };
17500
17501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MDIChildFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
17502     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17503     if (SWIG_arg_fail(1)) SWIG_fail;
17504     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17505     if (SWIG_arg_fail(2)) SWIG_fail;
17506     if (obj2) {
17507         {
17508             arg3 = (int const)(SWIG_As_int(obj2));
17509             if (SWIG_arg_fail(3)) SWIG_fail;
17510         }
17511     }
17512     if (obj3) {
17513         {
17514             arg4 = wxString_in_helper(obj3);
17515             if (arg4 == NULL) SWIG_fail;
17516             temp4 = true;
17517         }
17518     }
17519     if (obj4) {
17520         {
17521             arg5 = &temp5;
17522             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
17523         }
17524     }
17525     if (obj5) {
17526         {
17527             arg6 = &temp6;
17528             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
17529         }
17530     }
17531     if (obj6) {
17532         {
17533             arg7 = (long)(SWIG_As_long(obj6));
17534             if (SWIG_arg_fail(7)) SWIG_fail;
17535         }
17536     }
17537     if (obj7) {
17538         {
17539             arg8 = wxString_in_helper(obj7);
17540             if (arg8 == NULL) SWIG_fail;
17541             temp8 = true;
17542         }
17543     }
17544     {
17545         PyThreadState* __tstate = wxPyBeginAllowThreads();
17546         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
17547
17548         wxPyEndAllowThreads(__tstate);
17549         if (PyErr_Occurred()) SWIG_fail;
17550     }
17551     {
17552         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17553     }
17554     {
17555         if (temp4)
17556         delete arg4;
17557     }
17558     {
17559         if (temp8)
17560         delete arg8;
17561     }
17562     return resultobj;
17563     fail:
17564     {
17565         if (temp4)
17566         delete arg4;
17567     }
17568     {
17569         if (temp8)
17570         delete arg8;
17571     }
17572     return NULL;
17573 }
17574
17575
17576 static PyObject *_wrap_MDIChildFrame_Activate(PyObject *, PyObject *args, PyObject *kwargs) {
17577     PyObject *resultobj;
17578     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17579     PyObject * obj0 = 0 ;
17580     char *kwnames[] = {
17581         (char *) "self", NULL
17582     };
17583
17584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIChildFrame_Activate",kwnames,&obj0)) goto fail;
17585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17586     if (SWIG_arg_fail(1)) SWIG_fail;
17587     {
17588         PyThreadState* __tstate = wxPyBeginAllowThreads();
17589         (arg1)->Activate();
17590
17591         wxPyEndAllowThreads(__tstate);
17592         if (PyErr_Occurred()) SWIG_fail;
17593     }
17594     Py_INCREF(Py_None); resultobj = Py_None;
17595     return resultobj;
17596     fail:
17597     return NULL;
17598 }
17599
17600
17601 static PyObject *_wrap_MDIChildFrame_Maximize(PyObject *, PyObject *args, PyObject *kwargs) {
17602     PyObject *resultobj;
17603     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17604     bool arg2 = (bool) true ;
17605     PyObject * obj0 = 0 ;
17606     PyObject * obj1 = 0 ;
17607     char *kwnames[] = {
17608         (char *) "self",(char *) "maximize", NULL
17609     };
17610
17611     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MDIChildFrame_Maximize",kwnames,&obj0,&obj1)) goto fail;
17612     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17613     if (SWIG_arg_fail(1)) SWIG_fail;
17614     if (obj1) {
17615         {
17616             arg2 = (bool)(SWIG_As_bool(obj1));
17617             if (SWIG_arg_fail(2)) SWIG_fail;
17618         }
17619     }
17620     {
17621         PyThreadState* __tstate = wxPyBeginAllowThreads();
17622         (arg1)->Maximize(arg2);
17623
17624         wxPyEndAllowThreads(__tstate);
17625         if (PyErr_Occurred()) SWIG_fail;
17626     }
17627     Py_INCREF(Py_None); resultobj = Py_None;
17628     return resultobj;
17629     fail:
17630     return NULL;
17631 }
17632
17633
17634 static PyObject *_wrap_MDIChildFrame_Restore(PyObject *, PyObject *args, PyObject *kwargs) {
17635     PyObject *resultobj;
17636     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17637     PyObject * obj0 = 0 ;
17638     char *kwnames[] = {
17639         (char *) "self", NULL
17640     };
17641
17642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIChildFrame_Restore",kwnames,&obj0)) goto fail;
17643     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17644     if (SWIG_arg_fail(1)) SWIG_fail;
17645     {
17646         PyThreadState* __tstate = wxPyBeginAllowThreads();
17647         (arg1)->Restore();
17648
17649         wxPyEndAllowThreads(__tstate);
17650         if (PyErr_Occurred()) SWIG_fail;
17651     }
17652     Py_INCREF(Py_None); resultobj = Py_None;
17653     return resultobj;
17654     fail:
17655     return NULL;
17656 }
17657
17658
17659 static PyObject * MDIChildFrame_swigregister(PyObject *, PyObject *args) {
17660     PyObject *obj;
17661     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17662     SWIG_TypeClientData(SWIGTYPE_p_wxMDIChildFrame, obj);
17663     Py_INCREF(obj);
17664     return Py_BuildValue((char *)"");
17665 }
17666 static PyObject *_wrap_new_MDIClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17667     PyObject *resultobj;
17668     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17669     long arg2 = (long) 0 ;
17670     wxMDIClientWindow *result;
17671     PyObject * obj0 = 0 ;
17672     PyObject * obj1 = 0 ;
17673     char *kwnames[] = {
17674         (char *) "parent",(char *) "style", NULL
17675     };
17676
17677     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_MDIClientWindow",kwnames,&obj0,&obj1)) goto fail;
17678     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17679     if (SWIG_arg_fail(1)) SWIG_fail;
17680     if (obj1) {
17681         {
17682             arg2 = (long)(SWIG_As_long(obj1));
17683             if (SWIG_arg_fail(2)) SWIG_fail;
17684         }
17685     }
17686     {
17687         if (!wxPyCheckForApp()) SWIG_fail;
17688         PyThreadState* __tstate = wxPyBeginAllowThreads();
17689         result = (wxMDIClientWindow *)new wxMDIClientWindow(arg1,arg2);
17690
17691         wxPyEndAllowThreads(__tstate);
17692         if (PyErr_Occurred()) SWIG_fail;
17693     }
17694     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIClientWindow, 1);
17695     return resultobj;
17696     fail:
17697     return NULL;
17698 }
17699
17700
17701 static PyObject *_wrap_new_PreMDIClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17702     PyObject *resultobj;
17703     wxMDIClientWindow *result;
17704     char *kwnames[] = {
17705         NULL
17706     };
17707
17708     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIClientWindow",kwnames)) goto fail;
17709     {
17710         if (!wxPyCheckForApp()) SWIG_fail;
17711         PyThreadState* __tstate = wxPyBeginAllowThreads();
17712         result = (wxMDIClientWindow *)new wxMDIClientWindow();
17713
17714         wxPyEndAllowThreads(__tstate);
17715         if (PyErr_Occurred()) SWIG_fail;
17716     }
17717     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIClientWindow, 1);
17718     return resultobj;
17719     fail:
17720     return NULL;
17721 }
17722
17723
17724 static PyObject *_wrap_MDIClientWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17725     PyObject *resultobj;
17726     wxMDIClientWindow *arg1 = (wxMDIClientWindow *) 0 ;
17727     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
17728     long arg3 = (long) 0 ;
17729     bool result;
17730     PyObject * obj0 = 0 ;
17731     PyObject * obj1 = 0 ;
17732     PyObject * obj2 = 0 ;
17733     char *kwnames[] = {
17734         (char *) "self",(char *) "parent",(char *) "style", NULL
17735     };
17736
17737     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MDIClientWindow_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
17738     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIClientWindow, SWIG_POINTER_EXCEPTION | 0);
17739     if (SWIG_arg_fail(1)) SWIG_fail;
17740     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17741     if (SWIG_arg_fail(2)) SWIG_fail;
17742     if (obj2) {
17743         {
17744             arg3 = (long)(SWIG_As_long(obj2));
17745             if (SWIG_arg_fail(3)) SWIG_fail;
17746         }
17747     }
17748     {
17749         PyThreadState* __tstate = wxPyBeginAllowThreads();
17750         result = (bool)(arg1)->Create(arg2,arg3);
17751
17752         wxPyEndAllowThreads(__tstate);
17753         if (PyErr_Occurred()) SWIG_fail;
17754     }
17755     {
17756         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17757     }
17758     return resultobj;
17759     fail:
17760     return NULL;
17761 }
17762
17763
17764 static PyObject * MDIClientWindow_swigregister(PyObject *, PyObject *args) {
17765     PyObject *obj;
17766     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17767     SWIG_TypeClientData(SWIGTYPE_p_wxMDIClientWindow, obj);
17768     Py_INCREF(obj);
17769     return Py_BuildValue((char *)"");
17770 }
17771 static PyObject *_wrap_new_PyWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17772     PyObject *resultobj;
17773     wxWindow *arg1 = (wxWindow *) 0 ;
17774     int arg2 = (int) (int)-1 ;
17775     wxPoint const &arg3_defvalue = wxDefaultPosition ;
17776     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
17777     wxSize const &arg4_defvalue = wxDefaultSize ;
17778     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
17779     long arg5 = (long) 0 ;
17780     wxString const &arg6_defvalue = wxPyPanelNameStr ;
17781     wxString *arg6 = (wxString *) &arg6_defvalue ;
17782     wxPyWindow *result;
17783     wxPoint temp3 ;
17784     wxSize temp4 ;
17785     bool temp6 = false ;
17786     PyObject * obj0 = 0 ;
17787     PyObject * obj1 = 0 ;
17788     PyObject * obj2 = 0 ;
17789     PyObject * obj3 = 0 ;
17790     PyObject * obj4 = 0 ;
17791     PyObject * obj5 = 0 ;
17792     char *kwnames[] = {
17793         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17794     };
17795
17796     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17797     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17798     if (SWIG_arg_fail(1)) SWIG_fail;
17799     if (obj1) {
17800         {
17801             arg2 = (int const)(SWIG_As_int(obj1));
17802             if (SWIG_arg_fail(2)) SWIG_fail;
17803         }
17804     }
17805     if (obj2) {
17806         {
17807             arg3 = &temp3;
17808             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17809         }
17810     }
17811     if (obj3) {
17812         {
17813             arg4 = &temp4;
17814             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
17815         }
17816     }
17817     if (obj4) {
17818         {
17819             arg5 = (long)(SWIG_As_long(obj4));
17820             if (SWIG_arg_fail(5)) SWIG_fail;
17821         }
17822     }
17823     if (obj5) {
17824         {
17825             arg6 = wxString_in_helper(obj5);
17826             if (arg6 == NULL) SWIG_fail;
17827             temp6 = true;
17828         }
17829     }
17830     {
17831         if (!wxPyCheckForApp()) SWIG_fail;
17832         PyThreadState* __tstate = wxPyBeginAllowThreads();
17833         result = (wxPyWindow *)new wxPyWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
17834
17835         wxPyEndAllowThreads(__tstate);
17836         if (PyErr_Occurred()) SWIG_fail;
17837     }
17838     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyWindow, 1);
17839     {
17840         if (temp6)
17841         delete arg6;
17842     }
17843     return resultobj;
17844     fail:
17845     {
17846         if (temp6)
17847         delete arg6;
17848     }
17849     return NULL;
17850 }
17851
17852
17853 static PyObject *_wrap_new_PrePyWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17854     PyObject *resultobj;
17855     wxPyWindow *result;
17856     char *kwnames[] = {
17857         NULL
17858     };
17859
17860     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyWindow",kwnames)) goto fail;
17861     {
17862         if (!wxPyCheckForApp()) SWIG_fail;
17863         PyThreadState* __tstate = wxPyBeginAllowThreads();
17864         result = (wxPyWindow *)new wxPyWindow();
17865
17866         wxPyEndAllowThreads(__tstate);
17867         if (PyErr_Occurred()) SWIG_fail;
17868     }
17869     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyWindow, 1);
17870     return resultobj;
17871     fail:
17872     return NULL;
17873 }
17874
17875
17876 static PyObject *_wrap_PyWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
17877     PyObject *resultobj;
17878     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17879     PyObject *arg2 = (PyObject *) 0 ;
17880     PyObject *arg3 = (PyObject *) 0 ;
17881     PyObject * obj0 = 0 ;
17882     PyObject * obj1 = 0 ;
17883     PyObject * obj2 = 0 ;
17884     char *kwnames[] = {
17885         (char *) "self",(char *) "self",(char *) "_class", NULL
17886     };
17887
17888     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
17889     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17890     if (SWIG_arg_fail(1)) SWIG_fail;
17891     arg2 = obj1;
17892     arg3 = obj2;
17893     {
17894         PyThreadState* __tstate = wxPyBeginAllowThreads();
17895         (arg1)->_setCallbackInfo(arg2,arg3);
17896
17897         wxPyEndAllowThreads(__tstate);
17898         if (PyErr_Occurred()) SWIG_fail;
17899     }
17900     Py_INCREF(Py_None); resultobj = Py_None;
17901     return resultobj;
17902     fail:
17903     return NULL;
17904 }
17905
17906
17907 static PyObject *_wrap_PyWindow_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
17908     PyObject *resultobj;
17909     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17910     wxSize *arg2 = 0 ;
17911     wxSize temp2 ;
17912     PyObject * obj0 = 0 ;
17913     PyObject * obj1 = 0 ;
17914     char *kwnames[] = {
17915         (char *) "self",(char *) "size", NULL
17916     };
17917
17918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
17919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17920     if (SWIG_arg_fail(1)) SWIG_fail;
17921     {
17922         arg2 = &temp2;
17923         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17924     }
17925     {
17926         PyThreadState* __tstate = wxPyBeginAllowThreads();
17927         (arg1)->SetBestSize((wxSize const &)*arg2);
17928
17929         wxPyEndAllowThreads(__tstate);
17930         if (PyErr_Occurred()) SWIG_fail;
17931     }
17932     Py_INCREF(Py_None); resultobj = Py_None;
17933     return resultobj;
17934     fail:
17935     return NULL;
17936 }
17937
17938
17939 static PyObject *_wrap_PyWindow_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17940     PyObject *resultobj;
17941     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17942     int arg2 ;
17943     int arg3 ;
17944     int arg4 ;
17945     int arg5 ;
17946     PyObject * obj0 = 0 ;
17947     PyObject * obj1 = 0 ;
17948     PyObject * obj2 = 0 ;
17949     PyObject * obj3 = 0 ;
17950     PyObject * obj4 = 0 ;
17951     char *kwnames[] = {
17952         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
17953     };
17954
17955     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyWindow_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17956     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17957     if (SWIG_arg_fail(1)) SWIG_fail;
17958     {
17959         arg2 = (int)(SWIG_As_int(obj1));
17960         if (SWIG_arg_fail(2)) SWIG_fail;
17961     }
17962     {
17963         arg3 = (int)(SWIG_As_int(obj2));
17964         if (SWIG_arg_fail(3)) SWIG_fail;
17965     }
17966     {
17967         arg4 = (int)(SWIG_As_int(obj3));
17968         if (SWIG_arg_fail(4)) SWIG_fail;
17969     }
17970     {
17971         arg5 = (int)(SWIG_As_int(obj4));
17972         if (SWIG_arg_fail(5)) SWIG_fail;
17973     }
17974     {
17975         PyThreadState* __tstate = wxPyBeginAllowThreads();
17976         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
17977
17978         wxPyEndAllowThreads(__tstate);
17979         if (PyErr_Occurred()) SWIG_fail;
17980     }
17981     Py_INCREF(Py_None); resultobj = Py_None;
17982     return resultobj;
17983     fail:
17984     return NULL;
17985 }
17986
17987
17988 static PyObject *_wrap_PyWindow_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
17989     PyObject *resultobj;
17990     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17991     int arg2 ;
17992     int arg3 ;
17993     int arg4 ;
17994     int arg5 ;
17995     int arg6 = (int) wxSIZE_AUTO ;
17996     PyObject * obj0 = 0 ;
17997     PyObject * obj1 = 0 ;
17998     PyObject * obj2 = 0 ;
17999     PyObject * obj3 = 0 ;
18000     PyObject * obj4 = 0 ;
18001     PyObject * obj5 = 0 ;
18002     char *kwnames[] = {
18003         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
18004     };
18005
18006     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyWindow_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18007     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18008     if (SWIG_arg_fail(1)) SWIG_fail;
18009     {
18010         arg2 = (int)(SWIG_As_int(obj1));
18011         if (SWIG_arg_fail(2)) SWIG_fail;
18012     }
18013     {
18014         arg3 = (int)(SWIG_As_int(obj2));
18015         if (SWIG_arg_fail(3)) SWIG_fail;
18016     }
18017     {
18018         arg4 = (int)(SWIG_As_int(obj3));
18019         if (SWIG_arg_fail(4)) SWIG_fail;
18020     }
18021     {
18022         arg5 = (int)(SWIG_As_int(obj4));
18023         if (SWIG_arg_fail(5)) SWIG_fail;
18024     }
18025     if (obj5) {
18026         {
18027             arg6 = (int)(SWIG_As_int(obj5));
18028             if (SWIG_arg_fail(6)) SWIG_fail;
18029         }
18030     }
18031     {
18032         PyThreadState* __tstate = wxPyBeginAllowThreads();
18033         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
18034
18035         wxPyEndAllowThreads(__tstate);
18036         if (PyErr_Occurred()) SWIG_fail;
18037     }
18038     Py_INCREF(Py_None); resultobj = Py_None;
18039     return resultobj;
18040     fail:
18041     return NULL;
18042 }
18043
18044
18045 static PyObject *_wrap_PyWindow_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18046     PyObject *resultobj;
18047     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18048     int arg2 ;
18049     int arg3 ;
18050     PyObject * obj0 = 0 ;
18051     PyObject * obj1 = 0 ;
18052     PyObject * obj2 = 0 ;
18053     char *kwnames[] = {
18054         (char *) "self",(char *) "width",(char *) "height", NULL
18055     };
18056
18057     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18058     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18059     if (SWIG_arg_fail(1)) SWIG_fail;
18060     {
18061         arg2 = (int)(SWIG_As_int(obj1));
18062         if (SWIG_arg_fail(2)) SWIG_fail;
18063     }
18064     {
18065         arg3 = (int)(SWIG_As_int(obj2));
18066         if (SWIG_arg_fail(3)) SWIG_fail;
18067     }
18068     {
18069         PyThreadState* __tstate = wxPyBeginAllowThreads();
18070         (arg1)->base_DoSetClientSize(arg2,arg3);
18071
18072         wxPyEndAllowThreads(__tstate);
18073         if (PyErr_Occurred()) SWIG_fail;
18074     }
18075     Py_INCREF(Py_None); resultobj = Py_None;
18076     return resultobj;
18077     fail:
18078     return NULL;
18079 }
18080
18081
18082 static PyObject *_wrap_PyWindow_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18083     PyObject *resultobj;
18084     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18085     int arg2 ;
18086     int arg3 ;
18087     PyObject * obj0 = 0 ;
18088     PyObject * obj1 = 0 ;
18089     PyObject * obj2 = 0 ;
18090     char *kwnames[] = {
18091         (char *) "self",(char *) "x",(char *) "y", NULL
18092     };
18093
18094     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18095     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18096     if (SWIG_arg_fail(1)) SWIG_fail;
18097     {
18098         arg2 = (int)(SWIG_As_int(obj1));
18099         if (SWIG_arg_fail(2)) SWIG_fail;
18100     }
18101     {
18102         arg3 = (int)(SWIG_As_int(obj2));
18103         if (SWIG_arg_fail(3)) SWIG_fail;
18104     }
18105     {
18106         PyThreadState* __tstate = wxPyBeginAllowThreads();
18107         (arg1)->base_DoSetVirtualSize(arg2,arg3);
18108
18109         wxPyEndAllowThreads(__tstate);
18110         if (PyErr_Occurred()) SWIG_fail;
18111     }
18112     Py_INCREF(Py_None); resultobj = Py_None;
18113     return resultobj;
18114     fail:
18115     return NULL;
18116 }
18117
18118
18119 static PyObject *_wrap_PyWindow_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18120     PyObject *resultobj;
18121     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18122     int *arg2 = (int *) 0 ;
18123     int *arg3 = (int *) 0 ;
18124     int temp2 ;
18125     int res2 = 0 ;
18126     int temp3 ;
18127     int res3 = 0 ;
18128     PyObject * obj0 = 0 ;
18129     char *kwnames[] = {
18130         (char *) "self", NULL
18131     };
18132
18133     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18134     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18135     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetSize",kwnames,&obj0)) goto fail;
18136     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18137     if (SWIG_arg_fail(1)) SWIG_fail;
18138     {
18139         PyThreadState* __tstate = wxPyBeginAllowThreads();
18140         ((wxPyWindow const *)arg1)->base_DoGetSize(arg2,arg3);
18141
18142         wxPyEndAllowThreads(__tstate);
18143         if (PyErr_Occurred()) SWIG_fail;
18144     }
18145     Py_INCREF(Py_None); resultobj = Py_None;
18146     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18147     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18148     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18149     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18150     return resultobj;
18151     fail:
18152     return NULL;
18153 }
18154
18155
18156 static PyObject *_wrap_PyWindow_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18157     PyObject *resultobj;
18158     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18159     int *arg2 = (int *) 0 ;
18160     int *arg3 = (int *) 0 ;
18161     int temp2 ;
18162     int res2 = 0 ;
18163     int temp3 ;
18164     int res3 = 0 ;
18165     PyObject * obj0 = 0 ;
18166     char *kwnames[] = {
18167         (char *) "self", NULL
18168     };
18169
18170     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18171     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18172     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetClientSize",kwnames,&obj0)) goto fail;
18173     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18174     if (SWIG_arg_fail(1)) SWIG_fail;
18175     {
18176         PyThreadState* __tstate = wxPyBeginAllowThreads();
18177         ((wxPyWindow const *)arg1)->base_DoGetClientSize(arg2,arg3);
18178
18179         wxPyEndAllowThreads(__tstate);
18180         if (PyErr_Occurred()) SWIG_fail;
18181     }
18182     Py_INCREF(Py_None); resultobj = Py_None;
18183     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18184     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18185     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18186     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18187     return resultobj;
18188     fail:
18189     return NULL;
18190 }
18191
18192
18193 static PyObject *_wrap_PyWindow_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18194     PyObject *resultobj;
18195     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18196     int *arg2 = (int *) 0 ;
18197     int *arg3 = (int *) 0 ;
18198     int temp2 ;
18199     int res2 = 0 ;
18200     int temp3 ;
18201     int res3 = 0 ;
18202     PyObject * obj0 = 0 ;
18203     char *kwnames[] = {
18204         (char *) "self", NULL
18205     };
18206
18207     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18208     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18209     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetPosition",kwnames,&obj0)) goto fail;
18210     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18211     if (SWIG_arg_fail(1)) SWIG_fail;
18212     {
18213         PyThreadState* __tstate = wxPyBeginAllowThreads();
18214         ((wxPyWindow const *)arg1)->base_DoGetPosition(arg2,arg3);
18215
18216         wxPyEndAllowThreads(__tstate);
18217         if (PyErr_Occurred()) SWIG_fail;
18218     }
18219     Py_INCREF(Py_None); resultobj = Py_None;
18220     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18221     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18222     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18223     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18224     return resultobj;
18225     fail:
18226     return NULL;
18227 }
18228
18229
18230 static PyObject *_wrap_PyWindow_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18231     PyObject *resultobj;
18232     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18233     wxSize result;
18234     PyObject * obj0 = 0 ;
18235     char *kwnames[] = {
18236         (char *) "self", NULL
18237     };
18238
18239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
18240     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18241     if (SWIG_arg_fail(1)) SWIG_fail;
18242     {
18243         PyThreadState* __tstate = wxPyBeginAllowThreads();
18244         result = ((wxPyWindow const *)arg1)->base_DoGetVirtualSize();
18245
18246         wxPyEndAllowThreads(__tstate);
18247         if (PyErr_Occurred()) SWIG_fail;
18248     }
18249     {
18250         wxSize * resultptr;
18251         resultptr = new wxSize((wxSize &)(result));
18252         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18253     }
18254     return resultobj;
18255     fail:
18256     return NULL;
18257 }
18258
18259
18260 static PyObject *_wrap_PyWindow_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18261     PyObject *resultobj;
18262     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18263     wxSize result;
18264     PyObject * obj0 = 0 ;
18265     char *kwnames[] = {
18266         (char *) "self", NULL
18267     };
18268
18269     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetBestSize",kwnames,&obj0)) goto fail;
18270     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18271     if (SWIG_arg_fail(1)) SWIG_fail;
18272     {
18273         PyThreadState* __tstate = wxPyBeginAllowThreads();
18274         result = ((wxPyWindow const *)arg1)->base_DoGetBestSize();
18275
18276         wxPyEndAllowThreads(__tstate);
18277         if (PyErr_Occurred()) SWIG_fail;
18278     }
18279     {
18280         wxSize * resultptr;
18281         resultptr = new wxSize((wxSize &)(result));
18282         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18283     }
18284     return resultobj;
18285     fail:
18286     return NULL;
18287 }
18288
18289
18290 static PyObject *_wrap_PyWindow_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
18291     PyObject *resultobj;
18292     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18293     PyObject * obj0 = 0 ;
18294     char *kwnames[] = {
18295         (char *) "self", NULL
18296     };
18297
18298     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_InitDialog",kwnames,&obj0)) goto fail;
18299     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18300     if (SWIG_arg_fail(1)) SWIG_fail;
18301     {
18302         PyThreadState* __tstate = wxPyBeginAllowThreads();
18303         (arg1)->base_InitDialog();
18304
18305         wxPyEndAllowThreads(__tstate);
18306         if (PyErr_Occurred()) SWIG_fail;
18307     }
18308     Py_INCREF(Py_None); resultobj = Py_None;
18309     return resultobj;
18310     fail:
18311     return NULL;
18312 }
18313
18314
18315 static PyObject *_wrap_PyWindow_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18316     PyObject *resultobj;
18317     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18318     bool result;
18319     PyObject * obj0 = 0 ;
18320     char *kwnames[] = {
18321         (char *) "self", NULL
18322     };
18323
18324     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
18325     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18326     if (SWIG_arg_fail(1)) SWIG_fail;
18327     {
18328         PyThreadState* __tstate = wxPyBeginAllowThreads();
18329         result = (bool)(arg1)->base_TransferDataToWindow();
18330
18331         wxPyEndAllowThreads(__tstate);
18332         if (PyErr_Occurred()) SWIG_fail;
18333     }
18334     {
18335         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18336     }
18337     return resultobj;
18338     fail:
18339     return NULL;
18340 }
18341
18342
18343 static PyObject *_wrap_PyWindow_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18344     PyObject *resultobj;
18345     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18346     bool result;
18347     PyObject * obj0 = 0 ;
18348     char *kwnames[] = {
18349         (char *) "self", NULL
18350     };
18351
18352     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
18353     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18354     if (SWIG_arg_fail(1)) SWIG_fail;
18355     {
18356         PyThreadState* __tstate = wxPyBeginAllowThreads();
18357         result = (bool)(arg1)->base_TransferDataFromWindow();
18358
18359         wxPyEndAllowThreads(__tstate);
18360         if (PyErr_Occurred()) SWIG_fail;
18361     }
18362     {
18363         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18364     }
18365     return resultobj;
18366     fail:
18367     return NULL;
18368 }
18369
18370
18371 static PyObject *_wrap_PyWindow_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
18372     PyObject *resultobj;
18373     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18374     bool result;
18375     PyObject * obj0 = 0 ;
18376     char *kwnames[] = {
18377         (char *) "self", NULL
18378     };
18379
18380     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_Validate",kwnames,&obj0)) goto fail;
18381     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18382     if (SWIG_arg_fail(1)) SWIG_fail;
18383     {
18384         PyThreadState* __tstate = wxPyBeginAllowThreads();
18385         result = (bool)(arg1)->base_Validate();
18386
18387         wxPyEndAllowThreads(__tstate);
18388         if (PyErr_Occurred()) SWIG_fail;
18389     }
18390     {
18391         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18392     }
18393     return resultobj;
18394     fail:
18395     return NULL;
18396 }
18397
18398
18399 static PyObject *_wrap_PyWindow_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
18400     PyObject *resultobj;
18401     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18402     bool result;
18403     PyObject * obj0 = 0 ;
18404     char *kwnames[] = {
18405         (char *) "self", NULL
18406     };
18407
18408     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_AcceptsFocus",kwnames,&obj0)) goto fail;
18409     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18410     if (SWIG_arg_fail(1)) SWIG_fail;
18411     {
18412         PyThreadState* __tstate = wxPyBeginAllowThreads();
18413         result = (bool)((wxPyWindow const *)arg1)->base_AcceptsFocus();
18414
18415         wxPyEndAllowThreads(__tstate);
18416         if (PyErr_Occurred()) SWIG_fail;
18417     }
18418     {
18419         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18420     }
18421     return resultobj;
18422     fail:
18423     return NULL;
18424 }
18425
18426
18427 static PyObject *_wrap_PyWindow_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
18428     PyObject *resultobj;
18429     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18430     bool result;
18431     PyObject * obj0 = 0 ;
18432     char *kwnames[] = {
18433         (char *) "self", NULL
18434     };
18435
18436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
18437     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18438     if (SWIG_arg_fail(1)) SWIG_fail;
18439     {
18440         PyThreadState* __tstate = wxPyBeginAllowThreads();
18441         result = (bool)((wxPyWindow const *)arg1)->base_AcceptsFocusFromKeyboard();
18442
18443         wxPyEndAllowThreads(__tstate);
18444         if (PyErr_Occurred()) SWIG_fail;
18445     }
18446     {
18447         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18448     }
18449     return resultobj;
18450     fail:
18451     return NULL;
18452 }
18453
18454
18455 static PyObject *_wrap_PyWindow_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
18456     PyObject *resultobj;
18457     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18458     wxSize result;
18459     PyObject * obj0 = 0 ;
18460     char *kwnames[] = {
18461         (char *) "self", NULL
18462     };
18463
18464     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_GetMaxSize",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 = ((wxPyWindow const *)arg1)->base_GetMaxSize();
18470
18471         wxPyEndAllowThreads(__tstate);
18472         if (PyErr_Occurred()) SWIG_fail;
18473     }
18474     {
18475         wxSize * resultptr;
18476         resultptr = new wxSize((wxSize &)(result));
18477         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18478     }
18479     return resultobj;
18480     fail:
18481     return NULL;
18482 }
18483
18484
18485 static PyObject *_wrap_PyWindow_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
18486     PyObject *resultobj;
18487     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18488     wxWindow *arg2 = (wxWindow *) 0 ;
18489     PyObject * obj0 = 0 ;
18490     PyObject * obj1 = 0 ;
18491     char *kwnames[] = {
18492         (char *) "self",(char *) "child", NULL
18493     };
18494
18495     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
18496     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18497     if (SWIG_arg_fail(1)) SWIG_fail;
18498     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18499     if (SWIG_arg_fail(2)) SWIG_fail;
18500     {
18501         PyThreadState* __tstate = wxPyBeginAllowThreads();
18502         (arg1)->base_AddChild(arg2);
18503
18504         wxPyEndAllowThreads(__tstate);
18505         if (PyErr_Occurred()) SWIG_fail;
18506     }
18507     Py_INCREF(Py_None); resultobj = Py_None;
18508     return resultobj;
18509     fail:
18510     return NULL;
18511 }
18512
18513
18514 static PyObject *_wrap_PyWindow_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
18515     PyObject *resultobj;
18516     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18517     wxWindow *arg2 = (wxWindow *) 0 ;
18518     PyObject * obj0 = 0 ;
18519     PyObject * obj1 = 0 ;
18520     char *kwnames[] = {
18521         (char *) "self",(char *) "child", NULL
18522     };
18523
18524     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
18525     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18526     if (SWIG_arg_fail(1)) SWIG_fail;
18527     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18528     if (SWIG_arg_fail(2)) SWIG_fail;
18529     {
18530         PyThreadState* __tstate = wxPyBeginAllowThreads();
18531         (arg1)->base_RemoveChild(arg2);
18532
18533         wxPyEndAllowThreads(__tstate);
18534         if (PyErr_Occurred()) SWIG_fail;
18535     }
18536     Py_INCREF(Py_None); resultobj = Py_None;
18537     return resultobj;
18538     fail:
18539     return NULL;
18540 }
18541
18542
18543 static PyObject *_wrap_PyWindow_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
18544     PyObject *resultobj;
18545     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18546     bool result;
18547     PyObject * obj0 = 0 ;
18548     char *kwnames[] = {
18549         (char *) "self", NULL
18550     };
18551
18552     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
18553     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18554     if (SWIG_arg_fail(1)) SWIG_fail;
18555     {
18556         PyThreadState* __tstate = wxPyBeginAllowThreads();
18557         result = (bool)((wxPyWindow const *)arg1)->base_ShouldInheritColours();
18558
18559         wxPyEndAllowThreads(__tstate);
18560         if (PyErr_Occurred()) SWIG_fail;
18561     }
18562     {
18563         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18564     }
18565     return resultobj;
18566     fail:
18567     return NULL;
18568 }
18569
18570
18571 static PyObject *_wrap_PyWindow_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
18572     PyObject *resultobj;
18573     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18574     wxColour *arg2 = 0 ;
18575     wxColour temp2 ;
18576     PyObject * obj0 = 0 ;
18577     PyObject * obj1 = 0 ;
18578     char *kwnames[] = {
18579         (char *) "self",(char *) "c", NULL
18580     };
18581
18582     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
18583     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18584     if (SWIG_arg_fail(1)) SWIG_fail;
18585     {
18586         arg2 = &temp2;
18587         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18588     }
18589     {
18590         PyThreadState* __tstate = wxPyBeginAllowThreads();
18591         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
18592
18593         wxPyEndAllowThreads(__tstate);
18594         if (PyErr_Occurred()) SWIG_fail;
18595     }
18596     Py_INCREF(Py_None); resultobj = Py_None;
18597     return resultobj;
18598     fail:
18599     return NULL;
18600 }
18601
18602
18603 static PyObject *_wrap_PyWindow_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
18604     PyObject *resultobj;
18605     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18606     wxVisualAttributes result;
18607     PyObject * obj0 = 0 ;
18608     char *kwnames[] = {
18609         (char *) "self", NULL
18610     };
18611
18612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
18613     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18614     if (SWIG_arg_fail(1)) SWIG_fail;
18615     {
18616         PyThreadState* __tstate = wxPyBeginAllowThreads();
18617         result = (arg1)->base_GetDefaultAttributes();
18618
18619         wxPyEndAllowThreads(__tstate);
18620         if (PyErr_Occurred()) SWIG_fail;
18621     }
18622     {
18623         wxVisualAttributes * resultptr;
18624         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
18625         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
18626     }
18627     return resultobj;
18628     fail:
18629     return NULL;
18630 }
18631
18632
18633 static PyObject * PyWindow_swigregister(PyObject *, PyObject *args) {
18634     PyObject *obj;
18635     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18636     SWIG_TypeClientData(SWIGTYPE_p_wxPyWindow, obj);
18637     Py_INCREF(obj);
18638     return Py_BuildValue((char *)"");
18639 }
18640 static PyObject *_wrap_new_PyPanel(PyObject *, PyObject *args, PyObject *kwargs) {
18641     PyObject *resultobj;
18642     wxWindow *arg1 = (wxWindow *) 0 ;
18643     int arg2 = (int) (int)-1 ;
18644     wxPoint const &arg3_defvalue = wxDefaultPosition ;
18645     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
18646     wxSize const &arg4_defvalue = wxDefaultSize ;
18647     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
18648     long arg5 = (long) 0 ;
18649     wxString const &arg6_defvalue = wxPyPanelNameStr ;
18650     wxString *arg6 = (wxString *) &arg6_defvalue ;
18651     wxPyPanel *result;
18652     wxPoint temp3 ;
18653     wxSize temp4 ;
18654     bool temp6 = false ;
18655     PyObject * obj0 = 0 ;
18656     PyObject * obj1 = 0 ;
18657     PyObject * obj2 = 0 ;
18658     PyObject * obj3 = 0 ;
18659     PyObject * obj4 = 0 ;
18660     PyObject * obj5 = 0 ;
18661     char *kwnames[] = {
18662         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
18663     };
18664
18665     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyPanel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18666     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18667     if (SWIG_arg_fail(1)) SWIG_fail;
18668     if (obj1) {
18669         {
18670             arg2 = (int const)(SWIG_As_int(obj1));
18671             if (SWIG_arg_fail(2)) SWIG_fail;
18672         }
18673     }
18674     if (obj2) {
18675         {
18676             arg3 = &temp3;
18677             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18678         }
18679     }
18680     if (obj3) {
18681         {
18682             arg4 = &temp4;
18683             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
18684         }
18685     }
18686     if (obj4) {
18687         {
18688             arg5 = (long)(SWIG_As_long(obj4));
18689             if (SWIG_arg_fail(5)) SWIG_fail;
18690         }
18691     }
18692     if (obj5) {
18693         {
18694             arg6 = wxString_in_helper(obj5);
18695             if (arg6 == NULL) SWIG_fail;
18696             temp6 = true;
18697         }
18698     }
18699     {
18700         if (!wxPyCheckForApp()) SWIG_fail;
18701         PyThreadState* __tstate = wxPyBeginAllowThreads();
18702         result = (wxPyPanel *)new wxPyPanel(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
18703
18704         wxPyEndAllowThreads(__tstate);
18705         if (PyErr_Occurred()) SWIG_fail;
18706     }
18707     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPanel, 1);
18708     {
18709         if (temp6)
18710         delete arg6;
18711     }
18712     return resultobj;
18713     fail:
18714     {
18715         if (temp6)
18716         delete arg6;
18717     }
18718     return NULL;
18719 }
18720
18721
18722 static PyObject *_wrap_new_PrePyPanel(PyObject *, PyObject *args, PyObject *kwargs) {
18723     PyObject *resultobj;
18724     wxPyPanel *result;
18725     char *kwnames[] = {
18726         NULL
18727     };
18728
18729     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyPanel",kwnames)) goto fail;
18730     {
18731         if (!wxPyCheckForApp()) SWIG_fail;
18732         PyThreadState* __tstate = wxPyBeginAllowThreads();
18733         result = (wxPyPanel *)new wxPyPanel();
18734
18735         wxPyEndAllowThreads(__tstate);
18736         if (PyErr_Occurred()) SWIG_fail;
18737     }
18738     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPanel, 1);
18739     return resultobj;
18740     fail:
18741     return NULL;
18742 }
18743
18744
18745 static PyObject *_wrap_PyPanel__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
18746     PyObject *resultobj;
18747     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18748     PyObject *arg2 = (PyObject *) 0 ;
18749     PyObject *arg3 = (PyObject *) 0 ;
18750     PyObject * obj0 = 0 ;
18751     PyObject * obj1 = 0 ;
18752     PyObject * obj2 = 0 ;
18753     char *kwnames[] = {
18754         (char *) "self",(char *) "self",(char *) "_class", NULL
18755     };
18756
18757     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
18758     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18759     if (SWIG_arg_fail(1)) SWIG_fail;
18760     arg2 = obj1;
18761     arg3 = obj2;
18762     {
18763         PyThreadState* __tstate = wxPyBeginAllowThreads();
18764         (arg1)->_setCallbackInfo(arg2,arg3);
18765
18766         wxPyEndAllowThreads(__tstate);
18767         if (PyErr_Occurred()) SWIG_fail;
18768     }
18769     Py_INCREF(Py_None); resultobj = Py_None;
18770     return resultobj;
18771     fail:
18772     return NULL;
18773 }
18774
18775
18776 static PyObject *_wrap_PyPanel_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18777     PyObject *resultobj;
18778     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18779     wxSize *arg2 = 0 ;
18780     wxSize temp2 ;
18781     PyObject * obj0 = 0 ;
18782     PyObject * obj1 = 0 ;
18783     char *kwnames[] = {
18784         (char *) "self",(char *) "size", NULL
18785     };
18786
18787     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
18788     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18789     if (SWIG_arg_fail(1)) SWIG_fail;
18790     {
18791         arg2 = &temp2;
18792         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18793     }
18794     {
18795         PyThreadState* __tstate = wxPyBeginAllowThreads();
18796         (arg1)->SetBestSize((wxSize const &)*arg2);
18797
18798         wxPyEndAllowThreads(__tstate);
18799         if (PyErr_Occurred()) SWIG_fail;
18800     }
18801     Py_INCREF(Py_None); resultobj = Py_None;
18802     return resultobj;
18803     fail:
18804     return NULL;
18805 }
18806
18807
18808 static PyObject *_wrap_PyPanel_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18809     PyObject *resultobj;
18810     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18811     int arg2 ;
18812     int arg3 ;
18813     int arg4 ;
18814     int arg5 ;
18815     PyObject * obj0 = 0 ;
18816     PyObject * obj1 = 0 ;
18817     PyObject * obj2 = 0 ;
18818     PyObject * obj3 = 0 ;
18819     PyObject * obj4 = 0 ;
18820     char *kwnames[] = {
18821         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18822     };
18823
18824     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyPanel_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18825     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18826     if (SWIG_arg_fail(1)) SWIG_fail;
18827     {
18828         arg2 = (int)(SWIG_As_int(obj1));
18829         if (SWIG_arg_fail(2)) SWIG_fail;
18830     }
18831     {
18832         arg3 = (int)(SWIG_As_int(obj2));
18833         if (SWIG_arg_fail(3)) SWIG_fail;
18834     }
18835     {
18836         arg4 = (int)(SWIG_As_int(obj3));
18837         if (SWIG_arg_fail(4)) SWIG_fail;
18838     }
18839     {
18840         arg5 = (int)(SWIG_As_int(obj4));
18841         if (SWIG_arg_fail(5)) SWIG_fail;
18842     }
18843     {
18844         PyThreadState* __tstate = wxPyBeginAllowThreads();
18845         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
18846
18847         wxPyEndAllowThreads(__tstate);
18848         if (PyErr_Occurred()) SWIG_fail;
18849     }
18850     Py_INCREF(Py_None); resultobj = Py_None;
18851     return resultobj;
18852     fail:
18853     return NULL;
18854 }
18855
18856
18857 static PyObject *_wrap_PyPanel_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18858     PyObject *resultobj;
18859     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18860     int arg2 ;
18861     int arg3 ;
18862     int arg4 ;
18863     int arg5 ;
18864     int arg6 = (int) wxSIZE_AUTO ;
18865     PyObject * obj0 = 0 ;
18866     PyObject * obj1 = 0 ;
18867     PyObject * obj2 = 0 ;
18868     PyObject * obj3 = 0 ;
18869     PyObject * obj4 = 0 ;
18870     PyObject * obj5 = 0 ;
18871     char *kwnames[] = {
18872         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
18873     };
18874
18875     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyPanel_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18876     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18877     if (SWIG_arg_fail(1)) SWIG_fail;
18878     {
18879         arg2 = (int)(SWIG_As_int(obj1));
18880         if (SWIG_arg_fail(2)) SWIG_fail;
18881     }
18882     {
18883         arg3 = (int)(SWIG_As_int(obj2));
18884         if (SWIG_arg_fail(3)) SWIG_fail;
18885     }
18886     {
18887         arg4 = (int)(SWIG_As_int(obj3));
18888         if (SWIG_arg_fail(4)) SWIG_fail;
18889     }
18890     {
18891         arg5 = (int)(SWIG_As_int(obj4));
18892         if (SWIG_arg_fail(5)) SWIG_fail;
18893     }
18894     if (obj5) {
18895         {
18896             arg6 = (int)(SWIG_As_int(obj5));
18897             if (SWIG_arg_fail(6)) SWIG_fail;
18898         }
18899     }
18900     {
18901         PyThreadState* __tstate = wxPyBeginAllowThreads();
18902         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
18903
18904         wxPyEndAllowThreads(__tstate);
18905         if (PyErr_Occurred()) SWIG_fail;
18906     }
18907     Py_INCREF(Py_None); resultobj = Py_None;
18908     return resultobj;
18909     fail:
18910     return NULL;
18911 }
18912
18913
18914 static PyObject *_wrap_PyPanel_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18915     PyObject *resultobj;
18916     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18917     int arg2 ;
18918     int arg3 ;
18919     PyObject * obj0 = 0 ;
18920     PyObject * obj1 = 0 ;
18921     PyObject * obj2 = 0 ;
18922     char *kwnames[] = {
18923         (char *) "self",(char *) "width",(char *) "height", NULL
18924     };
18925
18926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18927     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18928     if (SWIG_arg_fail(1)) SWIG_fail;
18929     {
18930         arg2 = (int)(SWIG_As_int(obj1));
18931         if (SWIG_arg_fail(2)) SWIG_fail;
18932     }
18933     {
18934         arg3 = (int)(SWIG_As_int(obj2));
18935         if (SWIG_arg_fail(3)) SWIG_fail;
18936     }
18937     {
18938         PyThreadState* __tstate = wxPyBeginAllowThreads();
18939         (arg1)->base_DoSetClientSize(arg2,arg3);
18940
18941         wxPyEndAllowThreads(__tstate);
18942         if (PyErr_Occurred()) SWIG_fail;
18943     }
18944     Py_INCREF(Py_None); resultobj = Py_None;
18945     return resultobj;
18946     fail:
18947     return NULL;
18948 }
18949
18950
18951 static PyObject *_wrap_PyPanel_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18952     PyObject *resultobj;
18953     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18954     int arg2 ;
18955     int arg3 ;
18956     PyObject * obj0 = 0 ;
18957     PyObject * obj1 = 0 ;
18958     PyObject * obj2 = 0 ;
18959     char *kwnames[] = {
18960         (char *) "self",(char *) "x",(char *) "y", NULL
18961     };
18962
18963     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18964     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18965     if (SWIG_arg_fail(1)) SWIG_fail;
18966     {
18967         arg2 = (int)(SWIG_As_int(obj1));
18968         if (SWIG_arg_fail(2)) SWIG_fail;
18969     }
18970     {
18971         arg3 = (int)(SWIG_As_int(obj2));
18972         if (SWIG_arg_fail(3)) SWIG_fail;
18973     }
18974     {
18975         PyThreadState* __tstate = wxPyBeginAllowThreads();
18976         (arg1)->base_DoSetVirtualSize(arg2,arg3);
18977
18978         wxPyEndAllowThreads(__tstate);
18979         if (PyErr_Occurred()) SWIG_fail;
18980     }
18981     Py_INCREF(Py_None); resultobj = Py_None;
18982     return resultobj;
18983     fail:
18984     return NULL;
18985 }
18986
18987
18988 static PyObject *_wrap_PyPanel_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18989     PyObject *resultobj;
18990     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18991     int *arg2 = (int *) 0 ;
18992     int *arg3 = (int *) 0 ;
18993     int temp2 ;
18994     int res2 = 0 ;
18995     int temp3 ;
18996     int res3 = 0 ;
18997     PyObject * obj0 = 0 ;
18998     char *kwnames[] = {
18999         (char *) "self", NULL
19000     };
19001
19002     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19003     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19004     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetSize",kwnames,&obj0)) goto fail;
19005     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19006     if (SWIG_arg_fail(1)) SWIG_fail;
19007     {
19008         PyThreadState* __tstate = wxPyBeginAllowThreads();
19009         ((wxPyPanel const *)arg1)->base_DoGetSize(arg2,arg3);
19010
19011         wxPyEndAllowThreads(__tstate);
19012         if (PyErr_Occurred()) SWIG_fail;
19013     }
19014     Py_INCREF(Py_None); resultobj = Py_None;
19015     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19016     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19017     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19018     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19019     return resultobj;
19020     fail:
19021     return NULL;
19022 }
19023
19024
19025 static PyObject *_wrap_PyPanel_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19026     PyObject *resultobj;
19027     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19028     int *arg2 = (int *) 0 ;
19029     int *arg3 = (int *) 0 ;
19030     int temp2 ;
19031     int res2 = 0 ;
19032     int temp3 ;
19033     int res3 = 0 ;
19034     PyObject * obj0 = 0 ;
19035     char *kwnames[] = {
19036         (char *) "self", NULL
19037     };
19038
19039     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19040     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19041     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetClientSize",kwnames,&obj0)) goto fail;
19042     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19043     if (SWIG_arg_fail(1)) SWIG_fail;
19044     {
19045         PyThreadState* __tstate = wxPyBeginAllowThreads();
19046         ((wxPyPanel const *)arg1)->base_DoGetClientSize(arg2,arg3);
19047
19048         wxPyEndAllowThreads(__tstate);
19049         if (PyErr_Occurred()) SWIG_fail;
19050     }
19051     Py_INCREF(Py_None); resultobj = Py_None;
19052     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19053     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19054     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19055     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19056     return resultobj;
19057     fail:
19058     return NULL;
19059 }
19060
19061
19062 static PyObject *_wrap_PyPanel_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19063     PyObject *resultobj;
19064     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19065     int *arg2 = (int *) 0 ;
19066     int *arg3 = (int *) 0 ;
19067     int temp2 ;
19068     int res2 = 0 ;
19069     int temp3 ;
19070     int res3 = 0 ;
19071     PyObject * obj0 = 0 ;
19072     char *kwnames[] = {
19073         (char *) "self", NULL
19074     };
19075
19076     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19077     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19078     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetPosition",kwnames,&obj0)) goto fail;
19079     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19080     if (SWIG_arg_fail(1)) SWIG_fail;
19081     {
19082         PyThreadState* __tstate = wxPyBeginAllowThreads();
19083         ((wxPyPanel const *)arg1)->base_DoGetPosition(arg2,arg3);
19084
19085         wxPyEndAllowThreads(__tstate);
19086         if (PyErr_Occurred()) SWIG_fail;
19087     }
19088     Py_INCREF(Py_None); resultobj = Py_None;
19089     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19090     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19091     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19092     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19093     return resultobj;
19094     fail:
19095     return NULL;
19096 }
19097
19098
19099 static PyObject *_wrap_PyPanel_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19100     PyObject *resultobj;
19101     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19102     wxSize result;
19103     PyObject * obj0 = 0 ;
19104     char *kwnames[] = {
19105         (char *) "self", NULL
19106     };
19107
19108     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
19109     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19110     if (SWIG_arg_fail(1)) SWIG_fail;
19111     {
19112         PyThreadState* __tstate = wxPyBeginAllowThreads();
19113         result = ((wxPyPanel const *)arg1)->base_DoGetVirtualSize();
19114
19115         wxPyEndAllowThreads(__tstate);
19116         if (PyErr_Occurred()) SWIG_fail;
19117     }
19118     {
19119         wxSize * resultptr;
19120         resultptr = new wxSize((wxSize &)(result));
19121         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19122     }
19123     return resultobj;
19124     fail:
19125     return NULL;
19126 }
19127
19128
19129 static PyObject *_wrap_PyPanel_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19130     PyObject *resultobj;
19131     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19132     wxSize result;
19133     PyObject * obj0 = 0 ;
19134     char *kwnames[] = {
19135         (char *) "self", NULL
19136     };
19137
19138     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetBestSize",kwnames,&obj0)) goto fail;
19139     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19140     if (SWIG_arg_fail(1)) SWIG_fail;
19141     {
19142         PyThreadState* __tstate = wxPyBeginAllowThreads();
19143         result = ((wxPyPanel const *)arg1)->base_DoGetBestSize();
19144
19145         wxPyEndAllowThreads(__tstate);
19146         if (PyErr_Occurred()) SWIG_fail;
19147     }
19148     {
19149         wxSize * resultptr;
19150         resultptr = new wxSize((wxSize &)(result));
19151         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19152     }
19153     return resultobj;
19154     fail:
19155     return NULL;
19156 }
19157
19158
19159 static PyObject *_wrap_PyPanel_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
19160     PyObject *resultobj;
19161     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19162     PyObject * obj0 = 0 ;
19163     char *kwnames[] = {
19164         (char *) "self", NULL
19165     };
19166
19167     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_InitDialog",kwnames,&obj0)) goto fail;
19168     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19169     if (SWIG_arg_fail(1)) SWIG_fail;
19170     {
19171         PyThreadState* __tstate = wxPyBeginAllowThreads();
19172         (arg1)->base_InitDialog();
19173
19174         wxPyEndAllowThreads(__tstate);
19175         if (PyErr_Occurred()) SWIG_fail;
19176     }
19177     Py_INCREF(Py_None); resultobj = Py_None;
19178     return resultobj;
19179     fail:
19180     return NULL;
19181 }
19182
19183
19184 static PyObject *_wrap_PyPanel_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19185     PyObject *resultobj;
19186     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19187     bool result;
19188     PyObject * obj0 = 0 ;
19189     char *kwnames[] = {
19190         (char *) "self", NULL
19191     };
19192
19193     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
19194     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19195     if (SWIG_arg_fail(1)) SWIG_fail;
19196     {
19197         PyThreadState* __tstate = wxPyBeginAllowThreads();
19198         result = (bool)(arg1)->base_TransferDataToWindow();
19199
19200         wxPyEndAllowThreads(__tstate);
19201         if (PyErr_Occurred()) SWIG_fail;
19202     }
19203     {
19204         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19205     }
19206     return resultobj;
19207     fail:
19208     return NULL;
19209 }
19210
19211
19212 static PyObject *_wrap_PyPanel_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19213     PyObject *resultobj;
19214     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19215     bool result;
19216     PyObject * obj0 = 0 ;
19217     char *kwnames[] = {
19218         (char *) "self", NULL
19219     };
19220
19221     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
19222     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19223     if (SWIG_arg_fail(1)) SWIG_fail;
19224     {
19225         PyThreadState* __tstate = wxPyBeginAllowThreads();
19226         result = (bool)(arg1)->base_TransferDataFromWindow();
19227
19228         wxPyEndAllowThreads(__tstate);
19229         if (PyErr_Occurred()) SWIG_fail;
19230     }
19231     {
19232         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19233     }
19234     return resultobj;
19235     fail:
19236     return NULL;
19237 }
19238
19239
19240 static PyObject *_wrap_PyPanel_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
19241     PyObject *resultobj;
19242     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19243     bool result;
19244     PyObject * obj0 = 0 ;
19245     char *kwnames[] = {
19246         (char *) "self", NULL
19247     };
19248
19249     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_Validate",kwnames,&obj0)) goto fail;
19250     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19251     if (SWIG_arg_fail(1)) SWIG_fail;
19252     {
19253         PyThreadState* __tstate = wxPyBeginAllowThreads();
19254         result = (bool)(arg1)->base_Validate();
19255
19256         wxPyEndAllowThreads(__tstate);
19257         if (PyErr_Occurred()) SWIG_fail;
19258     }
19259     {
19260         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19261     }
19262     return resultobj;
19263     fail:
19264     return NULL;
19265 }
19266
19267
19268 static PyObject *_wrap_PyPanel_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
19269     PyObject *resultobj;
19270     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19271     bool result;
19272     PyObject * obj0 = 0 ;
19273     char *kwnames[] = {
19274         (char *) "self", NULL
19275     };
19276
19277     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_AcceptsFocus",kwnames,&obj0)) goto fail;
19278     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19279     if (SWIG_arg_fail(1)) SWIG_fail;
19280     {
19281         PyThreadState* __tstate = wxPyBeginAllowThreads();
19282         result = (bool)((wxPyPanel const *)arg1)->base_AcceptsFocus();
19283
19284         wxPyEndAllowThreads(__tstate);
19285         if (PyErr_Occurred()) SWIG_fail;
19286     }
19287     {
19288         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19289     }
19290     return resultobj;
19291     fail:
19292     return NULL;
19293 }
19294
19295
19296 static PyObject *_wrap_PyPanel_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
19297     PyObject *resultobj;
19298     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19299     bool result;
19300     PyObject * obj0 = 0 ;
19301     char *kwnames[] = {
19302         (char *) "self", NULL
19303     };
19304
19305     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
19306     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19307     if (SWIG_arg_fail(1)) SWIG_fail;
19308     {
19309         PyThreadState* __tstate = wxPyBeginAllowThreads();
19310         result = (bool)((wxPyPanel const *)arg1)->base_AcceptsFocusFromKeyboard();
19311
19312         wxPyEndAllowThreads(__tstate);
19313         if (PyErr_Occurred()) SWIG_fail;
19314     }
19315     {
19316         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19317     }
19318     return resultobj;
19319     fail:
19320     return NULL;
19321 }
19322
19323
19324 static PyObject *_wrap_PyPanel_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
19325     PyObject *resultobj;
19326     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19327     wxSize result;
19328     PyObject * obj0 = 0 ;
19329     char *kwnames[] = {
19330         (char *) "self", NULL
19331     };
19332
19333     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_GetMaxSize",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 = ((wxPyPanel const *)arg1)->base_GetMaxSize();
19339
19340         wxPyEndAllowThreads(__tstate);
19341         if (PyErr_Occurred()) SWIG_fail;
19342     }
19343     {
19344         wxSize * resultptr;
19345         resultptr = new wxSize((wxSize &)(result));
19346         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19347     }
19348     return resultobj;
19349     fail:
19350     return NULL;
19351 }
19352
19353
19354 static PyObject *_wrap_PyPanel_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
19355     PyObject *resultobj;
19356     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19357     wxWindow *arg2 = (wxWindow *) 0 ;
19358     PyObject * obj0 = 0 ;
19359     PyObject * obj1 = 0 ;
19360     char *kwnames[] = {
19361         (char *) "self",(char *) "child", NULL
19362     };
19363
19364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
19365     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19366     if (SWIG_arg_fail(1)) SWIG_fail;
19367     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19368     if (SWIG_arg_fail(2)) SWIG_fail;
19369     {
19370         PyThreadState* __tstate = wxPyBeginAllowThreads();
19371         (arg1)->base_AddChild(arg2);
19372
19373         wxPyEndAllowThreads(__tstate);
19374         if (PyErr_Occurred()) SWIG_fail;
19375     }
19376     Py_INCREF(Py_None); resultobj = Py_None;
19377     return resultobj;
19378     fail:
19379     return NULL;
19380 }
19381
19382
19383 static PyObject *_wrap_PyPanel_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
19384     PyObject *resultobj;
19385     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19386     wxWindow *arg2 = (wxWindow *) 0 ;
19387     PyObject * obj0 = 0 ;
19388     PyObject * obj1 = 0 ;
19389     char *kwnames[] = {
19390         (char *) "self",(char *) "child", NULL
19391     };
19392
19393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
19394     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19395     if (SWIG_arg_fail(1)) SWIG_fail;
19396     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19397     if (SWIG_arg_fail(2)) SWIG_fail;
19398     {
19399         PyThreadState* __tstate = wxPyBeginAllowThreads();
19400         (arg1)->base_RemoveChild(arg2);
19401
19402         wxPyEndAllowThreads(__tstate);
19403         if (PyErr_Occurred()) SWIG_fail;
19404     }
19405     Py_INCREF(Py_None); resultobj = Py_None;
19406     return resultobj;
19407     fail:
19408     return NULL;
19409 }
19410
19411
19412 static PyObject *_wrap_PyPanel_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
19413     PyObject *resultobj;
19414     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19415     bool result;
19416     PyObject * obj0 = 0 ;
19417     char *kwnames[] = {
19418         (char *) "self", NULL
19419     };
19420
19421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
19422     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19423     if (SWIG_arg_fail(1)) SWIG_fail;
19424     {
19425         PyThreadState* __tstate = wxPyBeginAllowThreads();
19426         result = (bool)((wxPyPanel const *)arg1)->base_ShouldInheritColours();
19427
19428         wxPyEndAllowThreads(__tstate);
19429         if (PyErr_Occurred()) SWIG_fail;
19430     }
19431     {
19432         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19433     }
19434     return resultobj;
19435     fail:
19436     return NULL;
19437 }
19438
19439
19440 static PyObject *_wrap_PyPanel_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
19441     PyObject *resultobj;
19442     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19443     wxColour *arg2 = 0 ;
19444     wxColour temp2 ;
19445     PyObject * obj0 = 0 ;
19446     PyObject * obj1 = 0 ;
19447     char *kwnames[] = {
19448         (char *) "self",(char *) "c", NULL
19449     };
19450
19451     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
19452     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19453     if (SWIG_arg_fail(1)) SWIG_fail;
19454     {
19455         arg2 = &temp2;
19456         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19457     }
19458     {
19459         PyThreadState* __tstate = wxPyBeginAllowThreads();
19460         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
19461
19462         wxPyEndAllowThreads(__tstate);
19463         if (PyErr_Occurred()) SWIG_fail;
19464     }
19465     Py_INCREF(Py_None); resultobj = Py_None;
19466     return resultobj;
19467     fail:
19468     return NULL;
19469 }
19470
19471
19472 static PyObject *_wrap_PyPanel_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
19473     PyObject *resultobj;
19474     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19475     wxVisualAttributes result;
19476     PyObject * obj0 = 0 ;
19477     char *kwnames[] = {
19478         (char *) "self", NULL
19479     };
19480
19481     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
19482     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19483     if (SWIG_arg_fail(1)) SWIG_fail;
19484     {
19485         PyThreadState* __tstate = wxPyBeginAllowThreads();
19486         result = (arg1)->base_GetDefaultAttributes();
19487
19488         wxPyEndAllowThreads(__tstate);
19489         if (PyErr_Occurred()) SWIG_fail;
19490     }
19491     {
19492         wxVisualAttributes * resultptr;
19493         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
19494         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
19495     }
19496     return resultobj;
19497     fail:
19498     return NULL;
19499 }
19500
19501
19502 static PyObject * PyPanel_swigregister(PyObject *, PyObject *args) {
19503     PyObject *obj;
19504     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19505     SWIG_TypeClientData(SWIGTYPE_p_wxPyPanel, obj);
19506     Py_INCREF(obj);
19507     return Py_BuildValue((char *)"");
19508 }
19509 static PyObject *_wrap_new_PyScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19510     PyObject *resultobj;
19511     wxWindow *arg1 = (wxWindow *) 0 ;
19512     int arg2 = (int) (int)-1 ;
19513     wxPoint const &arg3_defvalue = wxDefaultPosition ;
19514     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
19515     wxSize const &arg4_defvalue = wxDefaultSize ;
19516     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
19517     long arg5 = (long) 0 ;
19518     wxString const &arg6_defvalue = wxPyPanelNameStr ;
19519     wxString *arg6 = (wxString *) &arg6_defvalue ;
19520     wxPyScrolledWindow *result;
19521     wxPoint temp3 ;
19522     wxSize temp4 ;
19523     bool temp6 = false ;
19524     PyObject * obj0 = 0 ;
19525     PyObject * obj1 = 0 ;
19526     PyObject * obj2 = 0 ;
19527     PyObject * obj3 = 0 ;
19528     PyObject * obj4 = 0 ;
19529     PyObject * obj5 = 0 ;
19530     char *kwnames[] = {
19531         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
19532     };
19533
19534     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19535     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19536     if (SWIG_arg_fail(1)) SWIG_fail;
19537     if (obj1) {
19538         {
19539             arg2 = (int const)(SWIG_As_int(obj1));
19540             if (SWIG_arg_fail(2)) SWIG_fail;
19541         }
19542     }
19543     if (obj2) {
19544         {
19545             arg3 = &temp3;
19546             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19547         }
19548     }
19549     if (obj3) {
19550         {
19551             arg4 = &temp4;
19552             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
19553         }
19554     }
19555     if (obj4) {
19556         {
19557             arg5 = (long)(SWIG_As_long(obj4));
19558             if (SWIG_arg_fail(5)) SWIG_fail;
19559         }
19560     }
19561     if (obj5) {
19562         {
19563             arg6 = wxString_in_helper(obj5);
19564             if (arg6 == NULL) SWIG_fail;
19565             temp6 = true;
19566         }
19567     }
19568     {
19569         if (!wxPyCheckForApp()) SWIG_fail;
19570         PyThreadState* __tstate = wxPyBeginAllowThreads();
19571         result = (wxPyScrolledWindow *)new wxPyScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
19572
19573         wxPyEndAllowThreads(__tstate);
19574         if (PyErr_Occurred()) SWIG_fail;
19575     }
19576     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyScrolledWindow, 1);
19577     {
19578         if (temp6)
19579         delete arg6;
19580     }
19581     return resultobj;
19582     fail:
19583     {
19584         if (temp6)
19585         delete arg6;
19586     }
19587     return NULL;
19588 }
19589
19590
19591 static PyObject *_wrap_new_PrePyScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19592     PyObject *resultobj;
19593     wxPyScrolledWindow *result;
19594     char *kwnames[] = {
19595         NULL
19596     };
19597
19598     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyScrolledWindow",kwnames)) goto fail;
19599     {
19600         if (!wxPyCheckForApp()) SWIG_fail;
19601         PyThreadState* __tstate = wxPyBeginAllowThreads();
19602         result = (wxPyScrolledWindow *)new wxPyScrolledWindow();
19603
19604         wxPyEndAllowThreads(__tstate);
19605         if (PyErr_Occurred()) SWIG_fail;
19606     }
19607     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyScrolledWindow, 1);
19608     return resultobj;
19609     fail:
19610     return NULL;
19611 }
19612
19613
19614 static PyObject *_wrap_PyScrolledWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
19615     PyObject *resultobj;
19616     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19617     PyObject *arg2 = (PyObject *) 0 ;
19618     PyObject *arg3 = (PyObject *) 0 ;
19619     PyObject * obj0 = 0 ;
19620     PyObject * obj1 = 0 ;
19621     PyObject * obj2 = 0 ;
19622     char *kwnames[] = {
19623         (char *) "self",(char *) "self",(char *) "_class", NULL
19624     };
19625
19626     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
19627     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19628     if (SWIG_arg_fail(1)) SWIG_fail;
19629     arg2 = obj1;
19630     arg3 = obj2;
19631     {
19632         PyThreadState* __tstate = wxPyBeginAllowThreads();
19633         (arg1)->_setCallbackInfo(arg2,arg3);
19634
19635         wxPyEndAllowThreads(__tstate);
19636         if (PyErr_Occurred()) SWIG_fail;
19637     }
19638     Py_INCREF(Py_None); resultobj = Py_None;
19639     return resultobj;
19640     fail:
19641     return NULL;
19642 }
19643
19644
19645 static PyObject *_wrap_PyScrolledWindow_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19646     PyObject *resultobj;
19647     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19648     wxSize *arg2 = 0 ;
19649     wxSize temp2 ;
19650     PyObject * obj0 = 0 ;
19651     PyObject * obj1 = 0 ;
19652     char *kwnames[] = {
19653         (char *) "self",(char *) "size", NULL
19654     };
19655
19656     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
19657     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19658     if (SWIG_arg_fail(1)) SWIG_fail;
19659     {
19660         arg2 = &temp2;
19661         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
19662     }
19663     {
19664         PyThreadState* __tstate = wxPyBeginAllowThreads();
19665         (arg1)->SetBestSize((wxSize const &)*arg2);
19666
19667         wxPyEndAllowThreads(__tstate);
19668         if (PyErr_Occurred()) SWIG_fail;
19669     }
19670     Py_INCREF(Py_None); resultobj = Py_None;
19671     return resultobj;
19672     fail:
19673     return NULL;
19674 }
19675
19676
19677 static PyObject *_wrap_PyScrolledWindow_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19678     PyObject *resultobj;
19679     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19680     int arg2 ;
19681     int arg3 ;
19682     int arg4 ;
19683     int arg5 ;
19684     PyObject * obj0 = 0 ;
19685     PyObject * obj1 = 0 ;
19686     PyObject * obj2 = 0 ;
19687     PyObject * obj3 = 0 ;
19688     PyObject * obj4 = 0 ;
19689     char *kwnames[] = {
19690         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
19691     };
19692
19693     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyScrolledWindow_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19694     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19695     if (SWIG_arg_fail(1)) SWIG_fail;
19696     {
19697         arg2 = (int)(SWIG_As_int(obj1));
19698         if (SWIG_arg_fail(2)) SWIG_fail;
19699     }
19700     {
19701         arg3 = (int)(SWIG_As_int(obj2));
19702         if (SWIG_arg_fail(3)) SWIG_fail;
19703     }
19704     {
19705         arg4 = (int)(SWIG_As_int(obj3));
19706         if (SWIG_arg_fail(4)) SWIG_fail;
19707     }
19708     {
19709         arg5 = (int)(SWIG_As_int(obj4));
19710         if (SWIG_arg_fail(5)) SWIG_fail;
19711     }
19712     {
19713         PyThreadState* __tstate = wxPyBeginAllowThreads();
19714         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
19715
19716         wxPyEndAllowThreads(__tstate);
19717         if (PyErr_Occurred()) SWIG_fail;
19718     }
19719     Py_INCREF(Py_None); resultobj = Py_None;
19720     return resultobj;
19721     fail:
19722     return NULL;
19723 }
19724
19725
19726 static PyObject *_wrap_PyScrolledWindow_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19727     PyObject *resultobj;
19728     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19729     int arg2 ;
19730     int arg3 ;
19731     int arg4 ;
19732     int arg5 ;
19733     int arg6 = (int) wxSIZE_AUTO ;
19734     PyObject * obj0 = 0 ;
19735     PyObject * obj1 = 0 ;
19736     PyObject * obj2 = 0 ;
19737     PyObject * obj3 = 0 ;
19738     PyObject * obj4 = 0 ;
19739     PyObject * obj5 = 0 ;
19740     char *kwnames[] = {
19741         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
19742     };
19743
19744     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyScrolledWindow_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19745     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19746     if (SWIG_arg_fail(1)) SWIG_fail;
19747     {
19748         arg2 = (int)(SWIG_As_int(obj1));
19749         if (SWIG_arg_fail(2)) SWIG_fail;
19750     }
19751     {
19752         arg3 = (int)(SWIG_As_int(obj2));
19753         if (SWIG_arg_fail(3)) SWIG_fail;
19754     }
19755     {
19756         arg4 = (int)(SWIG_As_int(obj3));
19757         if (SWIG_arg_fail(4)) SWIG_fail;
19758     }
19759     {
19760         arg5 = (int)(SWIG_As_int(obj4));
19761         if (SWIG_arg_fail(5)) SWIG_fail;
19762     }
19763     if (obj5) {
19764         {
19765             arg6 = (int)(SWIG_As_int(obj5));
19766             if (SWIG_arg_fail(6)) SWIG_fail;
19767         }
19768     }
19769     {
19770         PyThreadState* __tstate = wxPyBeginAllowThreads();
19771         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
19772
19773         wxPyEndAllowThreads(__tstate);
19774         if (PyErr_Occurred()) SWIG_fail;
19775     }
19776     Py_INCREF(Py_None); resultobj = Py_None;
19777     return resultobj;
19778     fail:
19779     return NULL;
19780 }
19781
19782
19783 static PyObject *_wrap_PyScrolledWindow_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19784     PyObject *resultobj;
19785     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19786     int arg2 ;
19787     int arg3 ;
19788     PyObject * obj0 = 0 ;
19789     PyObject * obj1 = 0 ;
19790     PyObject * obj2 = 0 ;
19791     char *kwnames[] = {
19792         (char *) "self",(char *) "width",(char *) "height", NULL
19793     };
19794
19795     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
19796     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19797     if (SWIG_arg_fail(1)) SWIG_fail;
19798     {
19799         arg2 = (int)(SWIG_As_int(obj1));
19800         if (SWIG_arg_fail(2)) SWIG_fail;
19801     }
19802     {
19803         arg3 = (int)(SWIG_As_int(obj2));
19804         if (SWIG_arg_fail(3)) SWIG_fail;
19805     }
19806     {
19807         PyThreadState* __tstate = wxPyBeginAllowThreads();
19808         (arg1)->base_DoSetClientSize(arg2,arg3);
19809
19810         wxPyEndAllowThreads(__tstate);
19811         if (PyErr_Occurred()) SWIG_fail;
19812     }
19813     Py_INCREF(Py_None); resultobj = Py_None;
19814     return resultobj;
19815     fail:
19816     return NULL;
19817 }
19818
19819
19820 static PyObject *_wrap_PyScrolledWindow_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19821     PyObject *resultobj;
19822     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19823     int arg2 ;
19824     int arg3 ;
19825     PyObject * obj0 = 0 ;
19826     PyObject * obj1 = 0 ;
19827     PyObject * obj2 = 0 ;
19828     char *kwnames[] = {
19829         (char *) "self",(char *) "x",(char *) "y", NULL
19830     };
19831
19832     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
19833     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19834     if (SWIG_arg_fail(1)) SWIG_fail;
19835     {
19836         arg2 = (int)(SWIG_As_int(obj1));
19837         if (SWIG_arg_fail(2)) SWIG_fail;
19838     }
19839     {
19840         arg3 = (int)(SWIG_As_int(obj2));
19841         if (SWIG_arg_fail(3)) SWIG_fail;
19842     }
19843     {
19844         PyThreadState* __tstate = wxPyBeginAllowThreads();
19845         (arg1)->base_DoSetVirtualSize(arg2,arg3);
19846
19847         wxPyEndAllowThreads(__tstate);
19848         if (PyErr_Occurred()) SWIG_fail;
19849     }
19850     Py_INCREF(Py_None); resultobj = Py_None;
19851     return resultobj;
19852     fail:
19853     return NULL;
19854 }
19855
19856
19857 static PyObject *_wrap_PyScrolledWindow_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19858     PyObject *resultobj;
19859     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19860     int *arg2 = (int *) 0 ;
19861     int *arg3 = (int *) 0 ;
19862     int temp2 ;
19863     int res2 = 0 ;
19864     int temp3 ;
19865     int res3 = 0 ;
19866     PyObject * obj0 = 0 ;
19867     char *kwnames[] = {
19868         (char *) "self", NULL
19869     };
19870
19871     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19872     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19873     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetSize",kwnames,&obj0)) goto fail;
19874     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19875     if (SWIG_arg_fail(1)) SWIG_fail;
19876     {
19877         PyThreadState* __tstate = wxPyBeginAllowThreads();
19878         ((wxPyScrolledWindow const *)arg1)->base_DoGetSize(arg2,arg3);
19879
19880         wxPyEndAllowThreads(__tstate);
19881         if (PyErr_Occurred()) SWIG_fail;
19882     }
19883     Py_INCREF(Py_None); resultobj = Py_None;
19884     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19885     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19886     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19887     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19888     return resultobj;
19889     fail:
19890     return NULL;
19891 }
19892
19893
19894 static PyObject *_wrap_PyScrolledWindow_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19895     PyObject *resultobj;
19896     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19897     int *arg2 = (int *) 0 ;
19898     int *arg3 = (int *) 0 ;
19899     int temp2 ;
19900     int res2 = 0 ;
19901     int temp3 ;
19902     int res3 = 0 ;
19903     PyObject * obj0 = 0 ;
19904     char *kwnames[] = {
19905         (char *) "self", NULL
19906     };
19907
19908     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19909     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19910     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetClientSize",kwnames,&obj0)) goto fail;
19911     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19912     if (SWIG_arg_fail(1)) SWIG_fail;
19913     {
19914         PyThreadState* __tstate = wxPyBeginAllowThreads();
19915         ((wxPyScrolledWindow const *)arg1)->base_DoGetClientSize(arg2,arg3);
19916
19917         wxPyEndAllowThreads(__tstate);
19918         if (PyErr_Occurred()) SWIG_fail;
19919     }
19920     Py_INCREF(Py_None); resultobj = Py_None;
19921     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19922     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19923     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19924     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19925     return resultobj;
19926     fail:
19927     return NULL;
19928 }
19929
19930
19931 static PyObject *_wrap_PyScrolledWindow_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19932     PyObject *resultobj;
19933     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19934     int *arg2 = (int *) 0 ;
19935     int *arg3 = (int *) 0 ;
19936     int temp2 ;
19937     int res2 = 0 ;
19938     int temp3 ;
19939     int res3 = 0 ;
19940     PyObject * obj0 = 0 ;
19941     char *kwnames[] = {
19942         (char *) "self", NULL
19943     };
19944
19945     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19946     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19947     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetPosition",kwnames,&obj0)) goto fail;
19948     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19949     if (SWIG_arg_fail(1)) SWIG_fail;
19950     {
19951         PyThreadState* __tstate = wxPyBeginAllowThreads();
19952         ((wxPyScrolledWindow const *)arg1)->base_DoGetPosition(arg2,arg3);
19953
19954         wxPyEndAllowThreads(__tstate);
19955         if (PyErr_Occurred()) SWIG_fail;
19956     }
19957     Py_INCREF(Py_None); resultobj = Py_None;
19958     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19959     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19960     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19961     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19962     return resultobj;
19963     fail:
19964     return NULL;
19965 }
19966
19967
19968 static PyObject *_wrap_PyScrolledWindow_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19969     PyObject *resultobj;
19970     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19971     wxSize result;
19972     PyObject * obj0 = 0 ;
19973     char *kwnames[] = {
19974         (char *) "self", NULL
19975     };
19976
19977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
19978     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19979     if (SWIG_arg_fail(1)) SWIG_fail;
19980     {
19981         PyThreadState* __tstate = wxPyBeginAllowThreads();
19982         result = ((wxPyScrolledWindow const *)arg1)->base_DoGetVirtualSize();
19983
19984         wxPyEndAllowThreads(__tstate);
19985         if (PyErr_Occurred()) SWIG_fail;
19986     }
19987     {
19988         wxSize * resultptr;
19989         resultptr = new wxSize((wxSize &)(result));
19990         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19991     }
19992     return resultobj;
19993     fail:
19994     return NULL;
19995 }
19996
19997
19998 static PyObject *_wrap_PyScrolledWindow_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19999     PyObject *resultobj;
20000     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20001     wxSize result;
20002     PyObject * obj0 = 0 ;
20003     char *kwnames[] = {
20004         (char *) "self", NULL
20005     };
20006
20007     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetBestSize",kwnames,&obj0)) goto fail;
20008     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20009     if (SWIG_arg_fail(1)) SWIG_fail;
20010     {
20011         PyThreadState* __tstate = wxPyBeginAllowThreads();
20012         result = ((wxPyScrolledWindow const *)arg1)->base_DoGetBestSize();
20013
20014         wxPyEndAllowThreads(__tstate);
20015         if (PyErr_Occurred()) SWIG_fail;
20016     }
20017     {
20018         wxSize * resultptr;
20019         resultptr = new wxSize((wxSize &)(result));
20020         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20021     }
20022     return resultobj;
20023     fail:
20024     return NULL;
20025 }
20026
20027
20028 static PyObject *_wrap_PyScrolledWindow_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
20029     PyObject *resultobj;
20030     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20031     PyObject * obj0 = 0 ;
20032     char *kwnames[] = {
20033         (char *) "self", NULL
20034     };
20035
20036     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_InitDialog",kwnames,&obj0)) goto fail;
20037     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20038     if (SWIG_arg_fail(1)) SWIG_fail;
20039     {
20040         PyThreadState* __tstate = wxPyBeginAllowThreads();
20041         (arg1)->base_InitDialog();
20042
20043         wxPyEndAllowThreads(__tstate);
20044         if (PyErr_Occurred()) SWIG_fail;
20045     }
20046     Py_INCREF(Py_None); resultobj = Py_None;
20047     return resultobj;
20048     fail:
20049     return NULL;
20050 }
20051
20052
20053 static PyObject *_wrap_PyScrolledWindow_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20054     PyObject *resultobj;
20055     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20056     bool result;
20057     PyObject * obj0 = 0 ;
20058     char *kwnames[] = {
20059         (char *) "self", NULL
20060     };
20061
20062     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
20063     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20064     if (SWIG_arg_fail(1)) SWIG_fail;
20065     {
20066         PyThreadState* __tstate = wxPyBeginAllowThreads();
20067         result = (bool)(arg1)->base_TransferDataToWindow();
20068
20069         wxPyEndAllowThreads(__tstate);
20070         if (PyErr_Occurred()) SWIG_fail;
20071     }
20072     {
20073         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20074     }
20075     return resultobj;
20076     fail:
20077     return NULL;
20078 }
20079
20080
20081 static PyObject *_wrap_PyScrolledWindow_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20082     PyObject *resultobj;
20083     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20084     bool result;
20085     PyObject * obj0 = 0 ;
20086     char *kwnames[] = {
20087         (char *) "self", NULL
20088     };
20089
20090     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
20091     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20092     if (SWIG_arg_fail(1)) SWIG_fail;
20093     {
20094         PyThreadState* __tstate = wxPyBeginAllowThreads();
20095         result = (bool)(arg1)->base_TransferDataFromWindow();
20096
20097         wxPyEndAllowThreads(__tstate);
20098         if (PyErr_Occurred()) SWIG_fail;
20099     }
20100     {
20101         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20102     }
20103     return resultobj;
20104     fail:
20105     return NULL;
20106 }
20107
20108
20109 static PyObject *_wrap_PyScrolledWindow_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
20110     PyObject *resultobj;
20111     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20112     bool result;
20113     PyObject * obj0 = 0 ;
20114     char *kwnames[] = {
20115         (char *) "self", NULL
20116     };
20117
20118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_Validate",kwnames,&obj0)) goto fail;
20119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20120     if (SWIG_arg_fail(1)) SWIG_fail;
20121     {
20122         PyThreadState* __tstate = wxPyBeginAllowThreads();
20123         result = (bool)(arg1)->base_Validate();
20124
20125         wxPyEndAllowThreads(__tstate);
20126         if (PyErr_Occurred()) SWIG_fail;
20127     }
20128     {
20129         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20130     }
20131     return resultobj;
20132     fail:
20133     return NULL;
20134 }
20135
20136
20137 static PyObject *_wrap_PyScrolledWindow_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
20138     PyObject *resultobj;
20139     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20140     bool result;
20141     PyObject * obj0 = 0 ;
20142     char *kwnames[] = {
20143         (char *) "self", NULL
20144     };
20145
20146     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_AcceptsFocus",kwnames,&obj0)) goto fail;
20147     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20148     if (SWIG_arg_fail(1)) SWIG_fail;
20149     {
20150         PyThreadState* __tstate = wxPyBeginAllowThreads();
20151         result = (bool)((wxPyScrolledWindow const *)arg1)->base_AcceptsFocus();
20152
20153         wxPyEndAllowThreads(__tstate);
20154         if (PyErr_Occurred()) SWIG_fail;
20155     }
20156     {
20157         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20158     }
20159     return resultobj;
20160     fail:
20161     return NULL;
20162 }
20163
20164
20165 static PyObject *_wrap_PyScrolledWindow_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
20166     PyObject *resultobj;
20167     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20168     bool result;
20169     PyObject * obj0 = 0 ;
20170     char *kwnames[] = {
20171         (char *) "self", NULL
20172     };
20173
20174     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
20175     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20176     if (SWIG_arg_fail(1)) SWIG_fail;
20177     {
20178         PyThreadState* __tstate = wxPyBeginAllowThreads();
20179         result = (bool)((wxPyScrolledWindow const *)arg1)->base_AcceptsFocusFromKeyboard();
20180
20181         wxPyEndAllowThreads(__tstate);
20182         if (PyErr_Occurred()) SWIG_fail;
20183     }
20184     {
20185         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20186     }
20187     return resultobj;
20188     fail:
20189     return NULL;
20190 }
20191
20192
20193 static PyObject *_wrap_PyScrolledWindow_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
20194     PyObject *resultobj;
20195     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20196     wxSize result;
20197     PyObject * obj0 = 0 ;
20198     char *kwnames[] = {
20199         (char *) "self", NULL
20200     };
20201
20202     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_GetMaxSize",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 = ((wxPyScrolledWindow const *)arg1)->base_GetMaxSize();
20208
20209         wxPyEndAllowThreads(__tstate);
20210         if (PyErr_Occurred()) SWIG_fail;
20211     }
20212     {
20213         wxSize * resultptr;
20214         resultptr = new wxSize((wxSize &)(result));
20215         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20216     }
20217     return resultobj;
20218     fail:
20219     return NULL;
20220 }
20221
20222
20223 static PyObject *_wrap_PyScrolledWindow_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
20224     PyObject *resultobj;
20225     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20226     wxWindow *arg2 = (wxWindow *) 0 ;
20227     PyObject * obj0 = 0 ;
20228     PyObject * obj1 = 0 ;
20229     char *kwnames[] = {
20230         (char *) "self",(char *) "child", NULL
20231     };
20232
20233     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
20234     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20235     if (SWIG_arg_fail(1)) SWIG_fail;
20236     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20237     if (SWIG_arg_fail(2)) SWIG_fail;
20238     {
20239         PyThreadState* __tstate = wxPyBeginAllowThreads();
20240         (arg1)->base_AddChild(arg2);
20241
20242         wxPyEndAllowThreads(__tstate);
20243         if (PyErr_Occurred()) SWIG_fail;
20244     }
20245     Py_INCREF(Py_None); resultobj = Py_None;
20246     return resultobj;
20247     fail:
20248     return NULL;
20249 }
20250
20251
20252 static PyObject *_wrap_PyScrolledWindow_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
20253     PyObject *resultobj;
20254     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20255     wxWindow *arg2 = (wxWindow *) 0 ;
20256     PyObject * obj0 = 0 ;
20257     PyObject * obj1 = 0 ;
20258     char *kwnames[] = {
20259         (char *) "self",(char *) "child", NULL
20260     };
20261
20262     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
20263     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20264     if (SWIG_arg_fail(1)) SWIG_fail;
20265     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20266     if (SWIG_arg_fail(2)) SWIG_fail;
20267     {
20268         PyThreadState* __tstate = wxPyBeginAllowThreads();
20269         (arg1)->base_RemoveChild(arg2);
20270
20271         wxPyEndAllowThreads(__tstate);
20272         if (PyErr_Occurred()) SWIG_fail;
20273     }
20274     Py_INCREF(Py_None); resultobj = Py_None;
20275     return resultobj;
20276     fail:
20277     return NULL;
20278 }
20279
20280
20281 static PyObject *_wrap_PyScrolledWindow_base_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
20282     PyObject *resultobj;
20283     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20284     bool result;
20285     PyObject * obj0 = 0 ;
20286     char *kwnames[] = {
20287         (char *) "self", NULL
20288     };
20289
20290     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_ShouldInheritColours",kwnames,&obj0)) goto fail;
20291     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20292     if (SWIG_arg_fail(1)) SWIG_fail;
20293     {
20294         PyThreadState* __tstate = wxPyBeginAllowThreads();
20295         result = (bool)((wxPyScrolledWindow const *)arg1)->base_ShouldInheritColours();
20296
20297         wxPyEndAllowThreads(__tstate);
20298         if (PyErr_Occurred()) SWIG_fail;
20299     }
20300     {
20301         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20302     }
20303     return resultobj;
20304     fail:
20305     return NULL;
20306 }
20307
20308
20309 static PyObject *_wrap_PyScrolledWindow_base_ApplyParentThemeBackground(PyObject *, PyObject *args, PyObject *kwargs) {
20310     PyObject *resultobj;
20311     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20312     wxColour *arg2 = 0 ;
20313     wxColour temp2 ;
20314     PyObject * obj0 = 0 ;
20315     PyObject * obj1 = 0 ;
20316     char *kwnames[] = {
20317         (char *) "self",(char *) "c", NULL
20318     };
20319
20320     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_ApplyParentThemeBackground",kwnames,&obj0,&obj1)) goto fail;
20321     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20322     if (SWIG_arg_fail(1)) SWIG_fail;
20323     {
20324         arg2 = &temp2;
20325         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20326     }
20327     {
20328         PyThreadState* __tstate = wxPyBeginAllowThreads();
20329         (arg1)->base_ApplyParentThemeBackground((wxColour const &)*arg2);
20330
20331         wxPyEndAllowThreads(__tstate);
20332         if (PyErr_Occurred()) SWIG_fail;
20333     }
20334     Py_INCREF(Py_None); resultobj = Py_None;
20335     return resultobj;
20336     fail:
20337     return NULL;
20338 }
20339
20340
20341 static PyObject *_wrap_PyScrolledWindow_base_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
20342     PyObject *resultobj;
20343     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20344     wxVisualAttributes result;
20345     PyObject * obj0 = 0 ;
20346     char *kwnames[] = {
20347         (char *) "self", NULL
20348     };
20349
20350     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_GetDefaultAttributes",kwnames,&obj0)) goto fail;
20351     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20352     if (SWIG_arg_fail(1)) SWIG_fail;
20353     {
20354         PyThreadState* __tstate = wxPyBeginAllowThreads();
20355         result = (arg1)->base_GetDefaultAttributes();
20356
20357         wxPyEndAllowThreads(__tstate);
20358         if (PyErr_Occurred()) SWIG_fail;
20359     }
20360     {
20361         wxVisualAttributes * resultptr;
20362         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
20363         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
20364     }
20365     return resultobj;
20366     fail:
20367     return NULL;
20368 }
20369
20370
20371 static PyObject * PyScrolledWindow_swigregister(PyObject *, PyObject *args) {
20372     PyObject *obj;
20373     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20374     SWIG_TypeClientData(SWIGTYPE_p_wxPyScrolledWindow, obj);
20375     Py_INCREF(obj);
20376     return Py_BuildValue((char *)"");
20377 }
20378 static int _wrap_PrintoutTitleStr_set(PyObject *) {
20379     PyErr_SetString(PyExc_TypeError,"Variable PrintoutTitleStr is read-only.");
20380     return 1;
20381 }
20382
20383
20384 static PyObject *_wrap_PrintoutTitleStr_get(void) {
20385     PyObject *pyobj;
20386
20387     {
20388 #if wxUSE_UNICODE
20389         pyobj = PyUnicode_FromWideChar((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
20390 #else
20391         pyobj = PyString_FromStringAndSize((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
20392 #endif
20393     }
20394     return pyobj;
20395 }
20396
20397
20398 static int _wrap_PreviewCanvasNameStr_set(PyObject *) {
20399     PyErr_SetString(PyExc_TypeError,"Variable PreviewCanvasNameStr is read-only.");
20400     return 1;
20401 }
20402
20403
20404 static PyObject *_wrap_PreviewCanvasNameStr_get(void) {
20405     PyObject *pyobj;
20406
20407     {
20408 #if wxUSE_UNICODE
20409         pyobj = PyUnicode_FromWideChar((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
20410 #else
20411         pyobj = PyString_FromStringAndSize((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
20412 #endif
20413     }
20414     return pyobj;
20415 }
20416
20417
20418 static PyObject *_wrap_new_PrintData__SWIG_0(PyObject *, PyObject *args) {
20419     PyObject *resultobj;
20420     wxPrintData *result;
20421
20422     if(!PyArg_ParseTuple(args,(char *)":new_PrintData")) goto fail;
20423     {
20424         PyThreadState* __tstate = wxPyBeginAllowThreads();
20425         result = (wxPrintData *)new wxPrintData();
20426
20427         wxPyEndAllowThreads(__tstate);
20428         if (PyErr_Occurred()) SWIG_fail;
20429     }
20430     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 1);
20431     return resultobj;
20432     fail:
20433     return NULL;
20434 }
20435
20436
20437 static PyObject *_wrap_new_PrintData__SWIG_1(PyObject *, PyObject *args) {
20438     PyObject *resultobj;
20439     wxPrintData *arg1 = 0 ;
20440     wxPrintData *result;
20441     PyObject * obj0 = 0 ;
20442
20443     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintData",&obj0)) goto fail;
20444     {
20445         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20446         if (SWIG_arg_fail(1)) SWIG_fail;
20447         if (arg1 == NULL) {
20448             SWIG_null_ref("wxPrintData");
20449         }
20450         if (SWIG_arg_fail(1)) SWIG_fail;
20451     }
20452     {
20453         PyThreadState* __tstate = wxPyBeginAllowThreads();
20454         result = (wxPrintData *)new wxPrintData((wxPrintData const &)*arg1);
20455
20456         wxPyEndAllowThreads(__tstate);
20457         if (PyErr_Occurred()) SWIG_fail;
20458     }
20459     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 1);
20460     return resultobj;
20461     fail:
20462     return NULL;
20463 }
20464
20465
20466 static PyObject *_wrap_new_PrintData(PyObject *self, PyObject *args) {
20467     int argc;
20468     PyObject *argv[2];
20469     int ii;
20470
20471     argc = PyObject_Length(args);
20472     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
20473         argv[ii] = PyTuple_GetItem(args,ii);
20474     }
20475     if (argc == 0) {
20476         return _wrap_new_PrintData__SWIG_0(self,args);
20477     }
20478     if (argc == 1) {
20479         int _v;
20480         {
20481             void *ptr = 0;
20482             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
20483                 _v = 0;
20484                 PyErr_Clear();
20485             } else {
20486                 _v = (ptr != 0);
20487             }
20488         }
20489         if (_v) {
20490             return _wrap_new_PrintData__SWIG_1(self,args);
20491         }
20492     }
20493
20494     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintData'");
20495     return NULL;
20496 }
20497
20498
20499 static PyObject *_wrap_delete_PrintData(PyObject *, PyObject *args, PyObject *kwargs) {
20500     PyObject *resultobj;
20501     wxPrintData *arg1 = (wxPrintData *) 0 ;
20502     PyObject * obj0 = 0 ;
20503     char *kwnames[] = {
20504         (char *) "self", NULL
20505     };
20506
20507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PrintData",kwnames,&obj0)) goto fail;
20508     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20509     if (SWIG_arg_fail(1)) SWIG_fail;
20510     {
20511         PyThreadState* __tstate = wxPyBeginAllowThreads();
20512         delete arg1;
20513
20514         wxPyEndAllowThreads(__tstate);
20515         if (PyErr_Occurred()) SWIG_fail;
20516     }
20517     Py_INCREF(Py_None); resultobj = Py_None;
20518     return resultobj;
20519     fail:
20520     return NULL;
20521 }
20522
20523
20524 static PyObject *_wrap_PrintData_GetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
20525     PyObject *resultobj;
20526     wxPrintData *arg1 = (wxPrintData *) 0 ;
20527     int result;
20528     PyObject * obj0 = 0 ;
20529     char *kwnames[] = {
20530         (char *) "self", NULL
20531     };
20532
20533     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetNoCopies",kwnames,&obj0)) goto fail;
20534     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20535     if (SWIG_arg_fail(1)) SWIG_fail;
20536     {
20537         PyThreadState* __tstate = wxPyBeginAllowThreads();
20538         result = (int)(arg1)->GetNoCopies();
20539
20540         wxPyEndAllowThreads(__tstate);
20541         if (PyErr_Occurred()) SWIG_fail;
20542     }
20543     {
20544         resultobj = SWIG_From_int((int)(result));
20545     }
20546     return resultobj;
20547     fail:
20548     return NULL;
20549 }
20550
20551
20552 static PyObject *_wrap_PrintData_GetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
20553     PyObject *resultobj;
20554     wxPrintData *arg1 = (wxPrintData *) 0 ;
20555     bool result;
20556     PyObject * obj0 = 0 ;
20557     char *kwnames[] = {
20558         (char *) "self", NULL
20559     };
20560
20561     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetCollate",kwnames,&obj0)) goto fail;
20562     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20563     if (SWIG_arg_fail(1)) SWIG_fail;
20564     {
20565         PyThreadState* __tstate = wxPyBeginAllowThreads();
20566         result = (bool)(arg1)->GetCollate();
20567
20568         wxPyEndAllowThreads(__tstate);
20569         if (PyErr_Occurred()) SWIG_fail;
20570     }
20571     {
20572         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20573     }
20574     return resultobj;
20575     fail:
20576     return NULL;
20577 }
20578
20579
20580 static PyObject *_wrap_PrintData_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
20581     PyObject *resultobj;
20582     wxPrintData *arg1 = (wxPrintData *) 0 ;
20583     int result;
20584     PyObject * obj0 = 0 ;
20585     char *kwnames[] = {
20586         (char *) "self", NULL
20587     };
20588
20589     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetOrientation",kwnames,&obj0)) goto fail;
20590     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20591     if (SWIG_arg_fail(1)) SWIG_fail;
20592     {
20593         PyThreadState* __tstate = wxPyBeginAllowThreads();
20594         result = (int)(arg1)->GetOrientation();
20595
20596         wxPyEndAllowThreads(__tstate);
20597         if (PyErr_Occurred()) SWIG_fail;
20598     }
20599     {
20600         resultobj = SWIG_From_int((int)(result));
20601     }
20602     return resultobj;
20603     fail:
20604     return NULL;
20605 }
20606
20607
20608 static PyObject *_wrap_PrintData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
20609     PyObject *resultobj;
20610     wxPrintData *arg1 = (wxPrintData *) 0 ;
20611     bool result;
20612     PyObject * obj0 = 0 ;
20613     char *kwnames[] = {
20614         (char *) "self", NULL
20615     };
20616
20617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_Ok",kwnames,&obj0)) goto fail;
20618     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20619     if (SWIG_arg_fail(1)) SWIG_fail;
20620     {
20621         PyThreadState* __tstate = wxPyBeginAllowThreads();
20622         result = (bool)(arg1)->Ok();
20623
20624         wxPyEndAllowThreads(__tstate);
20625         if (PyErr_Occurred()) SWIG_fail;
20626     }
20627     {
20628         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20629     }
20630     return resultobj;
20631     fail:
20632     return NULL;
20633 }
20634
20635
20636 static PyObject *_wrap_PrintData_GetPrinterName(PyObject *, PyObject *args, PyObject *kwargs) {
20637     PyObject *resultobj;
20638     wxPrintData *arg1 = (wxPrintData *) 0 ;
20639     wxString *result;
20640     PyObject * obj0 = 0 ;
20641     char *kwnames[] = {
20642         (char *) "self", NULL
20643     };
20644
20645     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterName",kwnames,&obj0)) goto fail;
20646     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20647     if (SWIG_arg_fail(1)) SWIG_fail;
20648     {
20649         PyThreadState* __tstate = wxPyBeginAllowThreads();
20650         {
20651             wxString const &_result_ref = (arg1)->GetPrinterName();
20652             result = (wxString *) &_result_ref;
20653         }
20654
20655         wxPyEndAllowThreads(__tstate);
20656         if (PyErr_Occurred()) SWIG_fail;
20657     }
20658     {
20659 #if wxUSE_UNICODE
20660         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20661 #else
20662         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20663 #endif
20664     }
20665     return resultobj;
20666     fail:
20667     return NULL;
20668 }
20669
20670
20671 static PyObject *_wrap_PrintData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
20672     PyObject *resultobj;
20673     wxPrintData *arg1 = (wxPrintData *) 0 ;
20674     bool result;
20675     PyObject * obj0 = 0 ;
20676     char *kwnames[] = {
20677         (char *) "self", NULL
20678     };
20679
20680     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetColour",kwnames,&obj0)) goto fail;
20681     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20682     if (SWIG_arg_fail(1)) SWIG_fail;
20683     {
20684         PyThreadState* __tstate = wxPyBeginAllowThreads();
20685         result = (bool)(arg1)->GetColour();
20686
20687         wxPyEndAllowThreads(__tstate);
20688         if (PyErr_Occurred()) SWIG_fail;
20689     }
20690     {
20691         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20692     }
20693     return resultobj;
20694     fail:
20695     return NULL;
20696 }
20697
20698
20699 static PyObject *_wrap_PrintData_GetDuplex(PyObject *, PyObject *args, PyObject *kwargs) {
20700     PyObject *resultobj;
20701     wxPrintData *arg1 = (wxPrintData *) 0 ;
20702     wxDuplexMode result;
20703     PyObject * obj0 = 0 ;
20704     char *kwnames[] = {
20705         (char *) "self", NULL
20706     };
20707
20708     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetDuplex",kwnames,&obj0)) goto fail;
20709     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20710     if (SWIG_arg_fail(1)) SWIG_fail;
20711     {
20712         PyThreadState* __tstate = wxPyBeginAllowThreads();
20713         result = (wxDuplexMode)(arg1)->GetDuplex();
20714
20715         wxPyEndAllowThreads(__tstate);
20716         if (PyErr_Occurred()) SWIG_fail;
20717     }
20718     resultobj = SWIG_From_int((result));
20719     return resultobj;
20720     fail:
20721     return NULL;
20722 }
20723
20724
20725 static PyObject *_wrap_PrintData_GetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
20726     PyObject *resultobj;
20727     wxPrintData *arg1 = (wxPrintData *) 0 ;
20728     wxPaperSize result;
20729     PyObject * obj0 = 0 ;
20730     char *kwnames[] = {
20731         (char *) "self", NULL
20732     };
20733
20734     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPaperId",kwnames,&obj0)) goto fail;
20735     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20736     if (SWIG_arg_fail(1)) SWIG_fail;
20737     {
20738         PyThreadState* __tstate = wxPyBeginAllowThreads();
20739         result = (wxPaperSize)(arg1)->GetPaperId();
20740
20741         wxPyEndAllowThreads(__tstate);
20742         if (PyErr_Occurred()) SWIG_fail;
20743     }
20744     resultobj = SWIG_From_int((result));
20745     return resultobj;
20746     fail:
20747     return NULL;
20748 }
20749
20750
20751 static PyObject *_wrap_PrintData_GetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
20752     PyObject *resultobj;
20753     wxPrintData *arg1 = (wxPrintData *) 0 ;
20754     wxSize *result;
20755     PyObject * obj0 = 0 ;
20756     char *kwnames[] = {
20757         (char *) "self", NULL
20758     };
20759
20760     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPaperSize",kwnames,&obj0)) goto fail;
20761     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20762     if (SWIG_arg_fail(1)) SWIG_fail;
20763     {
20764         PyThreadState* __tstate = wxPyBeginAllowThreads();
20765         {
20766             wxSize const &_result_ref = (arg1)->GetPaperSize();
20767             result = (wxSize *) &_result_ref;
20768         }
20769
20770         wxPyEndAllowThreads(__tstate);
20771         if (PyErr_Occurred()) SWIG_fail;
20772     }
20773     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20774     return resultobj;
20775     fail:
20776     return NULL;
20777 }
20778
20779
20780 static PyObject *_wrap_PrintData_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
20781     PyObject *resultobj;
20782     wxPrintData *arg1 = (wxPrintData *) 0 ;
20783     int result;
20784     PyObject * obj0 = 0 ;
20785     char *kwnames[] = {
20786         (char *) "self", NULL
20787     };
20788
20789     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetQuality",kwnames,&obj0)) goto fail;
20790     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20791     if (SWIG_arg_fail(1)) SWIG_fail;
20792     {
20793         PyThreadState* __tstate = wxPyBeginAllowThreads();
20794         result = (int)(arg1)->GetQuality();
20795
20796         wxPyEndAllowThreads(__tstate);
20797         if (PyErr_Occurred()) SWIG_fail;
20798     }
20799     {
20800         resultobj = SWIG_From_int((int)(result));
20801     }
20802     return resultobj;
20803     fail:
20804     return NULL;
20805 }
20806
20807
20808 static PyObject *_wrap_PrintData_GetBin(PyObject *, PyObject *args, PyObject *kwargs) {
20809     PyObject *resultobj;
20810     wxPrintData *arg1 = (wxPrintData *) 0 ;
20811     wxPrintBin result;
20812     PyObject * obj0 = 0 ;
20813     char *kwnames[] = {
20814         (char *) "self", NULL
20815     };
20816
20817     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetBin",kwnames,&obj0)) goto fail;
20818     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20819     if (SWIG_arg_fail(1)) SWIG_fail;
20820     {
20821         PyThreadState* __tstate = wxPyBeginAllowThreads();
20822         result = (wxPrintBin)(arg1)->GetBin();
20823
20824         wxPyEndAllowThreads(__tstate);
20825         if (PyErr_Occurred()) SWIG_fail;
20826     }
20827     resultobj = SWIG_From_int((result));
20828     return resultobj;
20829     fail:
20830     return NULL;
20831 }
20832
20833
20834 static PyObject *_wrap_PrintData_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
20835     PyObject *resultobj;
20836     wxPrintData *arg1 = (wxPrintData *) 0 ;
20837     wxPrintMode result;
20838     PyObject * obj0 = 0 ;
20839     char *kwnames[] = {
20840         (char *) "self", NULL
20841     };
20842
20843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrintMode",kwnames,&obj0)) goto fail;
20844     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20845     if (SWIG_arg_fail(1)) SWIG_fail;
20846     {
20847         PyThreadState* __tstate = wxPyBeginAllowThreads();
20848         result = (wxPrintMode)((wxPrintData const *)arg1)->GetPrintMode();
20849
20850         wxPyEndAllowThreads(__tstate);
20851         if (PyErr_Occurred()) SWIG_fail;
20852     }
20853     resultobj = SWIG_From_int((result));
20854     return resultobj;
20855     fail:
20856     return NULL;
20857 }
20858
20859
20860 static PyObject *_wrap_PrintData_SetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
20861     PyObject *resultobj;
20862     wxPrintData *arg1 = (wxPrintData *) 0 ;
20863     int arg2 ;
20864     PyObject * obj0 = 0 ;
20865     PyObject * obj1 = 0 ;
20866     char *kwnames[] = {
20867         (char *) "self",(char *) "v", NULL
20868     };
20869
20870     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetNoCopies",kwnames,&obj0,&obj1)) goto fail;
20871     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20872     if (SWIG_arg_fail(1)) SWIG_fail;
20873     {
20874         arg2 = (int)(SWIG_As_int(obj1));
20875         if (SWIG_arg_fail(2)) SWIG_fail;
20876     }
20877     {
20878         PyThreadState* __tstate = wxPyBeginAllowThreads();
20879         (arg1)->SetNoCopies(arg2);
20880
20881         wxPyEndAllowThreads(__tstate);
20882         if (PyErr_Occurred()) SWIG_fail;
20883     }
20884     Py_INCREF(Py_None); resultobj = Py_None;
20885     return resultobj;
20886     fail:
20887     return NULL;
20888 }
20889
20890
20891 static PyObject *_wrap_PrintData_SetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
20892     PyObject *resultobj;
20893     wxPrintData *arg1 = (wxPrintData *) 0 ;
20894     bool arg2 ;
20895     PyObject * obj0 = 0 ;
20896     PyObject * obj1 = 0 ;
20897     char *kwnames[] = {
20898         (char *) "self",(char *) "flag", NULL
20899     };
20900
20901     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetCollate",kwnames,&obj0,&obj1)) goto fail;
20902     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20903     if (SWIG_arg_fail(1)) SWIG_fail;
20904     {
20905         arg2 = (bool)(SWIG_As_bool(obj1));
20906         if (SWIG_arg_fail(2)) SWIG_fail;
20907     }
20908     {
20909         PyThreadState* __tstate = wxPyBeginAllowThreads();
20910         (arg1)->SetCollate(arg2);
20911
20912         wxPyEndAllowThreads(__tstate);
20913         if (PyErr_Occurred()) SWIG_fail;
20914     }
20915     Py_INCREF(Py_None); resultobj = Py_None;
20916     return resultobj;
20917     fail:
20918     return NULL;
20919 }
20920
20921
20922 static PyObject *_wrap_PrintData_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
20923     PyObject *resultobj;
20924     wxPrintData *arg1 = (wxPrintData *) 0 ;
20925     int arg2 ;
20926     PyObject * obj0 = 0 ;
20927     PyObject * obj1 = 0 ;
20928     char *kwnames[] = {
20929         (char *) "self",(char *) "orient", NULL
20930     };
20931
20932     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
20933     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20934     if (SWIG_arg_fail(1)) SWIG_fail;
20935     {
20936         arg2 = (int)(SWIG_As_int(obj1));
20937         if (SWIG_arg_fail(2)) SWIG_fail;
20938     }
20939     {
20940         PyThreadState* __tstate = wxPyBeginAllowThreads();
20941         (arg1)->SetOrientation(arg2);
20942
20943         wxPyEndAllowThreads(__tstate);
20944         if (PyErr_Occurred()) SWIG_fail;
20945     }
20946     Py_INCREF(Py_None); resultobj = Py_None;
20947     return resultobj;
20948     fail:
20949     return NULL;
20950 }
20951
20952
20953 static PyObject *_wrap_PrintData_SetPrinterName(PyObject *, PyObject *args, PyObject *kwargs) {
20954     PyObject *resultobj;
20955     wxPrintData *arg1 = (wxPrintData *) 0 ;
20956     wxString *arg2 = 0 ;
20957     bool temp2 = false ;
20958     PyObject * obj0 = 0 ;
20959     PyObject * obj1 = 0 ;
20960     char *kwnames[] = {
20961         (char *) "self",(char *) "name", NULL
20962     };
20963
20964     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterName",kwnames,&obj0,&obj1)) goto fail;
20965     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20966     if (SWIG_arg_fail(1)) SWIG_fail;
20967     {
20968         arg2 = wxString_in_helper(obj1);
20969         if (arg2 == NULL) SWIG_fail;
20970         temp2 = true;
20971     }
20972     {
20973         PyThreadState* __tstate = wxPyBeginAllowThreads();
20974         (arg1)->SetPrinterName((wxString const &)*arg2);
20975
20976         wxPyEndAllowThreads(__tstate);
20977         if (PyErr_Occurred()) SWIG_fail;
20978     }
20979     Py_INCREF(Py_None); resultobj = Py_None;
20980     {
20981         if (temp2)
20982         delete arg2;
20983     }
20984     return resultobj;
20985     fail:
20986     {
20987         if (temp2)
20988         delete arg2;
20989     }
20990     return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_PrintData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
20995     PyObject *resultobj;
20996     wxPrintData *arg1 = (wxPrintData *) 0 ;
20997     bool arg2 ;
20998     PyObject * obj0 = 0 ;
20999     PyObject * obj1 = 0 ;
21000     char *kwnames[] = {
21001         (char *) "self",(char *) "colour", NULL
21002     };
21003
21004     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetColour",kwnames,&obj0,&obj1)) goto fail;
21005     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21006     if (SWIG_arg_fail(1)) SWIG_fail;
21007     {
21008         arg2 = (bool)(SWIG_As_bool(obj1));
21009         if (SWIG_arg_fail(2)) SWIG_fail;
21010     }
21011     {
21012         PyThreadState* __tstate = wxPyBeginAllowThreads();
21013         (arg1)->SetColour(arg2);
21014
21015         wxPyEndAllowThreads(__tstate);
21016         if (PyErr_Occurred()) SWIG_fail;
21017     }
21018     Py_INCREF(Py_None); resultobj = Py_None;
21019     return resultobj;
21020     fail:
21021     return NULL;
21022 }
21023
21024
21025 static PyObject *_wrap_PrintData_SetDuplex(PyObject *, PyObject *args, PyObject *kwargs) {
21026     PyObject *resultobj;
21027     wxPrintData *arg1 = (wxPrintData *) 0 ;
21028     wxDuplexMode arg2 ;
21029     PyObject * obj0 = 0 ;
21030     PyObject * obj1 = 0 ;
21031     char *kwnames[] = {
21032         (char *) "self",(char *) "duplex", NULL
21033     };
21034
21035     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetDuplex",kwnames,&obj0,&obj1)) goto fail;
21036     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21037     if (SWIG_arg_fail(1)) SWIG_fail;
21038     {
21039         arg2 = (wxDuplexMode)(SWIG_As_int(obj1));
21040         if (SWIG_arg_fail(2)) SWIG_fail;
21041     }
21042     {
21043         PyThreadState* __tstate = wxPyBeginAllowThreads();
21044         (arg1)->SetDuplex((wxDuplexMode )arg2);
21045
21046         wxPyEndAllowThreads(__tstate);
21047         if (PyErr_Occurred()) SWIG_fail;
21048     }
21049     Py_INCREF(Py_None); resultobj = Py_None;
21050     return resultobj;
21051     fail:
21052     return NULL;
21053 }
21054
21055
21056 static PyObject *_wrap_PrintData_SetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
21057     PyObject *resultobj;
21058     wxPrintData *arg1 = (wxPrintData *) 0 ;
21059     wxPaperSize arg2 ;
21060     PyObject * obj0 = 0 ;
21061     PyObject * obj1 = 0 ;
21062     char *kwnames[] = {
21063         (char *) "self",(char *) "sizeId", NULL
21064     };
21065
21066     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPaperId",kwnames,&obj0,&obj1)) goto fail;
21067     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21068     if (SWIG_arg_fail(1)) SWIG_fail;
21069     {
21070         arg2 = (wxPaperSize)(SWIG_As_int(obj1));
21071         if (SWIG_arg_fail(2)) SWIG_fail;
21072     }
21073     {
21074         PyThreadState* __tstate = wxPyBeginAllowThreads();
21075         (arg1)->SetPaperId((wxPaperSize )arg2);
21076
21077         wxPyEndAllowThreads(__tstate);
21078         if (PyErr_Occurred()) SWIG_fail;
21079     }
21080     Py_INCREF(Py_None); resultobj = Py_None;
21081     return resultobj;
21082     fail:
21083     return NULL;
21084 }
21085
21086
21087 static PyObject *_wrap_PrintData_SetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
21088     PyObject *resultobj;
21089     wxPrintData *arg1 = (wxPrintData *) 0 ;
21090     wxSize *arg2 = 0 ;
21091     wxSize temp2 ;
21092     PyObject * obj0 = 0 ;
21093     PyObject * obj1 = 0 ;
21094     char *kwnames[] = {
21095         (char *) "self",(char *) "sz", NULL
21096     };
21097
21098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPaperSize",kwnames,&obj0,&obj1)) goto fail;
21099     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21100     if (SWIG_arg_fail(1)) SWIG_fail;
21101     {
21102         arg2 = &temp2;
21103         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
21104     }
21105     {
21106         PyThreadState* __tstate = wxPyBeginAllowThreads();
21107         (arg1)->SetPaperSize((wxSize const &)*arg2);
21108
21109         wxPyEndAllowThreads(__tstate);
21110         if (PyErr_Occurred()) SWIG_fail;
21111     }
21112     Py_INCREF(Py_None); resultobj = Py_None;
21113     return resultobj;
21114     fail:
21115     return NULL;
21116 }
21117
21118
21119 static PyObject *_wrap_PrintData_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
21120     PyObject *resultobj;
21121     wxPrintData *arg1 = (wxPrintData *) 0 ;
21122     int arg2 ;
21123     PyObject * obj0 = 0 ;
21124     PyObject * obj1 = 0 ;
21125     char *kwnames[] = {
21126         (char *) "self",(char *) "quality", NULL
21127     };
21128
21129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetQuality",kwnames,&obj0,&obj1)) goto fail;
21130     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21131     if (SWIG_arg_fail(1)) SWIG_fail;
21132     {
21133         arg2 = (int)(SWIG_As_int(obj1));
21134         if (SWIG_arg_fail(2)) SWIG_fail;
21135     }
21136     {
21137         PyThreadState* __tstate = wxPyBeginAllowThreads();
21138         (arg1)->SetQuality(arg2);
21139
21140         wxPyEndAllowThreads(__tstate);
21141         if (PyErr_Occurred()) SWIG_fail;
21142     }
21143     Py_INCREF(Py_None); resultobj = Py_None;
21144     return resultobj;
21145     fail:
21146     return NULL;
21147 }
21148
21149
21150 static PyObject *_wrap_PrintData_SetBin(PyObject *, PyObject *args, PyObject *kwargs) {
21151     PyObject *resultobj;
21152     wxPrintData *arg1 = (wxPrintData *) 0 ;
21153     wxPrintBin arg2 ;
21154     PyObject * obj0 = 0 ;
21155     PyObject * obj1 = 0 ;
21156     char *kwnames[] = {
21157         (char *) "self",(char *) "bin", NULL
21158     };
21159
21160     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetBin",kwnames,&obj0,&obj1)) goto fail;
21161     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21162     if (SWIG_arg_fail(1)) SWIG_fail;
21163     {
21164         arg2 = (wxPrintBin)(SWIG_As_int(obj1));
21165         if (SWIG_arg_fail(2)) SWIG_fail;
21166     }
21167     {
21168         PyThreadState* __tstate = wxPyBeginAllowThreads();
21169         (arg1)->SetBin((wxPrintBin )arg2);
21170
21171         wxPyEndAllowThreads(__tstate);
21172         if (PyErr_Occurred()) SWIG_fail;
21173     }
21174     Py_INCREF(Py_None); resultobj = Py_None;
21175     return resultobj;
21176     fail:
21177     return NULL;
21178 }
21179
21180
21181 static PyObject *_wrap_PrintData_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
21182     PyObject *resultobj;
21183     wxPrintData *arg1 = (wxPrintData *) 0 ;
21184     wxPrintMode arg2 ;
21185     PyObject * obj0 = 0 ;
21186     PyObject * obj1 = 0 ;
21187     char *kwnames[] = {
21188         (char *) "self",(char *) "printMode", NULL
21189     };
21190
21191     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
21192     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21193     if (SWIG_arg_fail(1)) SWIG_fail;
21194     {
21195         arg2 = (wxPrintMode)(SWIG_As_int(obj1));
21196         if (SWIG_arg_fail(2)) SWIG_fail;
21197     }
21198     {
21199         PyThreadState* __tstate = wxPyBeginAllowThreads();
21200         (arg1)->SetPrintMode((wxPrintMode )arg2);
21201
21202         wxPyEndAllowThreads(__tstate);
21203         if (PyErr_Occurred()) SWIG_fail;
21204     }
21205     Py_INCREF(Py_None); resultobj = Py_None;
21206     return resultobj;
21207     fail:
21208     return NULL;
21209 }
21210
21211
21212 static PyObject *_wrap_PrintData_GetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
21213     PyObject *resultobj;
21214     wxPrintData *arg1 = (wxPrintData *) 0 ;
21215     wxString result;
21216     PyObject * obj0 = 0 ;
21217     char *kwnames[] = {
21218         (char *) "self", NULL
21219     };
21220
21221     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetFilename",kwnames,&obj0)) goto fail;
21222     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21223     if (SWIG_arg_fail(1)) SWIG_fail;
21224     {
21225         PyThreadState* __tstate = wxPyBeginAllowThreads();
21226         result = ((wxPrintData const *)arg1)->GetFilename();
21227
21228         wxPyEndAllowThreads(__tstate);
21229         if (PyErr_Occurred()) SWIG_fail;
21230     }
21231     {
21232 #if wxUSE_UNICODE
21233         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21234 #else
21235         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21236 #endif
21237     }
21238     return resultobj;
21239     fail:
21240     return NULL;
21241 }
21242
21243
21244 static PyObject *_wrap_PrintData_SetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
21245     PyObject *resultobj;
21246     wxPrintData *arg1 = (wxPrintData *) 0 ;
21247     wxString *arg2 = 0 ;
21248     bool temp2 = false ;
21249     PyObject * obj0 = 0 ;
21250     PyObject * obj1 = 0 ;
21251     char *kwnames[] = {
21252         (char *) "self",(char *) "filename", NULL
21253     };
21254
21255     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetFilename",kwnames,&obj0,&obj1)) goto fail;
21256     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21257     if (SWIG_arg_fail(1)) SWIG_fail;
21258     {
21259         arg2 = wxString_in_helper(obj1);
21260         if (arg2 == NULL) SWIG_fail;
21261         temp2 = true;
21262     }
21263     {
21264         PyThreadState* __tstate = wxPyBeginAllowThreads();
21265         (arg1)->SetFilename((wxString const &)*arg2);
21266
21267         wxPyEndAllowThreads(__tstate);
21268         if (PyErr_Occurred()) SWIG_fail;
21269     }
21270     Py_INCREF(Py_None); resultobj = Py_None;
21271     {
21272         if (temp2)
21273         delete arg2;
21274     }
21275     return resultobj;
21276     fail:
21277     {
21278         if (temp2)
21279         delete arg2;
21280     }
21281     return NULL;
21282 }
21283
21284
21285 static PyObject *_wrap_PrintData_GetPrivData(PyObject *, PyObject *args, PyObject *kwargs) {
21286     PyObject *resultobj;
21287     wxPrintData *arg1 = (wxPrintData *) 0 ;
21288     PyObject *result;
21289     PyObject * obj0 = 0 ;
21290     char *kwnames[] = {
21291         (char *) "self", NULL
21292     };
21293
21294     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrivData",kwnames,&obj0)) goto fail;
21295     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21296     if (SWIG_arg_fail(1)) SWIG_fail;
21297     {
21298         PyThreadState* __tstate = wxPyBeginAllowThreads();
21299         result = (PyObject *)wxPrintData_GetPrivData(arg1);
21300
21301         wxPyEndAllowThreads(__tstate);
21302         if (PyErr_Occurred()) SWIG_fail;
21303     }
21304     resultobj = result;
21305     return resultobj;
21306     fail:
21307     return NULL;
21308 }
21309
21310
21311 static PyObject *_wrap_PrintData_SetPrivData(PyObject *, PyObject *args, PyObject *kwargs) {
21312     PyObject *resultobj;
21313     wxPrintData *arg1 = (wxPrintData *) 0 ;
21314     PyObject *arg2 = (PyObject *) 0 ;
21315     PyObject * obj0 = 0 ;
21316     PyObject * obj1 = 0 ;
21317     char *kwnames[] = {
21318         (char *) "self",(char *) "data", NULL
21319     };
21320
21321     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrivData",kwnames,&obj0,&obj1)) goto fail;
21322     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21323     if (SWIG_arg_fail(1)) SWIG_fail;
21324     arg2 = obj1;
21325     {
21326         PyThreadState* __tstate = wxPyBeginAllowThreads();
21327         wxPrintData_SetPrivData(arg1,arg2);
21328
21329         wxPyEndAllowThreads(__tstate);
21330         if (PyErr_Occurred()) SWIG_fail;
21331     }
21332     Py_INCREF(Py_None); resultobj = Py_None;
21333     return resultobj;
21334     fail:
21335     return NULL;
21336 }
21337
21338
21339 static PyObject *_wrap_PrintData_GetPrinterCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21340     PyObject *resultobj;
21341     wxPrintData *arg1 = (wxPrintData *) 0 ;
21342     wxString *result;
21343     PyObject * obj0 = 0 ;
21344     char *kwnames[] = {
21345         (char *) "self", NULL
21346     };
21347
21348     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterCommand",kwnames,&obj0)) goto fail;
21349     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21350     if (SWIG_arg_fail(1)) SWIG_fail;
21351     {
21352         PyThreadState* __tstate = wxPyBeginAllowThreads();
21353         {
21354             wxString const &_result_ref = (arg1)->GetPrinterCommand();
21355             result = (wxString *) &_result_ref;
21356         }
21357
21358         wxPyEndAllowThreads(__tstate);
21359         if (PyErr_Occurred()) SWIG_fail;
21360     }
21361     {
21362 #if wxUSE_UNICODE
21363         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21364 #else
21365         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21366 #endif
21367     }
21368     return resultobj;
21369     fail:
21370     return NULL;
21371 }
21372
21373
21374 static PyObject *_wrap_PrintData_GetPrinterOptions(PyObject *, PyObject *args, PyObject *kwargs) {
21375     PyObject *resultobj;
21376     wxPrintData *arg1 = (wxPrintData *) 0 ;
21377     wxString *result;
21378     PyObject * obj0 = 0 ;
21379     char *kwnames[] = {
21380         (char *) "self", NULL
21381     };
21382
21383     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterOptions",kwnames,&obj0)) goto fail;
21384     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21385     if (SWIG_arg_fail(1)) SWIG_fail;
21386     {
21387         PyThreadState* __tstate = wxPyBeginAllowThreads();
21388         {
21389             wxString const &_result_ref = (arg1)->GetPrinterOptions();
21390             result = (wxString *) &_result_ref;
21391         }
21392
21393         wxPyEndAllowThreads(__tstate);
21394         if (PyErr_Occurred()) SWIG_fail;
21395     }
21396     {
21397 #if wxUSE_UNICODE
21398         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21399 #else
21400         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21401 #endif
21402     }
21403     return resultobj;
21404     fail:
21405     return NULL;
21406 }
21407
21408
21409 static PyObject *_wrap_PrintData_GetPreviewCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21410     PyObject *resultobj;
21411     wxPrintData *arg1 = (wxPrintData *) 0 ;
21412     wxString *result;
21413     PyObject * obj0 = 0 ;
21414     char *kwnames[] = {
21415         (char *) "self", NULL
21416     };
21417
21418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPreviewCommand",kwnames,&obj0)) goto fail;
21419     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21420     if (SWIG_arg_fail(1)) SWIG_fail;
21421     {
21422         PyThreadState* __tstate = wxPyBeginAllowThreads();
21423         {
21424             wxString const &_result_ref = (arg1)->GetPreviewCommand();
21425             result = (wxString *) &_result_ref;
21426         }
21427
21428         wxPyEndAllowThreads(__tstate);
21429         if (PyErr_Occurred()) SWIG_fail;
21430     }
21431     {
21432 #if wxUSE_UNICODE
21433         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21434 #else
21435         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21436 #endif
21437     }
21438     return resultobj;
21439     fail:
21440     return NULL;
21441 }
21442
21443
21444 static PyObject *_wrap_PrintData_GetFontMetricPath(PyObject *, PyObject *args, PyObject *kwargs) {
21445     PyObject *resultobj;
21446     wxPrintData *arg1 = (wxPrintData *) 0 ;
21447     wxString *result;
21448     PyObject * obj0 = 0 ;
21449     char *kwnames[] = {
21450         (char *) "self", NULL
21451     };
21452
21453     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetFontMetricPath",kwnames,&obj0)) goto fail;
21454     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21455     if (SWIG_arg_fail(1)) SWIG_fail;
21456     {
21457         PyThreadState* __tstate = wxPyBeginAllowThreads();
21458         {
21459             wxString const &_result_ref = (arg1)->GetFontMetricPath();
21460             result = (wxString *) &_result_ref;
21461         }
21462
21463         wxPyEndAllowThreads(__tstate);
21464         if (PyErr_Occurred()) SWIG_fail;
21465     }
21466     {
21467 #if wxUSE_UNICODE
21468         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21469 #else
21470         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21471 #endif
21472     }
21473     return resultobj;
21474     fail:
21475     return NULL;
21476 }
21477
21478
21479 static PyObject *_wrap_PrintData_GetPrinterScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
21480     PyObject *resultobj;
21481     wxPrintData *arg1 = (wxPrintData *) 0 ;
21482     double result;
21483     PyObject * obj0 = 0 ;
21484     char *kwnames[] = {
21485         (char *) "self", NULL
21486     };
21487
21488     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterScaleX",kwnames,&obj0)) goto fail;
21489     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21490     if (SWIG_arg_fail(1)) SWIG_fail;
21491     {
21492         PyThreadState* __tstate = wxPyBeginAllowThreads();
21493         result = (double)(arg1)->GetPrinterScaleX();
21494
21495         wxPyEndAllowThreads(__tstate);
21496         if (PyErr_Occurred()) SWIG_fail;
21497     }
21498     {
21499         resultobj = SWIG_From_double((double)(result));
21500     }
21501     return resultobj;
21502     fail:
21503     return NULL;
21504 }
21505
21506
21507 static PyObject *_wrap_PrintData_GetPrinterScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
21508     PyObject *resultobj;
21509     wxPrintData *arg1 = (wxPrintData *) 0 ;
21510     double result;
21511     PyObject * obj0 = 0 ;
21512     char *kwnames[] = {
21513         (char *) "self", NULL
21514     };
21515
21516     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterScaleY",kwnames,&obj0)) goto fail;
21517     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21518     if (SWIG_arg_fail(1)) SWIG_fail;
21519     {
21520         PyThreadState* __tstate = wxPyBeginAllowThreads();
21521         result = (double)(arg1)->GetPrinterScaleY();
21522
21523         wxPyEndAllowThreads(__tstate);
21524         if (PyErr_Occurred()) SWIG_fail;
21525     }
21526     {
21527         resultobj = SWIG_From_double((double)(result));
21528     }
21529     return resultobj;
21530     fail:
21531     return NULL;
21532 }
21533
21534
21535 static PyObject *_wrap_PrintData_GetPrinterTranslateX(PyObject *, PyObject *args, PyObject *kwargs) {
21536     PyObject *resultobj;
21537     wxPrintData *arg1 = (wxPrintData *) 0 ;
21538     long result;
21539     PyObject * obj0 = 0 ;
21540     char *kwnames[] = {
21541         (char *) "self", NULL
21542     };
21543
21544     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterTranslateX",kwnames,&obj0)) goto fail;
21545     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21546     if (SWIG_arg_fail(1)) SWIG_fail;
21547     {
21548         PyThreadState* __tstate = wxPyBeginAllowThreads();
21549         result = (long)(arg1)->GetPrinterTranslateX();
21550
21551         wxPyEndAllowThreads(__tstate);
21552         if (PyErr_Occurred()) SWIG_fail;
21553     }
21554     {
21555         resultobj = SWIG_From_long((long)(result));
21556     }
21557     return resultobj;
21558     fail:
21559     return NULL;
21560 }
21561
21562
21563 static PyObject *_wrap_PrintData_GetPrinterTranslateY(PyObject *, PyObject *args, PyObject *kwargs) {
21564     PyObject *resultobj;
21565     wxPrintData *arg1 = (wxPrintData *) 0 ;
21566     long result;
21567     PyObject * obj0 = 0 ;
21568     char *kwnames[] = {
21569         (char *) "self", NULL
21570     };
21571
21572     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterTranslateY",kwnames,&obj0)) goto fail;
21573     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21574     if (SWIG_arg_fail(1)) SWIG_fail;
21575     {
21576         PyThreadState* __tstate = wxPyBeginAllowThreads();
21577         result = (long)(arg1)->GetPrinterTranslateY();
21578
21579         wxPyEndAllowThreads(__tstate);
21580         if (PyErr_Occurred()) SWIG_fail;
21581     }
21582     {
21583         resultobj = SWIG_From_long((long)(result));
21584     }
21585     return resultobj;
21586     fail:
21587     return NULL;
21588 }
21589
21590
21591 static PyObject *_wrap_PrintData_SetPrinterCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21592     PyObject *resultobj;
21593     wxPrintData *arg1 = (wxPrintData *) 0 ;
21594     wxString *arg2 = 0 ;
21595     bool temp2 = false ;
21596     PyObject * obj0 = 0 ;
21597     PyObject * obj1 = 0 ;
21598     char *kwnames[] = {
21599         (char *) "self",(char *) "command", NULL
21600     };
21601
21602     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterCommand",kwnames,&obj0,&obj1)) goto fail;
21603     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21604     if (SWIG_arg_fail(1)) SWIG_fail;
21605     {
21606         arg2 = wxString_in_helper(obj1);
21607         if (arg2 == NULL) SWIG_fail;
21608         temp2 = true;
21609     }
21610     {
21611         PyThreadState* __tstate = wxPyBeginAllowThreads();
21612         (arg1)->SetPrinterCommand((wxString const &)*arg2);
21613
21614         wxPyEndAllowThreads(__tstate);
21615         if (PyErr_Occurred()) SWIG_fail;
21616     }
21617     Py_INCREF(Py_None); resultobj = Py_None;
21618     {
21619         if (temp2)
21620         delete arg2;
21621     }
21622     return resultobj;
21623     fail:
21624     {
21625         if (temp2)
21626         delete arg2;
21627     }
21628     return NULL;
21629 }
21630
21631
21632 static PyObject *_wrap_PrintData_SetPrinterOptions(PyObject *, PyObject *args, PyObject *kwargs) {
21633     PyObject *resultobj;
21634     wxPrintData *arg1 = (wxPrintData *) 0 ;
21635     wxString *arg2 = 0 ;
21636     bool temp2 = false ;
21637     PyObject * obj0 = 0 ;
21638     PyObject * obj1 = 0 ;
21639     char *kwnames[] = {
21640         (char *) "self",(char *) "options", NULL
21641     };
21642
21643     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterOptions",kwnames,&obj0,&obj1)) goto fail;
21644     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21645     if (SWIG_arg_fail(1)) SWIG_fail;
21646     {
21647         arg2 = wxString_in_helper(obj1);
21648         if (arg2 == NULL) SWIG_fail;
21649         temp2 = true;
21650     }
21651     {
21652         PyThreadState* __tstate = wxPyBeginAllowThreads();
21653         (arg1)->SetPrinterOptions((wxString const &)*arg2);
21654
21655         wxPyEndAllowThreads(__tstate);
21656         if (PyErr_Occurred()) SWIG_fail;
21657     }
21658     Py_INCREF(Py_None); resultobj = Py_None;
21659     {
21660         if (temp2)
21661         delete arg2;
21662     }
21663     return resultobj;
21664     fail:
21665     {
21666         if (temp2)
21667         delete arg2;
21668     }
21669     return NULL;
21670 }
21671
21672
21673 static PyObject *_wrap_PrintData_SetPreviewCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21674     PyObject *resultobj;
21675     wxPrintData *arg1 = (wxPrintData *) 0 ;
21676     wxString *arg2 = 0 ;
21677     bool temp2 = false ;
21678     PyObject * obj0 = 0 ;
21679     PyObject * obj1 = 0 ;
21680     char *kwnames[] = {
21681         (char *) "self",(char *) "command", NULL
21682     };
21683
21684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPreviewCommand",kwnames,&obj0,&obj1)) goto fail;
21685     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21686     if (SWIG_arg_fail(1)) SWIG_fail;
21687     {
21688         arg2 = wxString_in_helper(obj1);
21689         if (arg2 == NULL) SWIG_fail;
21690         temp2 = true;
21691     }
21692     {
21693         PyThreadState* __tstate = wxPyBeginAllowThreads();
21694         (arg1)->SetPreviewCommand((wxString const &)*arg2);
21695
21696         wxPyEndAllowThreads(__tstate);
21697         if (PyErr_Occurred()) SWIG_fail;
21698     }
21699     Py_INCREF(Py_None); resultobj = Py_None;
21700     {
21701         if (temp2)
21702         delete arg2;
21703     }
21704     return resultobj;
21705     fail:
21706     {
21707         if (temp2)
21708         delete arg2;
21709     }
21710     return NULL;
21711 }
21712
21713
21714 static PyObject *_wrap_PrintData_SetFontMetricPath(PyObject *, PyObject *args, PyObject *kwargs) {
21715     PyObject *resultobj;
21716     wxPrintData *arg1 = (wxPrintData *) 0 ;
21717     wxString *arg2 = 0 ;
21718     bool temp2 = false ;
21719     PyObject * obj0 = 0 ;
21720     PyObject * obj1 = 0 ;
21721     char *kwnames[] = {
21722         (char *) "self",(char *) "path", NULL
21723     };
21724
21725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetFontMetricPath",kwnames,&obj0,&obj1)) goto fail;
21726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21727     if (SWIG_arg_fail(1)) SWIG_fail;
21728     {
21729         arg2 = wxString_in_helper(obj1);
21730         if (arg2 == NULL) SWIG_fail;
21731         temp2 = true;
21732     }
21733     {
21734         PyThreadState* __tstate = wxPyBeginAllowThreads();
21735         (arg1)->SetFontMetricPath((wxString const &)*arg2);
21736
21737         wxPyEndAllowThreads(__tstate);
21738         if (PyErr_Occurred()) SWIG_fail;
21739     }
21740     Py_INCREF(Py_None); resultobj = Py_None;
21741     {
21742         if (temp2)
21743         delete arg2;
21744     }
21745     return resultobj;
21746     fail:
21747     {
21748         if (temp2)
21749         delete arg2;
21750     }
21751     return NULL;
21752 }
21753
21754
21755 static PyObject *_wrap_PrintData_SetPrinterScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
21756     PyObject *resultobj;
21757     wxPrintData *arg1 = (wxPrintData *) 0 ;
21758     double arg2 ;
21759     PyObject * obj0 = 0 ;
21760     PyObject * obj1 = 0 ;
21761     char *kwnames[] = {
21762         (char *) "self",(char *) "x", NULL
21763     };
21764
21765     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterScaleX",kwnames,&obj0,&obj1)) goto fail;
21766     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21767     if (SWIG_arg_fail(1)) SWIG_fail;
21768     {
21769         arg2 = (double)(SWIG_As_double(obj1));
21770         if (SWIG_arg_fail(2)) SWIG_fail;
21771     }
21772     {
21773         PyThreadState* __tstate = wxPyBeginAllowThreads();
21774         (arg1)->SetPrinterScaleX(arg2);
21775
21776         wxPyEndAllowThreads(__tstate);
21777         if (PyErr_Occurred()) SWIG_fail;
21778     }
21779     Py_INCREF(Py_None); resultobj = Py_None;
21780     return resultobj;
21781     fail:
21782     return NULL;
21783 }
21784
21785
21786 static PyObject *_wrap_PrintData_SetPrinterScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
21787     PyObject *resultobj;
21788     wxPrintData *arg1 = (wxPrintData *) 0 ;
21789     double arg2 ;
21790     PyObject * obj0 = 0 ;
21791     PyObject * obj1 = 0 ;
21792     char *kwnames[] = {
21793         (char *) "self",(char *) "y", NULL
21794     };
21795
21796     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterScaleY",kwnames,&obj0,&obj1)) goto fail;
21797     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21798     if (SWIG_arg_fail(1)) SWIG_fail;
21799     {
21800         arg2 = (double)(SWIG_As_double(obj1));
21801         if (SWIG_arg_fail(2)) SWIG_fail;
21802     }
21803     {
21804         PyThreadState* __tstate = wxPyBeginAllowThreads();
21805         (arg1)->SetPrinterScaleY(arg2);
21806
21807         wxPyEndAllowThreads(__tstate);
21808         if (PyErr_Occurred()) SWIG_fail;
21809     }
21810     Py_INCREF(Py_None); resultobj = Py_None;
21811     return resultobj;
21812     fail:
21813     return NULL;
21814 }
21815
21816
21817 static PyObject *_wrap_PrintData_SetPrinterScaling(PyObject *, PyObject *args, PyObject *kwargs) {
21818     PyObject *resultobj;
21819     wxPrintData *arg1 = (wxPrintData *) 0 ;
21820     double arg2 ;
21821     double arg3 ;
21822     PyObject * obj0 = 0 ;
21823     PyObject * obj1 = 0 ;
21824     PyObject * obj2 = 0 ;
21825     char *kwnames[] = {
21826         (char *) "self",(char *) "x",(char *) "y", NULL
21827     };
21828
21829     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintData_SetPrinterScaling",kwnames,&obj0,&obj1,&obj2)) goto fail;
21830     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21831     if (SWIG_arg_fail(1)) SWIG_fail;
21832     {
21833         arg2 = (double)(SWIG_As_double(obj1));
21834         if (SWIG_arg_fail(2)) SWIG_fail;
21835     }
21836     {
21837         arg3 = (double)(SWIG_As_double(obj2));
21838         if (SWIG_arg_fail(3)) SWIG_fail;
21839     }
21840     {
21841         PyThreadState* __tstate = wxPyBeginAllowThreads();
21842         (arg1)->SetPrinterScaling(arg2,arg3);
21843
21844         wxPyEndAllowThreads(__tstate);
21845         if (PyErr_Occurred()) SWIG_fail;
21846     }
21847     Py_INCREF(Py_None); resultobj = Py_None;
21848     return resultobj;
21849     fail:
21850     return NULL;
21851 }
21852
21853
21854 static PyObject *_wrap_PrintData_SetPrinterTranslateX(PyObject *, PyObject *args, PyObject *kwargs) {
21855     PyObject *resultobj;
21856     wxPrintData *arg1 = (wxPrintData *) 0 ;
21857     long arg2 ;
21858     PyObject * obj0 = 0 ;
21859     PyObject * obj1 = 0 ;
21860     char *kwnames[] = {
21861         (char *) "self",(char *) "x", NULL
21862     };
21863
21864     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterTranslateX",kwnames,&obj0,&obj1)) goto fail;
21865     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21866     if (SWIG_arg_fail(1)) SWIG_fail;
21867     {
21868         arg2 = (long)(SWIG_As_long(obj1));
21869         if (SWIG_arg_fail(2)) SWIG_fail;
21870     }
21871     {
21872         PyThreadState* __tstate = wxPyBeginAllowThreads();
21873         (arg1)->SetPrinterTranslateX(arg2);
21874
21875         wxPyEndAllowThreads(__tstate);
21876         if (PyErr_Occurred()) SWIG_fail;
21877     }
21878     Py_INCREF(Py_None); resultobj = Py_None;
21879     return resultobj;
21880     fail:
21881     return NULL;
21882 }
21883
21884
21885 static PyObject *_wrap_PrintData_SetPrinterTranslateY(PyObject *, PyObject *args, PyObject *kwargs) {
21886     PyObject *resultobj;
21887     wxPrintData *arg1 = (wxPrintData *) 0 ;
21888     long arg2 ;
21889     PyObject * obj0 = 0 ;
21890     PyObject * obj1 = 0 ;
21891     char *kwnames[] = {
21892         (char *) "self",(char *) "y", NULL
21893     };
21894
21895     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterTranslateY",kwnames,&obj0,&obj1)) goto fail;
21896     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21897     if (SWIG_arg_fail(1)) SWIG_fail;
21898     {
21899         arg2 = (long)(SWIG_As_long(obj1));
21900         if (SWIG_arg_fail(2)) SWIG_fail;
21901     }
21902     {
21903         PyThreadState* __tstate = wxPyBeginAllowThreads();
21904         (arg1)->SetPrinterTranslateY(arg2);
21905
21906         wxPyEndAllowThreads(__tstate);
21907         if (PyErr_Occurred()) SWIG_fail;
21908     }
21909     Py_INCREF(Py_None); resultobj = Py_None;
21910     return resultobj;
21911     fail:
21912     return NULL;
21913 }
21914
21915
21916 static PyObject *_wrap_PrintData_SetPrinterTranslation(PyObject *, PyObject *args, PyObject *kwargs) {
21917     PyObject *resultobj;
21918     wxPrintData *arg1 = (wxPrintData *) 0 ;
21919     long arg2 ;
21920     long arg3 ;
21921     PyObject * obj0 = 0 ;
21922     PyObject * obj1 = 0 ;
21923     PyObject * obj2 = 0 ;
21924     char *kwnames[] = {
21925         (char *) "self",(char *) "x",(char *) "y", NULL
21926     };
21927
21928     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintData_SetPrinterTranslation",kwnames,&obj0,&obj1,&obj2)) goto fail;
21929     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21930     if (SWIG_arg_fail(1)) SWIG_fail;
21931     {
21932         arg2 = (long)(SWIG_As_long(obj1));
21933         if (SWIG_arg_fail(2)) SWIG_fail;
21934     }
21935     {
21936         arg3 = (long)(SWIG_As_long(obj2));
21937         if (SWIG_arg_fail(3)) SWIG_fail;
21938     }
21939     {
21940         PyThreadState* __tstate = wxPyBeginAllowThreads();
21941         (arg1)->SetPrinterTranslation(arg2,arg3);
21942
21943         wxPyEndAllowThreads(__tstate);
21944         if (PyErr_Occurred()) SWIG_fail;
21945     }
21946     Py_INCREF(Py_None); resultobj = Py_None;
21947     return resultobj;
21948     fail:
21949     return NULL;
21950 }
21951
21952
21953 static PyObject * PrintData_swigregister(PyObject *, PyObject *args) {
21954     PyObject *obj;
21955     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21956     SWIG_TypeClientData(SWIGTYPE_p_wxPrintData, obj);
21957     Py_INCREF(obj);
21958     return Py_BuildValue((char *)"");
21959 }
21960 static PyObject *_wrap_new_PageSetupDialogData__SWIG_0(PyObject *, PyObject *args) {
21961     PyObject *resultobj;
21962     wxPageSetupDialogData *result;
21963
21964     if(!PyArg_ParseTuple(args,(char *)":new_PageSetupDialogData")) goto fail;
21965     {
21966         PyThreadState* __tstate = wxPyBeginAllowThreads();
21967         result = (wxPageSetupDialogData *)new wxPageSetupDialogData();
21968
21969         wxPyEndAllowThreads(__tstate);
21970         if (PyErr_Occurred()) SWIG_fail;
21971     }
21972     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21973     return resultobj;
21974     fail:
21975     return NULL;
21976 }
21977
21978
21979 static PyObject *_wrap_new_PageSetupDialogData__SWIG_1(PyObject *, PyObject *args) {
21980     PyObject *resultobj;
21981     wxPageSetupDialogData *arg1 = 0 ;
21982     wxPageSetupDialogData *result;
21983     PyObject * obj0 = 0 ;
21984
21985     if(!PyArg_ParseTuple(args,(char *)"O:new_PageSetupDialogData",&obj0)) goto fail;
21986     {
21987         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21988         if (SWIG_arg_fail(1)) SWIG_fail;
21989         if (arg1 == NULL) {
21990             SWIG_null_ref("wxPageSetupDialogData");
21991         }
21992         if (SWIG_arg_fail(1)) SWIG_fail;
21993     }
21994     {
21995         PyThreadState* __tstate = wxPyBeginAllowThreads();
21996         result = (wxPageSetupDialogData *)new wxPageSetupDialogData((wxPageSetupDialogData const &)*arg1);
21997
21998         wxPyEndAllowThreads(__tstate);
21999         if (PyErr_Occurred()) SWIG_fail;
22000     }
22001     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
22002     return resultobj;
22003     fail:
22004     return NULL;
22005 }
22006
22007
22008 static PyObject *_wrap_new_PageSetupDialogData__SWIG_2(PyObject *, PyObject *args) {
22009     PyObject *resultobj;
22010     wxPrintData *arg1 = 0 ;
22011     wxPageSetupDialogData *result;
22012     PyObject * obj0 = 0 ;
22013
22014     if(!PyArg_ParseTuple(args,(char *)"O:new_PageSetupDialogData",&obj0)) goto fail;
22015     {
22016         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
22017         if (SWIG_arg_fail(1)) SWIG_fail;
22018         if (arg1 == NULL) {
22019             SWIG_null_ref("wxPrintData");
22020         }
22021         if (SWIG_arg_fail(1)) SWIG_fail;
22022     }
22023     {
22024         PyThreadState* __tstate = wxPyBeginAllowThreads();
22025         result = (wxPageSetupDialogData *)new wxPageSetupDialogData((wxPrintData const &)*arg1);
22026
22027         wxPyEndAllowThreads(__tstate);
22028         if (PyErr_Occurred()) SWIG_fail;
22029     }
22030     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
22031     return resultobj;
22032     fail:
22033     return NULL;
22034 }
22035
22036
22037 static PyObject *_wrap_new_PageSetupDialogData(PyObject *self, PyObject *args) {
22038     int argc;
22039     PyObject *argv[2];
22040     int ii;
22041
22042     argc = PyObject_Length(args);
22043     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
22044         argv[ii] = PyTuple_GetItem(args,ii);
22045     }
22046     if (argc == 0) {
22047         return _wrap_new_PageSetupDialogData__SWIG_0(self,args);
22048     }
22049     if (argc == 1) {
22050         int _v;
22051         {
22052             void *ptr = 0;
22053             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPageSetupDialogData, 0) == -1) {
22054                 _v = 0;
22055                 PyErr_Clear();
22056             } else {
22057                 _v = (ptr != 0);
22058             }
22059         }
22060         if (_v) {
22061             return _wrap_new_PageSetupDialogData__SWIG_1(self,args);
22062         }
22063     }
22064     if (argc == 1) {
22065         int _v;
22066         {
22067             void *ptr = 0;
22068             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
22069                 _v = 0;
22070                 PyErr_Clear();
22071             } else {
22072                 _v = (ptr != 0);
22073             }
22074         }
22075         if (_v) {
22076             return _wrap_new_PageSetupDialogData__SWIG_2(self,args);
22077         }
22078     }
22079
22080     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PageSetupDialogData'");
22081     return NULL;
22082 }
22083
22084
22085 static PyObject *_wrap_delete_PageSetupDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
22086     PyObject *resultobj;
22087     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22088     PyObject * obj0 = 0 ;
22089     char *kwnames[] = {
22090         (char *) "self", NULL
22091     };
22092
22093     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PageSetupDialogData",kwnames,&obj0)) goto fail;
22094     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22095     if (SWIG_arg_fail(1)) SWIG_fail;
22096     {
22097         PyThreadState* __tstate = wxPyBeginAllowThreads();
22098         delete arg1;
22099
22100         wxPyEndAllowThreads(__tstate);
22101         if (PyErr_Occurred()) SWIG_fail;
22102     }
22103     Py_INCREF(Py_None); resultobj = Py_None;
22104     return resultobj;
22105     fail:
22106     return NULL;
22107 }
22108
22109
22110 static PyObject *_wrap_PageSetupDialogData_EnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
22111     PyObject *resultobj;
22112     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22113     bool arg2 ;
22114     PyObject * obj0 = 0 ;
22115     PyObject * obj1 = 0 ;
22116     char *kwnames[] = {
22117         (char *) "self",(char *) "flag", NULL
22118     };
22119
22120     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableHelp",kwnames,&obj0,&obj1)) goto fail;
22121     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22122     if (SWIG_arg_fail(1)) SWIG_fail;
22123     {
22124         arg2 = (bool)(SWIG_As_bool(obj1));
22125         if (SWIG_arg_fail(2)) SWIG_fail;
22126     }
22127     {
22128         PyThreadState* __tstate = wxPyBeginAllowThreads();
22129         (arg1)->EnableHelp(arg2);
22130
22131         wxPyEndAllowThreads(__tstate);
22132         if (PyErr_Occurred()) SWIG_fail;
22133     }
22134     Py_INCREF(Py_None); resultobj = Py_None;
22135     return resultobj;
22136     fail:
22137     return NULL;
22138 }
22139
22140
22141 static PyObject *_wrap_PageSetupDialogData_EnableMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22142     PyObject *resultobj;
22143     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22144     bool arg2 ;
22145     PyObject * obj0 = 0 ;
22146     PyObject * obj1 = 0 ;
22147     char *kwnames[] = {
22148         (char *) "self",(char *) "flag", NULL
22149     };
22150
22151     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableMargins",kwnames,&obj0,&obj1)) goto fail;
22152     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22153     if (SWIG_arg_fail(1)) SWIG_fail;
22154     {
22155         arg2 = (bool)(SWIG_As_bool(obj1));
22156         if (SWIG_arg_fail(2)) SWIG_fail;
22157     }
22158     {
22159         PyThreadState* __tstate = wxPyBeginAllowThreads();
22160         (arg1)->EnableMargins(arg2);
22161
22162         wxPyEndAllowThreads(__tstate);
22163         if (PyErr_Occurred()) SWIG_fail;
22164     }
22165     Py_INCREF(Py_None); resultobj = Py_None;
22166     return resultobj;
22167     fail:
22168     return NULL;
22169 }
22170
22171
22172 static PyObject *_wrap_PageSetupDialogData_EnableOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
22173     PyObject *resultobj;
22174     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22175     bool arg2 ;
22176     PyObject * obj0 = 0 ;
22177     PyObject * obj1 = 0 ;
22178     char *kwnames[] = {
22179         (char *) "self",(char *) "flag", NULL
22180     };
22181
22182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableOrientation",kwnames,&obj0,&obj1)) 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         arg2 = (bool)(SWIG_As_bool(obj1));
22187         if (SWIG_arg_fail(2)) SWIG_fail;
22188     }
22189     {
22190         PyThreadState* __tstate = wxPyBeginAllowThreads();
22191         (arg1)->EnableOrientation(arg2);
22192
22193         wxPyEndAllowThreads(__tstate);
22194         if (PyErr_Occurred()) SWIG_fail;
22195     }
22196     Py_INCREF(Py_None); resultobj = Py_None;
22197     return resultobj;
22198     fail:
22199     return NULL;
22200 }
22201
22202
22203 static PyObject *_wrap_PageSetupDialogData_EnablePaper(PyObject *, PyObject *args, PyObject *kwargs) {
22204     PyObject *resultobj;
22205     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22206     bool arg2 ;
22207     PyObject * obj0 = 0 ;
22208     PyObject * obj1 = 0 ;
22209     char *kwnames[] = {
22210         (char *) "self",(char *) "flag", NULL
22211     };
22212
22213     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnablePaper",kwnames,&obj0,&obj1)) goto fail;
22214     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22215     if (SWIG_arg_fail(1)) SWIG_fail;
22216     {
22217         arg2 = (bool)(SWIG_As_bool(obj1));
22218         if (SWIG_arg_fail(2)) SWIG_fail;
22219     }
22220     {
22221         PyThreadState* __tstate = wxPyBeginAllowThreads();
22222         (arg1)->EnablePaper(arg2);
22223
22224         wxPyEndAllowThreads(__tstate);
22225         if (PyErr_Occurred()) SWIG_fail;
22226     }
22227     Py_INCREF(Py_None); resultobj = Py_None;
22228     return resultobj;
22229     fail:
22230     return NULL;
22231 }
22232
22233
22234 static PyObject *_wrap_PageSetupDialogData_EnablePrinter(PyObject *, PyObject *args, PyObject *kwargs) {
22235     PyObject *resultobj;
22236     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22237     bool arg2 ;
22238     PyObject * obj0 = 0 ;
22239     PyObject * obj1 = 0 ;
22240     char *kwnames[] = {
22241         (char *) "self",(char *) "flag", NULL
22242     };
22243
22244     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnablePrinter",kwnames,&obj0,&obj1)) goto fail;
22245     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22246     if (SWIG_arg_fail(1)) SWIG_fail;
22247     {
22248         arg2 = (bool)(SWIG_As_bool(obj1));
22249         if (SWIG_arg_fail(2)) SWIG_fail;
22250     }
22251     {
22252         PyThreadState* __tstate = wxPyBeginAllowThreads();
22253         (arg1)->EnablePrinter(arg2);
22254
22255         wxPyEndAllowThreads(__tstate);
22256         if (PyErr_Occurred()) SWIG_fail;
22257     }
22258     Py_INCREF(Py_None); resultobj = Py_None;
22259     return resultobj;
22260     fail:
22261     return NULL;
22262 }
22263
22264
22265 static PyObject *_wrap_PageSetupDialogData_GetDefaultMinMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22266     PyObject *resultobj;
22267     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22268     bool result;
22269     PyObject * obj0 = 0 ;
22270     char *kwnames[] = {
22271         (char *) "self", NULL
22272     };
22273
22274     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetDefaultMinMargins",kwnames,&obj0)) goto fail;
22275     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22276     if (SWIG_arg_fail(1)) SWIG_fail;
22277     {
22278         PyThreadState* __tstate = wxPyBeginAllowThreads();
22279         result = (bool)(arg1)->GetDefaultMinMargins();
22280
22281         wxPyEndAllowThreads(__tstate);
22282         if (PyErr_Occurred()) SWIG_fail;
22283     }
22284     {
22285         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22286     }
22287     return resultobj;
22288     fail:
22289     return NULL;
22290 }
22291
22292
22293 static PyObject *_wrap_PageSetupDialogData_GetEnableMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22294     PyObject *resultobj;
22295     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22296     bool result;
22297     PyObject * obj0 = 0 ;
22298     char *kwnames[] = {
22299         (char *) "self", NULL
22300     };
22301
22302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableMargins",kwnames,&obj0)) goto fail;
22303     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22304     if (SWIG_arg_fail(1)) SWIG_fail;
22305     {
22306         PyThreadState* __tstate = wxPyBeginAllowThreads();
22307         result = (bool)(arg1)->GetEnableMargins();
22308
22309         wxPyEndAllowThreads(__tstate);
22310         if (PyErr_Occurred()) SWIG_fail;
22311     }
22312     {
22313         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22314     }
22315     return resultobj;
22316     fail:
22317     return NULL;
22318 }
22319
22320
22321 static PyObject *_wrap_PageSetupDialogData_GetEnableOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
22322     PyObject *resultobj;
22323     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22324     bool result;
22325     PyObject * obj0 = 0 ;
22326     char *kwnames[] = {
22327         (char *) "self", NULL
22328     };
22329
22330     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableOrientation",kwnames,&obj0)) goto fail;
22331     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22332     if (SWIG_arg_fail(1)) SWIG_fail;
22333     {
22334         PyThreadState* __tstate = wxPyBeginAllowThreads();
22335         result = (bool)(arg1)->GetEnableOrientation();
22336
22337         wxPyEndAllowThreads(__tstate);
22338         if (PyErr_Occurred()) SWIG_fail;
22339     }
22340     {
22341         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22342     }
22343     return resultobj;
22344     fail:
22345     return NULL;
22346 }
22347
22348
22349 static PyObject *_wrap_PageSetupDialogData_GetEnablePaper(PyObject *, PyObject *args, PyObject *kwargs) {
22350     PyObject *resultobj;
22351     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22352     bool result;
22353     PyObject * obj0 = 0 ;
22354     char *kwnames[] = {
22355         (char *) "self", NULL
22356     };
22357
22358     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnablePaper",kwnames,&obj0)) goto fail;
22359     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22360     if (SWIG_arg_fail(1)) SWIG_fail;
22361     {
22362         PyThreadState* __tstate = wxPyBeginAllowThreads();
22363         result = (bool)(arg1)->GetEnablePaper();
22364
22365         wxPyEndAllowThreads(__tstate);
22366         if (PyErr_Occurred()) SWIG_fail;
22367     }
22368     {
22369         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22370     }
22371     return resultobj;
22372     fail:
22373     return NULL;
22374 }
22375
22376
22377 static PyObject *_wrap_PageSetupDialogData_GetEnablePrinter(PyObject *, PyObject *args, PyObject *kwargs) {
22378     PyObject *resultobj;
22379     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22380     bool result;
22381     PyObject * obj0 = 0 ;
22382     char *kwnames[] = {
22383         (char *) "self", NULL
22384     };
22385
22386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnablePrinter",kwnames,&obj0)) goto fail;
22387     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22388     if (SWIG_arg_fail(1)) SWIG_fail;
22389     {
22390         PyThreadState* __tstate = wxPyBeginAllowThreads();
22391         result = (bool)(arg1)->GetEnablePrinter();
22392
22393         wxPyEndAllowThreads(__tstate);
22394         if (PyErr_Occurred()) SWIG_fail;
22395     }
22396     {
22397         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22398     }
22399     return resultobj;
22400     fail:
22401     return NULL;
22402 }
22403
22404
22405 static PyObject *_wrap_PageSetupDialogData_GetEnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
22406     PyObject *resultobj;
22407     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22408     bool result;
22409     PyObject * obj0 = 0 ;
22410     char *kwnames[] = {
22411         (char *) "self", NULL
22412     };
22413
22414     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableHelp",kwnames,&obj0)) goto fail;
22415     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22416     if (SWIG_arg_fail(1)) SWIG_fail;
22417     {
22418         PyThreadState* __tstate = wxPyBeginAllowThreads();
22419         result = (bool)(arg1)->GetEnableHelp();
22420
22421         wxPyEndAllowThreads(__tstate);
22422         if (PyErr_Occurred()) SWIG_fail;
22423     }
22424     {
22425         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22426     }
22427     return resultobj;
22428     fail:
22429     return NULL;
22430 }
22431
22432
22433 static PyObject *_wrap_PageSetupDialogData_GetDefaultInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22434     PyObject *resultobj;
22435     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22436     bool result;
22437     PyObject * obj0 = 0 ;
22438     char *kwnames[] = {
22439         (char *) "self", NULL
22440     };
22441
22442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetDefaultInfo",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 = (bool)(arg1)->GetDefaultInfo();
22448
22449         wxPyEndAllowThreads(__tstate);
22450         if (PyErr_Occurred()) SWIG_fail;
22451     }
22452     {
22453         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22454     }
22455     return resultobj;
22456     fail:
22457     return NULL;
22458 }
22459
22460
22461 static PyObject *_wrap_PageSetupDialogData_GetMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22462     PyObject *resultobj;
22463     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22464     wxPoint result;
22465     PyObject * obj0 = 0 ;
22466     char *kwnames[] = {
22467         (char *) "self", NULL
22468     };
22469
22470     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMarginTopLeft",kwnames,&obj0)) goto fail;
22471     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22472     if (SWIG_arg_fail(1)) SWIG_fail;
22473     {
22474         PyThreadState* __tstate = wxPyBeginAllowThreads();
22475         result = (arg1)->GetMarginTopLeft();
22476
22477         wxPyEndAllowThreads(__tstate);
22478         if (PyErr_Occurred()) SWIG_fail;
22479     }
22480     {
22481         wxPoint * resultptr;
22482         resultptr = new wxPoint((wxPoint &)(result));
22483         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22484     }
22485     return resultobj;
22486     fail:
22487     return NULL;
22488 }
22489
22490
22491 static PyObject *_wrap_PageSetupDialogData_GetMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22492     PyObject *resultobj;
22493     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22494     wxPoint result;
22495     PyObject * obj0 = 0 ;
22496     char *kwnames[] = {
22497         (char *) "self", NULL
22498     };
22499
22500     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMarginBottomRight",kwnames,&obj0)) goto fail;
22501     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22502     if (SWIG_arg_fail(1)) SWIG_fail;
22503     {
22504         PyThreadState* __tstate = wxPyBeginAllowThreads();
22505         result = (arg1)->GetMarginBottomRight();
22506
22507         wxPyEndAllowThreads(__tstate);
22508         if (PyErr_Occurred()) SWIG_fail;
22509     }
22510     {
22511         wxPoint * resultptr;
22512         resultptr = new wxPoint((wxPoint &)(result));
22513         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22514     }
22515     return resultobj;
22516     fail:
22517     return NULL;
22518 }
22519
22520
22521 static PyObject *_wrap_PageSetupDialogData_GetMinMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22522     PyObject *resultobj;
22523     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22524     wxPoint result;
22525     PyObject * obj0 = 0 ;
22526     char *kwnames[] = {
22527         (char *) "self", NULL
22528     };
22529
22530     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMinMarginTopLeft",kwnames,&obj0)) goto fail;
22531     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22532     if (SWIG_arg_fail(1)) SWIG_fail;
22533     {
22534         PyThreadState* __tstate = wxPyBeginAllowThreads();
22535         result = (arg1)->GetMinMarginTopLeft();
22536
22537         wxPyEndAllowThreads(__tstate);
22538         if (PyErr_Occurred()) SWIG_fail;
22539     }
22540     {
22541         wxPoint * resultptr;
22542         resultptr = new wxPoint((wxPoint &)(result));
22543         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22544     }
22545     return resultobj;
22546     fail:
22547     return NULL;
22548 }
22549
22550
22551 static PyObject *_wrap_PageSetupDialogData_GetMinMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22552     PyObject *resultobj;
22553     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22554     wxPoint result;
22555     PyObject * obj0 = 0 ;
22556     char *kwnames[] = {
22557         (char *) "self", NULL
22558     };
22559
22560     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMinMarginBottomRight",kwnames,&obj0)) goto fail;
22561     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22562     if (SWIG_arg_fail(1)) SWIG_fail;
22563     {
22564         PyThreadState* __tstate = wxPyBeginAllowThreads();
22565         result = (arg1)->GetMinMarginBottomRight();
22566
22567         wxPyEndAllowThreads(__tstate);
22568         if (PyErr_Occurred()) SWIG_fail;
22569     }
22570     {
22571         wxPoint * resultptr;
22572         resultptr = new wxPoint((wxPoint &)(result));
22573         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22574     }
22575     return resultobj;
22576     fail:
22577     return NULL;
22578 }
22579
22580
22581 static PyObject *_wrap_PageSetupDialogData_GetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
22582     PyObject *resultobj;
22583     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22584     wxPaperSize result;
22585     PyObject * obj0 = 0 ;
22586     char *kwnames[] = {
22587         (char *) "self", NULL
22588     };
22589
22590     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPaperId",kwnames,&obj0)) goto fail;
22591     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22592     if (SWIG_arg_fail(1)) SWIG_fail;
22593     {
22594         PyThreadState* __tstate = wxPyBeginAllowThreads();
22595         result = (wxPaperSize)(arg1)->GetPaperId();
22596
22597         wxPyEndAllowThreads(__tstate);
22598         if (PyErr_Occurred()) SWIG_fail;
22599     }
22600     resultobj = SWIG_From_int((result));
22601     return resultobj;
22602     fail:
22603     return NULL;
22604 }
22605
22606
22607 static PyObject *_wrap_PageSetupDialogData_GetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22608     PyObject *resultobj;
22609     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22610     wxSize result;
22611     PyObject * obj0 = 0 ;
22612     char *kwnames[] = {
22613         (char *) "self", NULL
22614     };
22615
22616     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPaperSize",kwnames,&obj0)) goto fail;
22617     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22618     if (SWIG_arg_fail(1)) SWIG_fail;
22619     {
22620         PyThreadState* __tstate = wxPyBeginAllowThreads();
22621         result = (arg1)->GetPaperSize();
22622
22623         wxPyEndAllowThreads(__tstate);
22624         if (PyErr_Occurred()) SWIG_fail;
22625     }
22626     {
22627         wxSize * resultptr;
22628         resultptr = new wxSize((wxSize &)(result));
22629         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
22630     }
22631     return resultobj;
22632     fail:
22633     return NULL;
22634 }
22635
22636
22637 static PyObject *_wrap_PageSetupDialogData_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
22638     PyObject *resultobj;
22639     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22640     wxPrintData *result;
22641     PyObject * obj0 = 0 ;
22642     char *kwnames[] = {
22643         (char *) "self", NULL
22644     };
22645
22646     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPrintData",kwnames,&obj0)) goto fail;
22647     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22648     if (SWIG_arg_fail(1)) SWIG_fail;
22649     {
22650         PyThreadState* __tstate = wxPyBeginAllowThreads();
22651         {
22652             wxPrintData &_result_ref = (arg1)->GetPrintData();
22653             result = (wxPrintData *) &_result_ref;
22654         }
22655
22656         wxPyEndAllowThreads(__tstate);
22657         if (PyErr_Occurred()) SWIG_fail;
22658     }
22659     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
22660     return resultobj;
22661     fail:
22662     return NULL;
22663 }
22664
22665
22666 static PyObject *_wrap_PageSetupDialogData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
22667     PyObject *resultobj;
22668     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22669     bool result;
22670     PyObject * obj0 = 0 ;
22671     char *kwnames[] = {
22672         (char *) "self", NULL
22673     };
22674
22675     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_Ok",kwnames,&obj0)) goto fail;
22676     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22677     if (SWIG_arg_fail(1)) SWIG_fail;
22678     {
22679         PyThreadState* __tstate = wxPyBeginAllowThreads();
22680         result = (bool)(arg1)->Ok();
22681
22682         wxPyEndAllowThreads(__tstate);
22683         if (PyErr_Occurred()) SWIG_fail;
22684     }
22685     {
22686         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22687     }
22688     return resultobj;
22689     fail:
22690     return NULL;
22691 }
22692
22693
22694 static PyObject *_wrap_PageSetupDialogData_SetDefaultInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22695     PyObject *resultobj;
22696     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22697     bool arg2 ;
22698     PyObject * obj0 = 0 ;
22699     PyObject * obj1 = 0 ;
22700     char *kwnames[] = {
22701         (char *) "self",(char *) "flag", NULL
22702     };
22703
22704     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetDefaultInfo",kwnames,&obj0,&obj1)) goto fail;
22705     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22706     if (SWIG_arg_fail(1)) SWIG_fail;
22707     {
22708         arg2 = (bool)(SWIG_As_bool(obj1));
22709         if (SWIG_arg_fail(2)) SWIG_fail;
22710     }
22711     {
22712         PyThreadState* __tstate = wxPyBeginAllowThreads();
22713         (arg1)->SetDefaultInfo(arg2);
22714
22715         wxPyEndAllowThreads(__tstate);
22716         if (PyErr_Occurred()) SWIG_fail;
22717     }
22718     Py_INCREF(Py_None); resultobj = Py_None;
22719     return resultobj;
22720     fail:
22721     return NULL;
22722 }
22723
22724
22725 static PyObject *_wrap_PageSetupDialogData_SetDefaultMinMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22726     PyObject *resultobj;
22727     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22728     bool arg2 ;
22729     PyObject * obj0 = 0 ;
22730     PyObject * obj1 = 0 ;
22731     char *kwnames[] = {
22732         (char *) "self",(char *) "flag", NULL
22733     };
22734
22735     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetDefaultMinMargins",kwnames,&obj0,&obj1)) goto fail;
22736     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22737     if (SWIG_arg_fail(1)) SWIG_fail;
22738     {
22739         arg2 = (bool)(SWIG_As_bool(obj1));
22740         if (SWIG_arg_fail(2)) SWIG_fail;
22741     }
22742     {
22743         PyThreadState* __tstate = wxPyBeginAllowThreads();
22744         (arg1)->SetDefaultMinMargins(arg2);
22745
22746         wxPyEndAllowThreads(__tstate);
22747         if (PyErr_Occurred()) SWIG_fail;
22748     }
22749     Py_INCREF(Py_None); resultobj = Py_None;
22750     return resultobj;
22751     fail:
22752     return NULL;
22753 }
22754
22755
22756 static PyObject *_wrap_PageSetupDialogData_SetMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22757     PyObject *resultobj;
22758     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22759     wxPoint *arg2 = 0 ;
22760     wxPoint temp2 ;
22761     PyObject * obj0 = 0 ;
22762     PyObject * obj1 = 0 ;
22763     char *kwnames[] = {
22764         (char *) "self",(char *) "pt", NULL
22765     };
22766
22767     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMarginTopLeft",kwnames,&obj0,&obj1)) goto fail;
22768     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22769     if (SWIG_arg_fail(1)) SWIG_fail;
22770     {
22771         arg2 = &temp2;
22772         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22773     }
22774     {
22775         PyThreadState* __tstate = wxPyBeginAllowThreads();
22776         (arg1)->SetMarginTopLeft((wxPoint const &)*arg2);
22777
22778         wxPyEndAllowThreads(__tstate);
22779         if (PyErr_Occurred()) SWIG_fail;
22780     }
22781     Py_INCREF(Py_None); resultobj = Py_None;
22782     return resultobj;
22783     fail:
22784     return NULL;
22785 }
22786
22787
22788 static PyObject *_wrap_PageSetupDialogData_SetMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22789     PyObject *resultobj;
22790     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22791     wxPoint *arg2 = 0 ;
22792     wxPoint temp2 ;
22793     PyObject * obj0 = 0 ;
22794     PyObject * obj1 = 0 ;
22795     char *kwnames[] = {
22796         (char *) "self",(char *) "pt", NULL
22797     };
22798
22799     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMarginBottomRight",kwnames,&obj0,&obj1)) goto fail;
22800     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22801     if (SWIG_arg_fail(1)) SWIG_fail;
22802     {
22803         arg2 = &temp2;
22804         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22805     }
22806     {
22807         PyThreadState* __tstate = wxPyBeginAllowThreads();
22808         (arg1)->SetMarginBottomRight((wxPoint const &)*arg2);
22809
22810         wxPyEndAllowThreads(__tstate);
22811         if (PyErr_Occurred()) SWIG_fail;
22812     }
22813     Py_INCREF(Py_None); resultobj = Py_None;
22814     return resultobj;
22815     fail:
22816     return NULL;
22817 }
22818
22819
22820 static PyObject *_wrap_PageSetupDialogData_SetMinMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22821     PyObject *resultobj;
22822     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22823     wxPoint *arg2 = 0 ;
22824     wxPoint temp2 ;
22825     PyObject * obj0 = 0 ;
22826     PyObject * obj1 = 0 ;
22827     char *kwnames[] = {
22828         (char *) "self",(char *) "pt", NULL
22829     };
22830
22831     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMinMarginTopLeft",kwnames,&obj0,&obj1)) goto fail;
22832     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22833     if (SWIG_arg_fail(1)) SWIG_fail;
22834     {
22835         arg2 = &temp2;
22836         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22837     }
22838     {
22839         PyThreadState* __tstate = wxPyBeginAllowThreads();
22840         (arg1)->SetMinMarginTopLeft((wxPoint const &)*arg2);
22841
22842         wxPyEndAllowThreads(__tstate);
22843         if (PyErr_Occurred()) SWIG_fail;
22844     }
22845     Py_INCREF(Py_None); resultobj = Py_None;
22846     return resultobj;
22847     fail:
22848     return NULL;
22849 }
22850
22851
22852 static PyObject *_wrap_PageSetupDialogData_SetMinMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22853     PyObject *resultobj;
22854     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22855     wxPoint *arg2 = 0 ;
22856     wxPoint temp2 ;
22857     PyObject * obj0 = 0 ;
22858     PyObject * obj1 = 0 ;
22859     char *kwnames[] = {
22860         (char *) "self",(char *) "pt", NULL
22861     };
22862
22863     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMinMarginBottomRight",kwnames,&obj0,&obj1)) goto fail;
22864     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22865     if (SWIG_arg_fail(1)) SWIG_fail;
22866     {
22867         arg2 = &temp2;
22868         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22869     }
22870     {
22871         PyThreadState* __tstate = wxPyBeginAllowThreads();
22872         (arg1)->SetMinMarginBottomRight((wxPoint const &)*arg2);
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 *_wrap_PageSetupDialogData_SetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
22885     PyObject *resultobj;
22886     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22887     wxPaperSize arg2 ;
22888     PyObject * obj0 = 0 ;
22889     PyObject * obj1 = 0 ;
22890     char *kwnames[] = {
22891         (char *) "self",(char *) "id", NULL
22892     };
22893
22894     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPaperId",kwnames,&obj0,&obj1)) goto fail;
22895     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22896     if (SWIG_arg_fail(1)) SWIG_fail;
22897     {
22898         arg2 = (wxPaperSize)(SWIG_As_int(obj1));
22899         if (SWIG_arg_fail(2)) SWIG_fail;
22900     }
22901     {
22902         PyThreadState* __tstate = wxPyBeginAllowThreads();
22903         (arg1)->SetPaperId((wxPaperSize )arg2);
22904
22905         wxPyEndAllowThreads(__tstate);
22906         if (PyErr_Occurred()) SWIG_fail;
22907     }
22908     Py_INCREF(Py_None); resultobj = Py_None;
22909     return resultobj;
22910     fail:
22911     return NULL;
22912 }
22913
22914
22915 static PyObject *_wrap_PageSetupDialogData_SetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22916     PyObject *resultobj;
22917     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22918     wxSize *arg2 = 0 ;
22919     wxSize temp2 ;
22920     PyObject * obj0 = 0 ;
22921     PyObject * obj1 = 0 ;
22922     char *kwnames[] = {
22923         (char *) "self",(char *) "size", NULL
22924     };
22925
22926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPaperSize",kwnames,&obj0,&obj1)) goto fail;
22927     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22928     if (SWIG_arg_fail(1)) SWIG_fail;
22929     {
22930         arg2 = &temp2;
22931         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
22932     }
22933     {
22934         PyThreadState* __tstate = wxPyBeginAllowThreads();
22935         (arg1)->SetPaperSize((wxSize const &)*arg2);
22936
22937         wxPyEndAllowThreads(__tstate);
22938         if (PyErr_Occurred()) SWIG_fail;
22939     }
22940     Py_INCREF(Py_None); resultobj = Py_None;
22941     return resultobj;
22942     fail:
22943     return NULL;
22944 }
22945
22946
22947 static PyObject *_wrap_PageSetupDialogData_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
22948     PyObject *resultobj;
22949     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22950     wxPrintData *arg2 = 0 ;
22951     PyObject * obj0 = 0 ;
22952     PyObject * obj1 = 0 ;
22953     char *kwnames[] = {
22954         (char *) "self",(char *) "printData", NULL
22955     };
22956
22957     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
22958     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22959     if (SWIG_arg_fail(1)) SWIG_fail;
22960     {
22961         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
22962         if (SWIG_arg_fail(2)) SWIG_fail;
22963         if (arg2 == NULL) {
22964             SWIG_null_ref("wxPrintData");
22965         }
22966         if (SWIG_arg_fail(2)) SWIG_fail;
22967     }
22968     {
22969         PyThreadState* __tstate = wxPyBeginAllowThreads();
22970         (arg1)->SetPrintData((wxPrintData const &)*arg2);
22971
22972         wxPyEndAllowThreads(__tstate);
22973         if (PyErr_Occurred()) SWIG_fail;
22974     }
22975     Py_INCREF(Py_None); resultobj = Py_None;
22976     return resultobj;
22977     fail:
22978     return NULL;
22979 }
22980
22981
22982 static PyObject *_wrap_PageSetupDialogData_CalculateIdFromPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22983     PyObject *resultobj;
22984     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22985     PyObject * obj0 = 0 ;
22986     char *kwnames[] = {
22987         (char *) "self", NULL
22988     };
22989
22990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_CalculateIdFromPaperSize",kwnames,&obj0)) goto fail;
22991     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22992     if (SWIG_arg_fail(1)) SWIG_fail;
22993     {
22994         PyThreadState* __tstate = wxPyBeginAllowThreads();
22995         (arg1)->CalculateIdFromPaperSize();
22996
22997         wxPyEndAllowThreads(__tstate);
22998         if (PyErr_Occurred()) SWIG_fail;
22999     }
23000     Py_INCREF(Py_None); resultobj = Py_None;
23001     return resultobj;
23002     fail:
23003     return NULL;
23004 }
23005
23006
23007 static PyObject *_wrap_PageSetupDialogData_CalculatePaperSizeFromId(PyObject *, PyObject *args, PyObject *kwargs) {
23008     PyObject *resultobj;
23009     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
23010     PyObject * obj0 = 0 ;
23011     char *kwnames[] = {
23012         (char *) "self", NULL
23013     };
23014
23015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_CalculatePaperSizeFromId",kwnames,&obj0)) goto fail;
23016     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
23017     if (SWIG_arg_fail(1)) SWIG_fail;
23018     {
23019         PyThreadState* __tstate = wxPyBeginAllowThreads();
23020         (arg1)->CalculatePaperSizeFromId();
23021
23022         wxPyEndAllowThreads(__tstate);
23023         if (PyErr_Occurred()) SWIG_fail;
23024     }
23025     Py_INCREF(Py_None); resultobj = Py_None;
23026     return resultobj;
23027     fail:
23028     return NULL;
23029 }
23030
23031
23032 static PyObject * PageSetupDialogData_swigregister(PyObject *, PyObject *args) {
23033     PyObject *obj;
23034     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23035     SWIG_TypeClientData(SWIGTYPE_p_wxPageSetupDialogData, obj);
23036     Py_INCREF(obj);
23037     return Py_BuildValue((char *)"");
23038 }
23039 static PyObject *_wrap_new_PageSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23040     PyObject *resultobj;
23041     wxWindow *arg1 = (wxWindow *) 0 ;
23042     wxPageSetupDialogData *arg2 = (wxPageSetupDialogData *) NULL ;
23043     wxPageSetupDialog *result;
23044     PyObject * obj0 = 0 ;
23045     PyObject * obj1 = 0 ;
23046     char *kwnames[] = {
23047         (char *) "parent",(char *) "data", NULL
23048     };
23049
23050     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PageSetupDialog",kwnames,&obj0,&obj1)) goto fail;
23051     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23052     if (SWIG_arg_fail(1)) SWIG_fail;
23053     if (obj1) {
23054         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
23055         if (SWIG_arg_fail(2)) SWIG_fail;
23056     }
23057     {
23058         if (!wxPyCheckForApp()) SWIG_fail;
23059         PyThreadState* __tstate = wxPyBeginAllowThreads();
23060         result = (wxPageSetupDialog *)new wxPageSetupDialog(arg1,arg2);
23061
23062         wxPyEndAllowThreads(__tstate);
23063         if (PyErr_Occurred()) SWIG_fail;
23064     }
23065     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialog, 1);
23066     return resultobj;
23067     fail:
23068     return NULL;
23069 }
23070
23071
23072 static PyObject *_wrap_PageSetupDialog_GetPageSetupData(PyObject *, PyObject *args, PyObject *kwargs) {
23073     PyObject *resultobj;
23074     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
23075     wxPageSetupDialogData *result;
23076     PyObject * obj0 = 0 ;
23077     char *kwnames[] = {
23078         (char *) "self", NULL
23079     };
23080
23081     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_GetPageSetupData",kwnames,&obj0)) goto fail;
23082     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
23083     if (SWIG_arg_fail(1)) SWIG_fail;
23084     {
23085         PyThreadState* __tstate = wxPyBeginAllowThreads();
23086         {
23087             wxPageSetupDialogData &_result_ref = (arg1)->GetPageSetupData();
23088             result = (wxPageSetupDialogData *) &_result_ref;
23089         }
23090
23091         wxPyEndAllowThreads(__tstate);
23092         if (PyErr_Occurred()) SWIG_fail;
23093     }
23094     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 0);
23095     return resultobj;
23096     fail:
23097     return NULL;
23098 }
23099
23100
23101 static PyObject *_wrap_PageSetupDialog_GetPageSetupDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
23102     PyObject *resultobj;
23103     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
23104     wxPageSetupDialogData *result;
23105     PyObject * obj0 = 0 ;
23106     char *kwnames[] = {
23107         (char *) "self", NULL
23108     };
23109
23110     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_GetPageSetupDialogData",kwnames,&obj0)) goto fail;
23111     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
23112     if (SWIG_arg_fail(1)) SWIG_fail;
23113     {
23114         PyThreadState* __tstate = wxPyBeginAllowThreads();
23115         {
23116             wxPageSetupDialogData &_result_ref = (arg1)->GetPageSetupDialogData();
23117             result = (wxPageSetupDialogData *) &_result_ref;
23118         }
23119
23120         wxPyEndAllowThreads(__tstate);
23121         if (PyErr_Occurred()) SWIG_fail;
23122     }
23123     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 0);
23124     return resultobj;
23125     fail:
23126     return NULL;
23127 }
23128
23129
23130 static PyObject *_wrap_PageSetupDialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
23131     PyObject *resultobj;
23132     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
23133     int result;
23134     PyObject * obj0 = 0 ;
23135     char *kwnames[] = {
23136         (char *) "self", NULL
23137     };
23138
23139     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_ShowModal",kwnames,&obj0)) goto fail;
23140     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
23141     if (SWIG_arg_fail(1)) SWIG_fail;
23142     {
23143         PyThreadState* __tstate = wxPyBeginAllowThreads();
23144         result = (int)(arg1)->ShowModal();
23145
23146         wxPyEndAllowThreads(__tstate);
23147         if (PyErr_Occurred()) SWIG_fail;
23148     }
23149     {
23150         resultobj = SWIG_From_int((int)(result));
23151     }
23152     return resultobj;
23153     fail:
23154     return NULL;
23155 }
23156
23157
23158 static PyObject * PageSetupDialog_swigregister(PyObject *, PyObject *args) {
23159     PyObject *obj;
23160     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23161     SWIG_TypeClientData(SWIGTYPE_p_wxPageSetupDialog, obj);
23162     Py_INCREF(obj);
23163     return Py_BuildValue((char *)"");
23164 }
23165 static PyObject *_wrap_new_PrintDialogData__SWIG_0(PyObject *, PyObject *args) {
23166     PyObject *resultobj;
23167     wxPrintDialogData *result;
23168
23169     if(!PyArg_ParseTuple(args,(char *)":new_PrintDialogData")) goto fail;
23170     {
23171         PyThreadState* __tstate = wxPyBeginAllowThreads();
23172         result = (wxPrintDialogData *)new wxPrintDialogData();
23173
23174         wxPyEndAllowThreads(__tstate);
23175         if (PyErr_Occurred()) SWIG_fail;
23176     }
23177     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23178     return resultobj;
23179     fail:
23180     return NULL;
23181 }
23182
23183
23184 static PyObject *_wrap_new_PrintDialogData__SWIG_1(PyObject *, PyObject *args) {
23185     PyObject *resultobj;
23186     wxPrintData *arg1 = 0 ;
23187     wxPrintDialogData *result;
23188     PyObject * obj0 = 0 ;
23189
23190     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintDialogData",&obj0)) goto fail;
23191     {
23192         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
23193         if (SWIG_arg_fail(1)) SWIG_fail;
23194         if (arg1 == NULL) {
23195             SWIG_null_ref("wxPrintData");
23196         }
23197         if (SWIG_arg_fail(1)) SWIG_fail;
23198     }
23199     {
23200         PyThreadState* __tstate = wxPyBeginAllowThreads();
23201         result = (wxPrintDialogData *)new wxPrintDialogData((wxPrintData const &)*arg1);
23202
23203         wxPyEndAllowThreads(__tstate);
23204         if (PyErr_Occurred()) SWIG_fail;
23205     }
23206     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23207     return resultobj;
23208     fail:
23209     return NULL;
23210 }
23211
23212
23213 static PyObject *_wrap_new_PrintDialogData__SWIG_2(PyObject *, PyObject *args) {
23214     PyObject *resultobj;
23215     wxPrintDialogData *arg1 = 0 ;
23216     wxPrintDialogData *result;
23217     PyObject * obj0 = 0 ;
23218
23219     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintDialogData",&obj0)) goto fail;
23220     {
23221         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23222         if (SWIG_arg_fail(1)) SWIG_fail;
23223         if (arg1 == NULL) {
23224             SWIG_null_ref("wxPrintDialogData");
23225         }
23226         if (SWIG_arg_fail(1)) SWIG_fail;
23227     }
23228     {
23229         PyThreadState* __tstate = wxPyBeginAllowThreads();
23230         result = (wxPrintDialogData *)new wxPrintDialogData((wxPrintDialogData const &)*arg1);
23231
23232         wxPyEndAllowThreads(__tstate);
23233         if (PyErr_Occurred()) SWIG_fail;
23234     }
23235     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23236     return resultobj;
23237     fail:
23238     return NULL;
23239 }
23240
23241
23242 static PyObject *_wrap_new_PrintDialogData(PyObject *self, PyObject *args) {
23243     int argc;
23244     PyObject *argv[2];
23245     int ii;
23246
23247     argc = PyObject_Length(args);
23248     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
23249         argv[ii] = PyTuple_GetItem(args,ii);
23250     }
23251     if (argc == 0) {
23252         return _wrap_new_PrintDialogData__SWIG_0(self,args);
23253     }
23254     if (argc == 1) {
23255         int _v;
23256         {
23257             void *ptr = 0;
23258             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
23259                 _v = 0;
23260                 PyErr_Clear();
23261             } else {
23262                 _v = (ptr != 0);
23263             }
23264         }
23265         if (_v) {
23266             return _wrap_new_PrintDialogData__SWIG_1(self,args);
23267         }
23268     }
23269     if (argc == 1) {
23270         int _v;
23271         {
23272             void *ptr = 0;
23273             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
23274                 _v = 0;
23275                 PyErr_Clear();
23276             } else {
23277                 _v = (ptr != 0);
23278             }
23279         }
23280         if (_v) {
23281             return _wrap_new_PrintDialogData__SWIG_2(self,args);
23282         }
23283     }
23284
23285     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintDialogData'");
23286     return NULL;
23287 }
23288
23289
23290 static PyObject *_wrap_delete_PrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
23291     PyObject *resultobj;
23292     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23293     PyObject * obj0 = 0 ;
23294     char *kwnames[] = {
23295         (char *) "self", NULL
23296     };
23297
23298     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PrintDialogData",kwnames,&obj0)) goto fail;
23299     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23300     if (SWIG_arg_fail(1)) SWIG_fail;
23301     {
23302         PyThreadState* __tstate = wxPyBeginAllowThreads();
23303         delete arg1;
23304
23305         wxPyEndAllowThreads(__tstate);
23306         if (PyErr_Occurred()) SWIG_fail;
23307     }
23308     Py_INCREF(Py_None); resultobj = Py_None;
23309     return resultobj;
23310     fail:
23311     return NULL;
23312 }
23313
23314
23315 static PyObject *_wrap_PrintDialogData_GetFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
23316     PyObject *resultobj;
23317     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23318     int result;
23319     PyObject * obj0 = 0 ;
23320     char *kwnames[] = {
23321         (char *) "self", NULL
23322     };
23323
23324     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetFromPage",kwnames,&obj0)) goto fail;
23325     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23326     if (SWIG_arg_fail(1)) SWIG_fail;
23327     {
23328         PyThreadState* __tstate = wxPyBeginAllowThreads();
23329         result = (int)((wxPrintDialogData const *)arg1)->GetFromPage();
23330
23331         wxPyEndAllowThreads(__tstate);
23332         if (PyErr_Occurred()) SWIG_fail;
23333     }
23334     {
23335         resultobj = SWIG_From_int((int)(result));
23336     }
23337     return resultobj;
23338     fail:
23339     return NULL;
23340 }
23341
23342
23343 static PyObject *_wrap_PrintDialogData_GetToPage(PyObject *, PyObject *args, PyObject *kwargs) {
23344     PyObject *resultobj;
23345     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23346     int result;
23347     PyObject * obj0 = 0 ;
23348     char *kwnames[] = {
23349         (char *) "self", NULL
23350     };
23351
23352     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetToPage",kwnames,&obj0)) goto fail;
23353     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23354     if (SWIG_arg_fail(1)) SWIG_fail;
23355     {
23356         PyThreadState* __tstate = wxPyBeginAllowThreads();
23357         result = (int)((wxPrintDialogData const *)arg1)->GetToPage();
23358
23359         wxPyEndAllowThreads(__tstate);
23360         if (PyErr_Occurred()) SWIG_fail;
23361     }
23362     {
23363         resultobj = SWIG_From_int((int)(result));
23364     }
23365     return resultobj;
23366     fail:
23367     return NULL;
23368 }
23369
23370
23371 static PyObject *_wrap_PrintDialogData_GetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
23372     PyObject *resultobj;
23373     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23374     int result;
23375     PyObject * obj0 = 0 ;
23376     char *kwnames[] = {
23377         (char *) "self", NULL
23378     };
23379
23380     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetMinPage",kwnames,&obj0)) goto fail;
23381     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23382     if (SWIG_arg_fail(1)) SWIG_fail;
23383     {
23384         PyThreadState* __tstate = wxPyBeginAllowThreads();
23385         result = (int)((wxPrintDialogData const *)arg1)->GetMinPage();
23386
23387         wxPyEndAllowThreads(__tstate);
23388         if (PyErr_Occurred()) SWIG_fail;
23389     }
23390     {
23391         resultobj = SWIG_From_int((int)(result));
23392     }
23393     return resultobj;
23394     fail:
23395     return NULL;
23396 }
23397
23398
23399 static PyObject *_wrap_PrintDialogData_GetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
23400     PyObject *resultobj;
23401     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23402     int result;
23403     PyObject * obj0 = 0 ;
23404     char *kwnames[] = {
23405         (char *) "self", NULL
23406     };
23407
23408     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetMaxPage",kwnames,&obj0)) goto fail;
23409     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23410     if (SWIG_arg_fail(1)) SWIG_fail;
23411     {
23412         PyThreadState* __tstate = wxPyBeginAllowThreads();
23413         result = (int)((wxPrintDialogData const *)arg1)->GetMaxPage();
23414
23415         wxPyEndAllowThreads(__tstate);
23416         if (PyErr_Occurred()) SWIG_fail;
23417     }
23418     {
23419         resultobj = SWIG_From_int((int)(result));
23420     }
23421     return resultobj;
23422     fail:
23423     return NULL;
23424 }
23425
23426
23427 static PyObject *_wrap_PrintDialogData_GetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
23428     PyObject *resultobj;
23429     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23430     int result;
23431     PyObject * obj0 = 0 ;
23432     char *kwnames[] = {
23433         (char *) "self", NULL
23434     };
23435
23436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetNoCopies",kwnames,&obj0)) goto fail;
23437     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23438     if (SWIG_arg_fail(1)) SWIG_fail;
23439     {
23440         PyThreadState* __tstate = wxPyBeginAllowThreads();
23441         result = (int)((wxPrintDialogData const *)arg1)->GetNoCopies();
23442
23443         wxPyEndAllowThreads(__tstate);
23444         if (PyErr_Occurred()) SWIG_fail;
23445     }
23446     {
23447         resultobj = SWIG_From_int((int)(result));
23448     }
23449     return resultobj;
23450     fail:
23451     return NULL;
23452 }
23453
23454
23455 static PyObject *_wrap_PrintDialogData_GetAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
23456     PyObject *resultobj;
23457     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23458     bool result;
23459     PyObject * obj0 = 0 ;
23460     char *kwnames[] = {
23461         (char *) "self", NULL
23462     };
23463
23464     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetAllPages",kwnames,&obj0)) goto fail;
23465     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23466     if (SWIG_arg_fail(1)) SWIG_fail;
23467     {
23468         PyThreadState* __tstate = wxPyBeginAllowThreads();
23469         result = (bool)((wxPrintDialogData const *)arg1)->GetAllPages();
23470
23471         wxPyEndAllowThreads(__tstate);
23472         if (PyErr_Occurred()) SWIG_fail;
23473     }
23474     {
23475         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23476     }
23477     return resultobj;
23478     fail:
23479     return NULL;
23480 }
23481
23482
23483 static PyObject *_wrap_PrintDialogData_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23484     PyObject *resultobj;
23485     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23486     bool result;
23487     PyObject * obj0 = 0 ;
23488     char *kwnames[] = {
23489         (char *) "self", NULL
23490     };
23491
23492     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetSelection",kwnames,&obj0)) goto fail;
23493     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23494     if (SWIG_arg_fail(1)) SWIG_fail;
23495     {
23496         PyThreadState* __tstate = wxPyBeginAllowThreads();
23497         result = (bool)((wxPrintDialogData const *)arg1)->GetSelection();
23498
23499         wxPyEndAllowThreads(__tstate);
23500         if (PyErr_Occurred()) SWIG_fail;
23501     }
23502     {
23503         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23504     }
23505     return resultobj;
23506     fail:
23507     return NULL;
23508 }
23509
23510
23511 static PyObject *_wrap_PrintDialogData_GetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
23512     PyObject *resultobj;
23513     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23514     bool result;
23515     PyObject * obj0 = 0 ;
23516     char *kwnames[] = {
23517         (char *) "self", NULL
23518     };
23519
23520     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetCollate",kwnames,&obj0)) goto fail;
23521     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23522     if (SWIG_arg_fail(1)) SWIG_fail;
23523     {
23524         PyThreadState* __tstate = wxPyBeginAllowThreads();
23525         result = (bool)((wxPrintDialogData const *)arg1)->GetCollate();
23526
23527         wxPyEndAllowThreads(__tstate);
23528         if (PyErr_Occurred()) SWIG_fail;
23529     }
23530     {
23531         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23532     }
23533     return resultobj;
23534     fail:
23535     return NULL;
23536 }
23537
23538
23539 static PyObject *_wrap_PrintDialogData_GetPrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23540     PyObject *resultobj;
23541     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23542     bool result;
23543     PyObject * obj0 = 0 ;
23544     char *kwnames[] = {
23545         (char *) "self", NULL
23546     };
23547
23548     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetPrintToFile",kwnames,&obj0)) goto fail;
23549     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23550     if (SWIG_arg_fail(1)) SWIG_fail;
23551     {
23552         PyThreadState* __tstate = wxPyBeginAllowThreads();
23553         result = (bool)((wxPrintDialogData const *)arg1)->GetPrintToFile();
23554
23555         wxPyEndAllowThreads(__tstate);
23556         if (PyErr_Occurred()) SWIG_fail;
23557     }
23558     {
23559         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23560     }
23561     return resultobj;
23562     fail:
23563     return NULL;
23564 }
23565
23566
23567 static PyObject *_wrap_PrintDialogData_GetSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23568     PyObject *resultobj;
23569     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23570     bool result;
23571     PyObject * obj0 = 0 ;
23572     char *kwnames[] = {
23573         (char *) "self", NULL
23574     };
23575
23576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetSetupDialog",kwnames,&obj0)) goto fail;
23577     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23578     if (SWIG_arg_fail(1)) SWIG_fail;
23579     {
23580         PyThreadState* __tstate = wxPyBeginAllowThreads();
23581         result = (bool)((wxPrintDialogData const *)arg1)->GetSetupDialog();
23582
23583         wxPyEndAllowThreads(__tstate);
23584         if (PyErr_Occurred()) SWIG_fail;
23585     }
23586     {
23587         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23588     }
23589     return resultobj;
23590     fail:
23591     return NULL;
23592 }
23593
23594
23595 static PyObject *_wrap_PrintDialogData_SetSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23596     PyObject *resultobj;
23597     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23598     bool arg2 ;
23599     PyObject * obj0 = 0 ;
23600     PyObject * obj1 = 0 ;
23601     char *kwnames[] = {
23602         (char *) "self",(char *) "flag", NULL
23603     };
23604
23605     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetSetupDialog",kwnames,&obj0,&obj1)) goto fail;
23606     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23607     if (SWIG_arg_fail(1)) SWIG_fail;
23608     {
23609         arg2 = (bool)(SWIG_As_bool(obj1));
23610         if (SWIG_arg_fail(2)) SWIG_fail;
23611     }
23612     {
23613         PyThreadState* __tstate = wxPyBeginAllowThreads();
23614         (arg1)->SetSetupDialog(arg2);
23615
23616         wxPyEndAllowThreads(__tstate);
23617         if (PyErr_Occurred()) SWIG_fail;
23618     }
23619     Py_INCREF(Py_None); resultobj = Py_None;
23620     return resultobj;
23621     fail:
23622     return NULL;
23623 }
23624
23625
23626 static PyObject *_wrap_PrintDialogData_SetFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
23627     PyObject *resultobj;
23628     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23629     int arg2 ;
23630     PyObject * obj0 = 0 ;
23631     PyObject * obj1 = 0 ;
23632     char *kwnames[] = {
23633         (char *) "self",(char *) "v", NULL
23634     };
23635
23636     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetFromPage",kwnames,&obj0,&obj1)) goto fail;
23637     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23638     if (SWIG_arg_fail(1)) SWIG_fail;
23639     {
23640         arg2 = (int)(SWIG_As_int(obj1));
23641         if (SWIG_arg_fail(2)) SWIG_fail;
23642     }
23643     {
23644         PyThreadState* __tstate = wxPyBeginAllowThreads();
23645         (arg1)->SetFromPage(arg2);
23646
23647         wxPyEndAllowThreads(__tstate);
23648         if (PyErr_Occurred()) SWIG_fail;
23649     }
23650     Py_INCREF(Py_None); resultobj = Py_None;
23651     return resultobj;
23652     fail:
23653     return NULL;
23654 }
23655
23656
23657 static PyObject *_wrap_PrintDialogData_SetToPage(PyObject *, PyObject *args, PyObject *kwargs) {
23658     PyObject *resultobj;
23659     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23660     int arg2 ;
23661     PyObject * obj0 = 0 ;
23662     PyObject * obj1 = 0 ;
23663     char *kwnames[] = {
23664         (char *) "self",(char *) "v", NULL
23665     };
23666
23667     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetToPage",kwnames,&obj0,&obj1)) goto fail;
23668     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23669     if (SWIG_arg_fail(1)) SWIG_fail;
23670     {
23671         arg2 = (int)(SWIG_As_int(obj1));
23672         if (SWIG_arg_fail(2)) SWIG_fail;
23673     }
23674     {
23675         PyThreadState* __tstate = wxPyBeginAllowThreads();
23676         (arg1)->SetToPage(arg2);
23677
23678         wxPyEndAllowThreads(__tstate);
23679         if (PyErr_Occurred()) SWIG_fail;
23680     }
23681     Py_INCREF(Py_None); resultobj = Py_None;
23682     return resultobj;
23683     fail:
23684     return NULL;
23685 }
23686
23687
23688 static PyObject *_wrap_PrintDialogData_SetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
23689     PyObject *resultobj;
23690     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23691     int arg2 ;
23692     PyObject * obj0 = 0 ;
23693     PyObject * obj1 = 0 ;
23694     char *kwnames[] = {
23695         (char *) "self",(char *) "v", NULL
23696     };
23697
23698     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetMinPage",kwnames,&obj0,&obj1)) goto fail;
23699     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23700     if (SWIG_arg_fail(1)) SWIG_fail;
23701     {
23702         arg2 = (int)(SWIG_As_int(obj1));
23703         if (SWIG_arg_fail(2)) SWIG_fail;
23704     }
23705     {
23706         PyThreadState* __tstate = wxPyBeginAllowThreads();
23707         (arg1)->SetMinPage(arg2);
23708
23709         wxPyEndAllowThreads(__tstate);
23710         if (PyErr_Occurred()) SWIG_fail;
23711     }
23712     Py_INCREF(Py_None); resultobj = Py_None;
23713     return resultobj;
23714     fail:
23715     return NULL;
23716 }
23717
23718
23719 static PyObject *_wrap_PrintDialogData_SetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
23720     PyObject *resultobj;
23721     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23722     int arg2 ;
23723     PyObject * obj0 = 0 ;
23724     PyObject * obj1 = 0 ;
23725     char *kwnames[] = {
23726         (char *) "self",(char *) "v", NULL
23727     };
23728
23729     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetMaxPage",kwnames,&obj0,&obj1)) goto fail;
23730     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23731     if (SWIG_arg_fail(1)) SWIG_fail;
23732     {
23733         arg2 = (int)(SWIG_As_int(obj1));
23734         if (SWIG_arg_fail(2)) SWIG_fail;
23735     }
23736     {
23737         PyThreadState* __tstate = wxPyBeginAllowThreads();
23738         (arg1)->SetMaxPage(arg2);
23739
23740         wxPyEndAllowThreads(__tstate);
23741         if (PyErr_Occurred()) SWIG_fail;
23742     }
23743     Py_INCREF(Py_None); resultobj = Py_None;
23744     return resultobj;
23745     fail:
23746     return NULL;
23747 }
23748
23749
23750 static PyObject *_wrap_PrintDialogData_SetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
23751     PyObject *resultobj;
23752     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23753     int arg2 ;
23754     PyObject * obj0 = 0 ;
23755     PyObject * obj1 = 0 ;
23756     char *kwnames[] = {
23757         (char *) "self",(char *) "v", NULL
23758     };
23759
23760     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetNoCopies",kwnames,&obj0,&obj1)) goto fail;
23761     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23762     if (SWIG_arg_fail(1)) SWIG_fail;
23763     {
23764         arg2 = (int)(SWIG_As_int(obj1));
23765         if (SWIG_arg_fail(2)) SWIG_fail;
23766     }
23767     {
23768         PyThreadState* __tstate = wxPyBeginAllowThreads();
23769         (arg1)->SetNoCopies(arg2);
23770
23771         wxPyEndAllowThreads(__tstate);
23772         if (PyErr_Occurred()) SWIG_fail;
23773     }
23774     Py_INCREF(Py_None); resultobj = Py_None;
23775     return resultobj;
23776     fail:
23777     return NULL;
23778 }
23779
23780
23781 static PyObject *_wrap_PrintDialogData_SetAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
23782     PyObject *resultobj;
23783     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23784     bool arg2 ;
23785     PyObject * obj0 = 0 ;
23786     PyObject * obj1 = 0 ;
23787     char *kwnames[] = {
23788         (char *) "self",(char *) "flag", NULL
23789     };
23790
23791     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetAllPages",kwnames,&obj0,&obj1)) goto fail;
23792     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23793     if (SWIG_arg_fail(1)) SWIG_fail;
23794     {
23795         arg2 = (bool)(SWIG_As_bool(obj1));
23796         if (SWIG_arg_fail(2)) SWIG_fail;
23797     }
23798     {
23799         PyThreadState* __tstate = wxPyBeginAllowThreads();
23800         (arg1)->SetAllPages(arg2);
23801
23802         wxPyEndAllowThreads(__tstate);
23803         if (PyErr_Occurred()) SWIG_fail;
23804     }
23805     Py_INCREF(Py_None); resultobj = Py_None;
23806     return resultobj;
23807     fail:
23808     return NULL;
23809 }
23810
23811
23812 static PyObject *_wrap_PrintDialogData_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23813     PyObject *resultobj;
23814     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23815     bool arg2 ;
23816     PyObject * obj0 = 0 ;
23817     PyObject * obj1 = 0 ;
23818     char *kwnames[] = {
23819         (char *) "self",(char *) "flag", NULL
23820     };
23821
23822     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetSelection",kwnames,&obj0,&obj1)) goto fail;
23823     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23824     if (SWIG_arg_fail(1)) SWIG_fail;
23825     {
23826         arg2 = (bool)(SWIG_As_bool(obj1));
23827         if (SWIG_arg_fail(2)) SWIG_fail;
23828     }
23829     {
23830         PyThreadState* __tstate = wxPyBeginAllowThreads();
23831         (arg1)->SetSelection(arg2);
23832
23833         wxPyEndAllowThreads(__tstate);
23834         if (PyErr_Occurred()) SWIG_fail;
23835     }
23836     Py_INCREF(Py_None); resultobj = Py_None;
23837     return resultobj;
23838     fail:
23839     return NULL;
23840 }
23841
23842
23843 static PyObject *_wrap_PrintDialogData_SetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
23844     PyObject *resultobj;
23845     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23846     bool arg2 ;
23847     PyObject * obj0 = 0 ;
23848     PyObject * obj1 = 0 ;
23849     char *kwnames[] = {
23850         (char *) "self",(char *) "flag", NULL
23851     };
23852
23853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetCollate",kwnames,&obj0,&obj1)) goto fail;
23854     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23855     if (SWIG_arg_fail(1)) SWIG_fail;
23856     {
23857         arg2 = (bool)(SWIG_As_bool(obj1));
23858         if (SWIG_arg_fail(2)) SWIG_fail;
23859     }
23860     {
23861         PyThreadState* __tstate = wxPyBeginAllowThreads();
23862         (arg1)->SetCollate(arg2);
23863
23864         wxPyEndAllowThreads(__tstate);
23865         if (PyErr_Occurred()) SWIG_fail;
23866     }
23867     Py_INCREF(Py_None); resultobj = Py_None;
23868     return resultobj;
23869     fail:
23870     return NULL;
23871 }
23872
23873
23874 static PyObject *_wrap_PrintDialogData_SetPrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23875     PyObject *resultobj;
23876     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23877     bool arg2 ;
23878     PyObject * obj0 = 0 ;
23879     PyObject * obj1 = 0 ;
23880     char *kwnames[] = {
23881         (char *) "self",(char *) "flag", NULL
23882     };
23883
23884     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetPrintToFile",kwnames,&obj0,&obj1)) goto fail;
23885     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23886     if (SWIG_arg_fail(1)) SWIG_fail;
23887     {
23888         arg2 = (bool)(SWIG_As_bool(obj1));
23889         if (SWIG_arg_fail(2)) SWIG_fail;
23890     }
23891     {
23892         PyThreadState* __tstate = wxPyBeginAllowThreads();
23893         (arg1)->SetPrintToFile(arg2);
23894
23895         wxPyEndAllowThreads(__tstate);
23896         if (PyErr_Occurred()) SWIG_fail;
23897     }
23898     Py_INCREF(Py_None); resultobj = Py_None;
23899     return resultobj;
23900     fail:
23901     return NULL;
23902 }
23903
23904
23905 static PyObject *_wrap_PrintDialogData_EnablePrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23906     PyObject *resultobj;
23907     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23908     bool arg2 ;
23909     PyObject * obj0 = 0 ;
23910     PyObject * obj1 = 0 ;
23911     char *kwnames[] = {
23912         (char *) "self",(char *) "flag", NULL
23913     };
23914
23915     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnablePrintToFile",kwnames,&obj0,&obj1)) goto fail;
23916     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23917     if (SWIG_arg_fail(1)) SWIG_fail;
23918     {
23919         arg2 = (bool)(SWIG_As_bool(obj1));
23920         if (SWIG_arg_fail(2)) SWIG_fail;
23921     }
23922     {
23923         PyThreadState* __tstate = wxPyBeginAllowThreads();
23924         (arg1)->EnablePrintToFile(arg2);
23925
23926         wxPyEndAllowThreads(__tstate);
23927         if (PyErr_Occurred()) SWIG_fail;
23928     }
23929     Py_INCREF(Py_None); resultobj = Py_None;
23930     return resultobj;
23931     fail:
23932     return NULL;
23933 }
23934
23935
23936 static PyObject *_wrap_PrintDialogData_EnableSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23937     PyObject *resultobj;
23938     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23939     bool arg2 ;
23940     PyObject * obj0 = 0 ;
23941     PyObject * obj1 = 0 ;
23942     char *kwnames[] = {
23943         (char *) "self",(char *) "flag", NULL
23944     };
23945
23946     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnableSelection",kwnames,&obj0,&obj1)) 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         arg2 = (bool)(SWIG_As_bool(obj1));
23951         if (SWIG_arg_fail(2)) SWIG_fail;
23952     }
23953     {
23954         PyThreadState* __tstate = wxPyBeginAllowThreads();
23955         (arg1)->EnableSelection(arg2);
23956
23957         wxPyEndAllowThreads(__tstate);
23958         if (PyErr_Occurred()) SWIG_fail;
23959     }
23960     Py_INCREF(Py_None); resultobj = Py_None;
23961     return resultobj;
23962     fail:
23963     return NULL;
23964 }
23965
23966
23967 static PyObject *_wrap_PrintDialogData_EnablePageNumbers(PyObject *, PyObject *args, PyObject *kwargs) {
23968     PyObject *resultobj;
23969     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23970     bool arg2 ;
23971     PyObject * obj0 = 0 ;
23972     PyObject * obj1 = 0 ;
23973     char *kwnames[] = {
23974         (char *) "self",(char *) "flag", NULL
23975     };
23976
23977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnablePageNumbers",kwnames,&obj0,&obj1)) goto fail;
23978     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23979     if (SWIG_arg_fail(1)) SWIG_fail;
23980     {
23981         arg2 = (bool)(SWIG_As_bool(obj1));
23982         if (SWIG_arg_fail(2)) SWIG_fail;
23983     }
23984     {
23985         PyThreadState* __tstate = wxPyBeginAllowThreads();
23986         (arg1)->EnablePageNumbers(arg2);
23987
23988         wxPyEndAllowThreads(__tstate);
23989         if (PyErr_Occurred()) SWIG_fail;
23990     }
23991     Py_INCREF(Py_None); resultobj = Py_None;
23992     return resultobj;
23993     fail:
23994     return NULL;
23995 }
23996
23997
23998 static PyObject *_wrap_PrintDialogData_EnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
23999     PyObject *resultobj;
24000     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24001     bool arg2 ;
24002     PyObject * obj0 = 0 ;
24003     PyObject * obj1 = 0 ;
24004     char *kwnames[] = {
24005         (char *) "self",(char *) "flag", NULL
24006     };
24007
24008     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnableHelp",kwnames,&obj0,&obj1)) goto fail;
24009     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24010     if (SWIG_arg_fail(1)) SWIG_fail;
24011     {
24012         arg2 = (bool)(SWIG_As_bool(obj1));
24013         if (SWIG_arg_fail(2)) SWIG_fail;
24014     }
24015     {
24016         PyThreadState* __tstate = wxPyBeginAllowThreads();
24017         (arg1)->EnableHelp(arg2);
24018
24019         wxPyEndAllowThreads(__tstate);
24020         if (PyErr_Occurred()) SWIG_fail;
24021     }
24022     Py_INCREF(Py_None); resultobj = Py_None;
24023     return resultobj;
24024     fail:
24025     return NULL;
24026 }
24027
24028
24029 static PyObject *_wrap_PrintDialogData_GetEnablePrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
24030     PyObject *resultobj;
24031     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24032     bool result;
24033     PyObject * obj0 = 0 ;
24034     char *kwnames[] = {
24035         (char *) "self", NULL
24036     };
24037
24038     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnablePrintToFile",kwnames,&obj0)) goto fail;
24039     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24040     if (SWIG_arg_fail(1)) SWIG_fail;
24041     {
24042         PyThreadState* __tstate = wxPyBeginAllowThreads();
24043         result = (bool)((wxPrintDialogData const *)arg1)->GetEnablePrintToFile();
24044
24045         wxPyEndAllowThreads(__tstate);
24046         if (PyErr_Occurred()) SWIG_fail;
24047     }
24048     {
24049         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24050     }
24051     return resultobj;
24052     fail:
24053     return NULL;
24054 }
24055
24056
24057 static PyObject *_wrap_PrintDialogData_GetEnableSelection(PyObject *, PyObject *args, PyObject *kwargs) {
24058     PyObject *resultobj;
24059     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24060     bool result;
24061     PyObject * obj0 = 0 ;
24062     char *kwnames[] = {
24063         (char *) "self", NULL
24064     };
24065
24066     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnableSelection",kwnames,&obj0)) goto fail;
24067     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24068     if (SWIG_arg_fail(1)) SWIG_fail;
24069     {
24070         PyThreadState* __tstate = wxPyBeginAllowThreads();
24071         result = (bool)((wxPrintDialogData const *)arg1)->GetEnableSelection();
24072
24073         wxPyEndAllowThreads(__tstate);
24074         if (PyErr_Occurred()) SWIG_fail;
24075     }
24076     {
24077         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24078     }
24079     return resultobj;
24080     fail:
24081     return NULL;
24082 }
24083
24084
24085 static PyObject *_wrap_PrintDialogData_GetEnablePageNumbers(PyObject *, PyObject *args, PyObject *kwargs) {
24086     PyObject *resultobj;
24087     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24088     bool result;
24089     PyObject * obj0 = 0 ;
24090     char *kwnames[] = {
24091         (char *) "self", NULL
24092     };
24093
24094     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnablePageNumbers",kwnames,&obj0)) goto fail;
24095     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24096     if (SWIG_arg_fail(1)) SWIG_fail;
24097     {
24098         PyThreadState* __tstate = wxPyBeginAllowThreads();
24099         result = (bool)((wxPrintDialogData const *)arg1)->GetEnablePageNumbers();
24100
24101         wxPyEndAllowThreads(__tstate);
24102         if (PyErr_Occurred()) SWIG_fail;
24103     }
24104     {
24105         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24106     }
24107     return resultobj;
24108     fail:
24109     return NULL;
24110 }
24111
24112
24113 static PyObject *_wrap_PrintDialogData_GetEnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
24114     PyObject *resultobj;
24115     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24116     bool result;
24117     PyObject * obj0 = 0 ;
24118     char *kwnames[] = {
24119         (char *) "self", NULL
24120     };
24121
24122     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnableHelp",kwnames,&obj0)) goto fail;
24123     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24124     if (SWIG_arg_fail(1)) SWIG_fail;
24125     {
24126         PyThreadState* __tstate = wxPyBeginAllowThreads();
24127         result = (bool)((wxPrintDialogData const *)arg1)->GetEnableHelp();
24128
24129         wxPyEndAllowThreads(__tstate);
24130         if (PyErr_Occurred()) SWIG_fail;
24131     }
24132     {
24133         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24134     }
24135     return resultobj;
24136     fail:
24137     return NULL;
24138 }
24139
24140
24141 static PyObject *_wrap_PrintDialogData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24142     PyObject *resultobj;
24143     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24144     bool result;
24145     PyObject * obj0 = 0 ;
24146     char *kwnames[] = {
24147         (char *) "self", NULL
24148     };
24149
24150     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_Ok",kwnames,&obj0)) goto fail;
24151     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24152     if (SWIG_arg_fail(1)) SWIG_fail;
24153     {
24154         PyThreadState* __tstate = wxPyBeginAllowThreads();
24155         result = (bool)((wxPrintDialogData const *)arg1)->Ok();
24156
24157         wxPyEndAllowThreads(__tstate);
24158         if (PyErr_Occurred()) SWIG_fail;
24159     }
24160     {
24161         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24162     }
24163     return resultobj;
24164     fail:
24165     return NULL;
24166 }
24167
24168
24169 static PyObject *_wrap_PrintDialogData_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24170     PyObject *resultobj;
24171     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24172     wxPrintData *result;
24173     PyObject * obj0 = 0 ;
24174     char *kwnames[] = {
24175         (char *) "self", NULL
24176     };
24177
24178     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetPrintData",kwnames,&obj0)) goto fail;
24179     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24180     if (SWIG_arg_fail(1)) SWIG_fail;
24181     {
24182         PyThreadState* __tstate = wxPyBeginAllowThreads();
24183         {
24184             wxPrintData &_result_ref = (arg1)->GetPrintData();
24185             result = (wxPrintData *) &_result_ref;
24186         }
24187
24188         wxPyEndAllowThreads(__tstate);
24189         if (PyErr_Occurred()) SWIG_fail;
24190     }
24191     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
24192     return resultobj;
24193     fail:
24194     return NULL;
24195 }
24196
24197
24198 static PyObject *_wrap_PrintDialogData_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24199     PyObject *resultobj;
24200     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24201     wxPrintData *arg2 = 0 ;
24202     PyObject * obj0 = 0 ;
24203     PyObject * obj1 = 0 ;
24204     char *kwnames[] = {
24205         (char *) "self",(char *) "printData", NULL
24206     };
24207
24208     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
24209     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24210     if (SWIG_arg_fail(1)) SWIG_fail;
24211     {
24212         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
24213         if (SWIG_arg_fail(2)) SWIG_fail;
24214         if (arg2 == NULL) {
24215             SWIG_null_ref("wxPrintData");
24216         }
24217         if (SWIG_arg_fail(2)) SWIG_fail;
24218     }
24219     {
24220         PyThreadState* __tstate = wxPyBeginAllowThreads();
24221         (arg1)->SetPrintData((wxPrintData const &)*arg2);
24222
24223         wxPyEndAllowThreads(__tstate);
24224         if (PyErr_Occurred()) SWIG_fail;
24225     }
24226     Py_INCREF(Py_None); resultobj = Py_None;
24227     return resultobj;
24228     fail:
24229     return NULL;
24230 }
24231
24232
24233 static PyObject * PrintDialogData_swigregister(PyObject *, PyObject *args) {
24234     PyObject *obj;
24235     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24236     SWIG_TypeClientData(SWIGTYPE_p_wxPrintDialogData, obj);
24237     Py_INCREF(obj);
24238     return Py_BuildValue((char *)"");
24239 }
24240 static PyObject *_wrap_new_PrintDialog(PyObject *, PyObject *args, PyObject *kwargs) {
24241     PyObject *resultobj;
24242     wxWindow *arg1 = (wxWindow *) 0 ;
24243     wxPrintDialogData *arg2 = (wxPrintDialogData *) NULL ;
24244     wxPrintDialog *result;
24245     PyObject * obj0 = 0 ;
24246     PyObject * obj1 = 0 ;
24247     char *kwnames[] = {
24248         (char *) "parent",(char *) "data", NULL
24249     };
24250
24251     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PrintDialog",kwnames,&obj0,&obj1)) goto fail;
24252     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24253     if (SWIG_arg_fail(1)) SWIG_fail;
24254     if (obj1) {
24255         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24256         if (SWIG_arg_fail(2)) SWIG_fail;
24257     }
24258     {
24259         if (!wxPyCheckForApp()) SWIG_fail;
24260         PyThreadState* __tstate = wxPyBeginAllowThreads();
24261         result = (wxPrintDialog *)new wxPrintDialog(arg1,arg2);
24262
24263         wxPyEndAllowThreads(__tstate);
24264         if (PyErr_Occurred()) SWIG_fail;
24265     }
24266     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialog, 1);
24267     return resultobj;
24268     fail:
24269     return NULL;
24270 }
24271
24272
24273 static PyObject *_wrap_PrintDialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
24274     PyObject *resultobj;
24275     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24276     int result;
24277     PyObject * obj0 = 0 ;
24278     char *kwnames[] = {
24279         (char *) "self", NULL
24280     };
24281
24282     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_ShowModal",kwnames,&obj0)) goto fail;
24283     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24284     if (SWIG_arg_fail(1)) SWIG_fail;
24285     {
24286         PyThreadState* __tstate = wxPyBeginAllowThreads();
24287         result = (int)(arg1)->ShowModal();
24288
24289         wxPyEndAllowThreads(__tstate);
24290         if (PyErr_Occurred()) SWIG_fail;
24291     }
24292     {
24293         resultobj = SWIG_From_int((int)(result));
24294     }
24295     return resultobj;
24296     fail:
24297     return NULL;
24298 }
24299
24300
24301 static PyObject *_wrap_PrintDialog_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
24302     PyObject *resultobj;
24303     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24304     wxPrintDialogData *result;
24305     PyObject * obj0 = 0 ;
24306     char *kwnames[] = {
24307         (char *) "self", NULL
24308     };
24309
24310     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintDialogData",kwnames,&obj0)) goto fail;
24311     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24312     if (SWIG_arg_fail(1)) SWIG_fail;
24313     {
24314         PyThreadState* __tstate = wxPyBeginAllowThreads();
24315         {
24316             wxPrintDialogData &_result_ref = (arg1)->GetPrintDialogData();
24317             result = (wxPrintDialogData *) &_result_ref;
24318         }
24319
24320         wxPyEndAllowThreads(__tstate);
24321         if (PyErr_Occurred()) SWIG_fail;
24322     }
24323     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
24324     return resultobj;
24325     fail:
24326     return NULL;
24327 }
24328
24329
24330 static PyObject *_wrap_PrintDialog_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24331     PyObject *resultobj;
24332     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24333     wxPrintData *result;
24334     PyObject * obj0 = 0 ;
24335     char *kwnames[] = {
24336         (char *) "self", NULL
24337     };
24338
24339     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintData",kwnames,&obj0)) goto fail;
24340     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24341     if (SWIG_arg_fail(1)) SWIG_fail;
24342     {
24343         PyThreadState* __tstate = wxPyBeginAllowThreads();
24344         {
24345             wxPrintData &_result_ref = (arg1)->GetPrintData();
24346             result = (wxPrintData *) &_result_ref;
24347         }
24348
24349         wxPyEndAllowThreads(__tstate);
24350         if (PyErr_Occurred()) SWIG_fail;
24351     }
24352     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
24353     return resultobj;
24354     fail:
24355     return NULL;
24356 }
24357
24358
24359 static PyObject *_wrap_PrintDialog_GetPrintDC(PyObject *, PyObject *args, PyObject *kwargs) {
24360     PyObject *resultobj;
24361     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24362     wxDC *result;
24363     PyObject * obj0 = 0 ;
24364     char *kwnames[] = {
24365         (char *) "self", NULL
24366     };
24367
24368     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintDC",kwnames,&obj0)) goto fail;
24369     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24370     if (SWIG_arg_fail(1)) SWIG_fail;
24371     {
24372         PyThreadState* __tstate = wxPyBeginAllowThreads();
24373         result = (wxDC *)(arg1)->GetPrintDC();
24374
24375         wxPyEndAllowThreads(__tstate);
24376         if (PyErr_Occurred()) SWIG_fail;
24377     }
24378     {
24379         resultobj = wxPyMake_wxObject(result, 1);
24380     }
24381     return resultobj;
24382     fail:
24383     return NULL;
24384 }
24385
24386
24387 static PyObject * PrintDialog_swigregister(PyObject *, PyObject *args) {
24388     PyObject *obj;
24389     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24390     SWIG_TypeClientData(SWIGTYPE_p_wxPrintDialog, obj);
24391     Py_INCREF(obj);
24392     return Py_BuildValue((char *)"");
24393 }
24394 static PyObject *_wrap_new_Printer(PyObject *, PyObject *args, PyObject *kwargs) {
24395     PyObject *resultobj;
24396     wxPrintDialogData *arg1 = (wxPrintDialogData *) NULL ;
24397     wxPrinter *result;
24398     PyObject * obj0 = 0 ;
24399     char *kwnames[] = {
24400         (char *) "data", NULL
24401     };
24402
24403     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Printer",kwnames,&obj0)) goto fail;
24404     if (obj0) {
24405         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24406         if (SWIG_arg_fail(1)) SWIG_fail;
24407     }
24408     {
24409         if (!wxPyCheckForApp()) SWIG_fail;
24410         PyThreadState* __tstate = wxPyBeginAllowThreads();
24411         result = (wxPrinter *)new wxPrinter(arg1);
24412
24413         wxPyEndAllowThreads(__tstate);
24414         if (PyErr_Occurred()) SWIG_fail;
24415     }
24416     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinter, 1);
24417     return resultobj;
24418     fail:
24419     return NULL;
24420 }
24421
24422
24423 static PyObject *_wrap_delete_Printer(PyObject *, PyObject *args, PyObject *kwargs) {
24424     PyObject *resultobj;
24425     wxPrinter *arg1 = (wxPrinter *) 0 ;
24426     PyObject * obj0 = 0 ;
24427     char *kwnames[] = {
24428         (char *) "self", NULL
24429     };
24430
24431     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Printer",kwnames,&obj0)) goto fail;
24432     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24433     if (SWIG_arg_fail(1)) SWIG_fail;
24434     {
24435         PyThreadState* __tstate = wxPyBeginAllowThreads();
24436         delete arg1;
24437
24438         wxPyEndAllowThreads(__tstate);
24439         if (PyErr_Occurred()) SWIG_fail;
24440     }
24441     Py_INCREF(Py_None); resultobj = Py_None;
24442     return resultobj;
24443     fail:
24444     return NULL;
24445 }
24446
24447
24448 static PyObject *_wrap_Printer_CreateAbortWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24449     PyObject *resultobj;
24450     wxPrinter *arg1 = (wxPrinter *) 0 ;
24451     wxWindow *arg2 = (wxWindow *) 0 ;
24452     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24453     wxWindow *result;
24454     PyObject * obj0 = 0 ;
24455     PyObject * obj1 = 0 ;
24456     PyObject * obj2 = 0 ;
24457     char *kwnames[] = {
24458         (char *) "self",(char *) "parent",(char *) "printout", NULL
24459     };
24460
24461     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printer_CreateAbortWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
24462     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24463     if (SWIG_arg_fail(1)) SWIG_fail;
24464     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24465     if (SWIG_arg_fail(2)) SWIG_fail;
24466     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24467     if (SWIG_arg_fail(3)) SWIG_fail;
24468     {
24469         PyThreadState* __tstate = wxPyBeginAllowThreads();
24470         result = (wxWindow *)(arg1)->CreateAbortWindow(arg2,arg3);
24471
24472         wxPyEndAllowThreads(__tstate);
24473         if (PyErr_Occurred()) SWIG_fail;
24474     }
24475     {
24476         resultobj = wxPyMake_wxObject(result, 0);
24477     }
24478     return resultobj;
24479     fail:
24480     return NULL;
24481 }
24482
24483
24484 static PyObject *_wrap_Printer_ReportError(PyObject *, PyObject *args, PyObject *kwargs) {
24485     PyObject *resultobj;
24486     wxPrinter *arg1 = (wxPrinter *) 0 ;
24487     wxWindow *arg2 = (wxWindow *) 0 ;
24488     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24489     wxString *arg4 = 0 ;
24490     bool temp4 = false ;
24491     PyObject * obj0 = 0 ;
24492     PyObject * obj1 = 0 ;
24493     PyObject * obj2 = 0 ;
24494     PyObject * obj3 = 0 ;
24495     char *kwnames[] = {
24496         (char *) "self",(char *) "parent",(char *) "printout",(char *) "message", NULL
24497     };
24498
24499     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Printer_ReportError",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24500     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24501     if (SWIG_arg_fail(1)) SWIG_fail;
24502     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24503     if (SWIG_arg_fail(2)) SWIG_fail;
24504     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24505     if (SWIG_arg_fail(3)) SWIG_fail;
24506     {
24507         arg4 = wxString_in_helper(obj3);
24508         if (arg4 == NULL) SWIG_fail;
24509         temp4 = true;
24510     }
24511     {
24512         PyThreadState* __tstate = wxPyBeginAllowThreads();
24513         (arg1)->ReportError(arg2,arg3,(wxString const &)*arg4);
24514
24515         wxPyEndAllowThreads(__tstate);
24516         if (PyErr_Occurred()) SWIG_fail;
24517     }
24518     Py_INCREF(Py_None); resultobj = Py_None;
24519     {
24520         if (temp4)
24521         delete arg4;
24522     }
24523     return resultobj;
24524     fail:
24525     {
24526         if (temp4)
24527         delete arg4;
24528     }
24529     return NULL;
24530 }
24531
24532
24533 static PyObject *_wrap_Printer_Setup(PyObject *, PyObject *args, PyObject *kwargs) {
24534     PyObject *resultobj;
24535     wxPrinter *arg1 = (wxPrinter *) 0 ;
24536     wxWindow *arg2 = (wxWindow *) 0 ;
24537     bool result;
24538     PyObject * obj0 = 0 ;
24539     PyObject * obj1 = 0 ;
24540     char *kwnames[] = {
24541         (char *) "self",(char *) "parent", NULL
24542     };
24543
24544     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printer_Setup",kwnames,&obj0,&obj1)) goto fail;
24545     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24546     if (SWIG_arg_fail(1)) SWIG_fail;
24547     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24548     if (SWIG_arg_fail(2)) SWIG_fail;
24549     {
24550         PyThreadState* __tstate = wxPyBeginAllowThreads();
24551         result = (bool)(arg1)->Setup(arg2);
24552
24553         wxPyEndAllowThreads(__tstate);
24554         if (PyErr_Occurred()) SWIG_fail;
24555     }
24556     {
24557         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24558     }
24559     return resultobj;
24560     fail:
24561     return NULL;
24562 }
24563
24564
24565 static PyObject *_wrap_Printer_Print(PyObject *, PyObject *args, PyObject *kwargs) {
24566     PyObject *resultobj;
24567     wxPrinter *arg1 = (wxPrinter *) 0 ;
24568     wxWindow *arg2 = (wxWindow *) 0 ;
24569     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24570     bool arg4 = (bool) true ;
24571     bool result;
24572     PyObject * obj0 = 0 ;
24573     PyObject * obj1 = 0 ;
24574     PyObject * obj2 = 0 ;
24575     PyObject * obj3 = 0 ;
24576     char *kwnames[] = {
24577         (char *) "self",(char *) "parent",(char *) "printout",(char *) "prompt", NULL
24578     };
24579
24580     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Printer_Print",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24581     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24582     if (SWIG_arg_fail(1)) SWIG_fail;
24583     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24584     if (SWIG_arg_fail(2)) SWIG_fail;
24585     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24586     if (SWIG_arg_fail(3)) SWIG_fail;
24587     if (obj3) {
24588         {
24589             arg4 = (bool)(SWIG_As_bool(obj3));
24590             if (SWIG_arg_fail(4)) SWIG_fail;
24591         }
24592     }
24593     {
24594         PyThreadState* __tstate = wxPyBeginAllowThreads();
24595         result = (bool)(arg1)->Print(arg2,arg3,arg4);
24596
24597         wxPyEndAllowThreads(__tstate);
24598         if (PyErr_Occurred()) SWIG_fail;
24599     }
24600     {
24601         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24602     }
24603     return resultobj;
24604     fail:
24605     return NULL;
24606 }
24607
24608
24609 static PyObject *_wrap_Printer_PrintDialog(PyObject *, PyObject *args, PyObject *kwargs) {
24610     PyObject *resultobj;
24611     wxPrinter *arg1 = (wxPrinter *) 0 ;
24612     wxWindow *arg2 = (wxWindow *) 0 ;
24613     wxDC *result;
24614     PyObject * obj0 = 0 ;
24615     PyObject * obj1 = 0 ;
24616     char *kwnames[] = {
24617         (char *) "self",(char *) "parent", NULL
24618     };
24619
24620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printer_PrintDialog",kwnames,&obj0,&obj1)) goto fail;
24621     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24622     if (SWIG_arg_fail(1)) SWIG_fail;
24623     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24624     if (SWIG_arg_fail(2)) SWIG_fail;
24625     {
24626         PyThreadState* __tstate = wxPyBeginAllowThreads();
24627         result = (wxDC *)(arg1)->PrintDialog(arg2);
24628
24629         wxPyEndAllowThreads(__tstate);
24630         if (PyErr_Occurred()) SWIG_fail;
24631     }
24632     {
24633         resultobj = wxPyMake_wxObject(result, 0);
24634     }
24635     return resultobj;
24636     fail:
24637     return NULL;
24638 }
24639
24640
24641 static PyObject *_wrap_Printer_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
24642     PyObject *resultobj;
24643     wxPrinter *arg1 = (wxPrinter *) 0 ;
24644     wxPrintDialogData *result;
24645     PyObject * obj0 = 0 ;
24646     char *kwnames[] = {
24647         (char *) "self", NULL
24648     };
24649
24650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printer_GetPrintDialogData",kwnames,&obj0)) goto fail;
24651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24652     if (SWIG_arg_fail(1)) SWIG_fail;
24653     {
24654         PyThreadState* __tstate = wxPyBeginAllowThreads();
24655         {
24656             wxPrintDialogData &_result_ref = ((wxPrinter const *)arg1)->GetPrintDialogData();
24657             result = (wxPrintDialogData *) &_result_ref;
24658         }
24659
24660         wxPyEndAllowThreads(__tstate);
24661         if (PyErr_Occurred()) SWIG_fail;
24662     }
24663     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
24664     return resultobj;
24665     fail:
24666     return NULL;
24667 }
24668
24669
24670 static PyObject *_wrap_Printer_GetAbort(PyObject *, PyObject *args, PyObject *kwargs) {
24671     PyObject *resultobj;
24672     wxPrinter *arg1 = (wxPrinter *) 0 ;
24673     bool result;
24674     PyObject * obj0 = 0 ;
24675     char *kwnames[] = {
24676         (char *) "self", NULL
24677     };
24678
24679     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printer_GetAbort",kwnames,&obj0)) goto fail;
24680     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24681     if (SWIG_arg_fail(1)) SWIG_fail;
24682     {
24683         PyThreadState* __tstate = wxPyBeginAllowThreads();
24684         result = (bool)(arg1)->GetAbort();
24685
24686         wxPyEndAllowThreads(__tstate);
24687         if (PyErr_Occurred()) SWIG_fail;
24688     }
24689     {
24690         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24691     }
24692     return resultobj;
24693     fail:
24694     return NULL;
24695 }
24696
24697
24698 static PyObject *_wrap_Printer_GetLastError(PyObject *, PyObject *args, PyObject *kwargs) {
24699     PyObject *resultobj;
24700     wxPrinterError result;
24701     char *kwnames[] = {
24702         NULL
24703     };
24704
24705     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Printer_GetLastError",kwnames)) goto fail;
24706     {
24707         PyThreadState* __tstate = wxPyBeginAllowThreads();
24708         result = (wxPrinterError)wxPrinter::GetLastError();
24709
24710         wxPyEndAllowThreads(__tstate);
24711         if (PyErr_Occurred()) SWIG_fail;
24712     }
24713     resultobj = SWIG_From_int((result));
24714     return resultobj;
24715     fail:
24716     return NULL;
24717 }
24718
24719
24720 static PyObject * Printer_swigregister(PyObject *, PyObject *args) {
24721     PyObject *obj;
24722     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24723     SWIG_TypeClientData(SWIGTYPE_p_wxPrinter, obj);
24724     Py_INCREF(obj);
24725     return Py_BuildValue((char *)"");
24726 }
24727 static PyObject *_wrap_new_Printout(PyObject *, PyObject *args, PyObject *kwargs) {
24728     PyObject *resultobj;
24729     wxString const &arg1_defvalue = wxPyPrintoutTitleStr ;
24730     wxString *arg1 = (wxString *) &arg1_defvalue ;
24731     wxPyPrintout *result;
24732     bool temp1 = false ;
24733     PyObject * obj0 = 0 ;
24734     char *kwnames[] = {
24735         (char *) "title", NULL
24736     };
24737
24738     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Printout",kwnames,&obj0)) goto fail;
24739     if (obj0) {
24740         {
24741             arg1 = wxString_in_helper(obj0);
24742             if (arg1 == NULL) SWIG_fail;
24743             temp1 = true;
24744         }
24745     }
24746     {
24747         if (!wxPyCheckForApp()) SWIG_fail;
24748         PyThreadState* __tstate = wxPyBeginAllowThreads();
24749         result = (wxPyPrintout *)new wxPyPrintout((wxString const &)*arg1);
24750
24751         wxPyEndAllowThreads(__tstate);
24752         if (PyErr_Occurred()) SWIG_fail;
24753     }
24754     {
24755         resultobj = wxPyMake_wxObject(result, 1);
24756     }
24757     {
24758         if (temp1)
24759         delete arg1;
24760     }
24761     return resultobj;
24762     fail:
24763     {
24764         if (temp1)
24765         delete arg1;
24766     }
24767     return NULL;
24768 }
24769
24770
24771 static PyObject *_wrap_Printout__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
24772     PyObject *resultobj;
24773     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24774     PyObject *arg2 = (PyObject *) 0 ;
24775     PyObject *arg3 = (PyObject *) 0 ;
24776     PyObject * obj0 = 0 ;
24777     PyObject * obj1 = 0 ;
24778     PyObject * obj2 = 0 ;
24779     char *kwnames[] = {
24780         (char *) "self",(char *) "self",(char *) "_class", NULL
24781     };
24782
24783     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
24784     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24785     if (SWIG_arg_fail(1)) SWIG_fail;
24786     arg2 = obj1;
24787     arg3 = obj2;
24788     {
24789         PyThreadState* __tstate = wxPyBeginAllowThreads();
24790         (arg1)->_setCallbackInfo(arg2,arg3);
24791
24792         wxPyEndAllowThreads(__tstate);
24793         if (PyErr_Occurred()) SWIG_fail;
24794     }
24795     Py_INCREF(Py_None); resultobj = Py_None;
24796     return resultobj;
24797     fail:
24798     return NULL;
24799 }
24800
24801
24802 static PyObject *_wrap_Printout_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24803     PyObject *resultobj;
24804     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24805     wxString result;
24806     PyObject * obj0 = 0 ;
24807     char *kwnames[] = {
24808         (char *) "self", NULL
24809     };
24810
24811     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetTitle",kwnames,&obj0)) goto fail;
24812     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24813     if (SWIG_arg_fail(1)) SWIG_fail;
24814     {
24815         PyThreadState* __tstate = wxPyBeginAllowThreads();
24816         result = ((wxPyPrintout const *)arg1)->GetTitle();
24817
24818         wxPyEndAllowThreads(__tstate);
24819         if (PyErr_Occurred()) SWIG_fail;
24820     }
24821     {
24822 #if wxUSE_UNICODE
24823         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24824 #else
24825         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24826 #endif
24827     }
24828     return resultobj;
24829     fail:
24830     return NULL;
24831 }
24832
24833
24834 static PyObject *_wrap_Printout_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
24835     PyObject *resultobj;
24836     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24837     wxDC *result;
24838     PyObject * obj0 = 0 ;
24839     char *kwnames[] = {
24840         (char *) "self", NULL
24841     };
24842
24843     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetDC",kwnames,&obj0)) goto fail;
24844     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24845     if (SWIG_arg_fail(1)) SWIG_fail;
24846     {
24847         PyThreadState* __tstate = wxPyBeginAllowThreads();
24848         result = (wxDC *)(arg1)->GetDC();
24849
24850         wxPyEndAllowThreads(__tstate);
24851         if (PyErr_Occurred()) SWIG_fail;
24852     }
24853     {
24854         resultobj = wxPyMake_wxObject(result, 0);
24855     }
24856     return resultobj;
24857     fail:
24858     return NULL;
24859 }
24860
24861
24862 static PyObject *_wrap_Printout_SetDC(PyObject *, PyObject *args, PyObject *kwargs) {
24863     PyObject *resultobj;
24864     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24865     wxDC *arg2 = (wxDC *) 0 ;
24866     PyObject * obj0 = 0 ;
24867     PyObject * obj1 = 0 ;
24868     char *kwnames[] = {
24869         (char *) "self",(char *) "dc", NULL
24870     };
24871
24872     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetDC",kwnames,&obj0,&obj1)) goto fail;
24873     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24874     if (SWIG_arg_fail(1)) SWIG_fail;
24875     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
24876     if (SWIG_arg_fail(2)) SWIG_fail;
24877     {
24878         PyThreadState* __tstate = wxPyBeginAllowThreads();
24879         (arg1)->SetDC(arg2);
24880
24881         wxPyEndAllowThreads(__tstate);
24882         if (PyErr_Occurred()) SWIG_fail;
24883     }
24884     Py_INCREF(Py_None); resultobj = Py_None;
24885     return resultobj;
24886     fail:
24887     return NULL;
24888 }
24889
24890
24891 static PyObject *_wrap_Printout_SetPageSizePixels(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 *) "w",(char *) "h", NULL
24901     };
24902
24903     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPageSizePixels",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)->SetPageSizePixels(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_GetPageSizePixels(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_GetPageSizePixels",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)->GetPageSizePixels(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_SetPageSizeMM(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 *) "w",(char *) "h", NULL
24975     };
24976
24977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPageSizeMM",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)->SetPageSizeMM(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_GetPageSizeMM(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_GetPageSizeMM",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)->GetPageSizeMM(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_SetPPIScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25040     PyObject *resultobj;
25041     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25042     int arg2 ;
25043     int arg3 ;
25044     PyObject * obj0 = 0 ;
25045     PyObject * obj1 = 0 ;
25046     PyObject * obj2 = 0 ;
25047     char *kwnames[] = {
25048         (char *) "self",(char *) "x",(char *) "y", NULL
25049     };
25050
25051     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPPIScreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
25052     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25053     if (SWIG_arg_fail(1)) SWIG_fail;
25054     {
25055         arg2 = (int)(SWIG_As_int(obj1));
25056         if (SWIG_arg_fail(2)) SWIG_fail;
25057     }
25058     {
25059         arg3 = (int)(SWIG_As_int(obj2));
25060         if (SWIG_arg_fail(3)) SWIG_fail;
25061     }
25062     {
25063         PyThreadState* __tstate = wxPyBeginAllowThreads();
25064         (arg1)->SetPPIScreen(arg2,arg3);
25065
25066         wxPyEndAllowThreads(__tstate);
25067         if (PyErr_Occurred()) SWIG_fail;
25068     }
25069     Py_INCREF(Py_None); resultobj = Py_None;
25070     return resultobj;
25071     fail:
25072     return NULL;
25073 }
25074
25075
25076 static PyObject *_wrap_Printout_GetPPIScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25077     PyObject *resultobj;
25078     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25079     int *arg2 = (int *) 0 ;
25080     int *arg3 = (int *) 0 ;
25081     int temp2 ;
25082     int res2 = 0 ;
25083     int temp3 ;
25084     int res3 = 0 ;
25085     PyObject * obj0 = 0 ;
25086     char *kwnames[] = {
25087         (char *) "self", NULL
25088     };
25089
25090     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25091     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25092     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPPIScreen",kwnames,&obj0)) goto fail;
25093     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25094     if (SWIG_arg_fail(1)) SWIG_fail;
25095     {
25096         PyThreadState* __tstate = wxPyBeginAllowThreads();
25097         (arg1)->GetPPIScreen(arg2,arg3);
25098
25099         wxPyEndAllowThreads(__tstate);
25100         if (PyErr_Occurred()) SWIG_fail;
25101     }
25102     Py_INCREF(Py_None); resultobj = Py_None;
25103     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25104     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25105     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25106     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25107     return resultobj;
25108     fail:
25109     return NULL;
25110 }
25111
25112
25113 static PyObject *_wrap_Printout_SetPPIPrinter(PyObject *, PyObject *args, PyObject *kwargs) {
25114     PyObject *resultobj;
25115     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25116     int arg2 ;
25117     int arg3 ;
25118     PyObject * obj0 = 0 ;
25119     PyObject * obj1 = 0 ;
25120     PyObject * obj2 = 0 ;
25121     char *kwnames[] = {
25122         (char *) "self",(char *) "x",(char *) "y", NULL
25123     };
25124
25125     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPPIPrinter",kwnames,&obj0,&obj1,&obj2)) goto fail;
25126     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25127     if (SWIG_arg_fail(1)) SWIG_fail;
25128     {
25129         arg2 = (int)(SWIG_As_int(obj1));
25130         if (SWIG_arg_fail(2)) SWIG_fail;
25131     }
25132     {
25133         arg3 = (int)(SWIG_As_int(obj2));
25134         if (SWIG_arg_fail(3)) SWIG_fail;
25135     }
25136     {
25137         PyThreadState* __tstate = wxPyBeginAllowThreads();
25138         (arg1)->SetPPIPrinter(arg2,arg3);
25139
25140         wxPyEndAllowThreads(__tstate);
25141         if (PyErr_Occurred()) SWIG_fail;
25142     }
25143     Py_INCREF(Py_None); resultobj = Py_None;
25144     return resultobj;
25145     fail:
25146     return NULL;
25147 }
25148
25149
25150 static PyObject *_wrap_Printout_GetPPIPrinter(PyObject *, PyObject *args, PyObject *kwargs) {
25151     PyObject *resultobj;
25152     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25153     int *arg2 = (int *) 0 ;
25154     int *arg3 = (int *) 0 ;
25155     int temp2 ;
25156     int res2 = 0 ;
25157     int temp3 ;
25158     int res3 = 0 ;
25159     PyObject * obj0 = 0 ;
25160     char *kwnames[] = {
25161         (char *) "self", NULL
25162     };
25163
25164     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25165     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25166     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPPIPrinter",kwnames,&obj0)) goto fail;
25167     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25168     if (SWIG_arg_fail(1)) SWIG_fail;
25169     {
25170         PyThreadState* __tstate = wxPyBeginAllowThreads();
25171         (arg1)->GetPPIPrinter(arg2,arg3);
25172
25173         wxPyEndAllowThreads(__tstate);
25174         if (PyErr_Occurred()) SWIG_fail;
25175     }
25176     Py_INCREF(Py_None); resultobj = Py_None;
25177     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25178     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25179     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25180     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25181     return resultobj;
25182     fail:
25183     return NULL;
25184 }
25185
25186
25187 static PyObject *_wrap_Printout_IsPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25188     PyObject *resultobj;
25189     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25190     bool result;
25191     PyObject * obj0 = 0 ;
25192     char *kwnames[] = {
25193         (char *) "self", NULL
25194     };
25195
25196     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_IsPreview",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         result = (bool)(arg1)->IsPreview();
25202
25203         wxPyEndAllowThreads(__tstate);
25204         if (PyErr_Occurred()) SWIG_fail;
25205     }
25206     {
25207         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25208     }
25209     return resultobj;
25210     fail:
25211     return NULL;
25212 }
25213
25214
25215 static PyObject *_wrap_Printout_SetIsPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25216     PyObject *resultobj;
25217     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25218     bool arg2 ;
25219     PyObject * obj0 = 0 ;
25220     PyObject * obj1 = 0 ;
25221     char *kwnames[] = {
25222         (char *) "self",(char *) "p", NULL
25223     };
25224
25225     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetIsPreview",kwnames,&obj0,&obj1)) goto fail;
25226     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25227     if (SWIG_arg_fail(1)) SWIG_fail;
25228     {
25229         arg2 = (bool)(SWIG_As_bool(obj1));
25230         if (SWIG_arg_fail(2)) SWIG_fail;
25231     }
25232     {
25233         PyThreadState* __tstate = wxPyBeginAllowThreads();
25234         (arg1)->SetIsPreview(arg2);
25235
25236         wxPyEndAllowThreads(__tstate);
25237         if (PyErr_Occurred()) SWIG_fail;
25238     }
25239     Py_INCREF(Py_None); resultobj = Py_None;
25240     return resultobj;
25241     fail:
25242     return NULL;
25243 }
25244
25245
25246 static PyObject *_wrap_Printout_base_OnBeginDocument(PyObject *, PyObject *args, PyObject *kwargs) {
25247     PyObject *resultobj;
25248     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25249     int arg2 ;
25250     int arg3 ;
25251     bool result;
25252     PyObject * obj0 = 0 ;
25253     PyObject * obj1 = 0 ;
25254     PyObject * obj2 = 0 ;
25255     char *kwnames[] = {
25256         (char *) "self",(char *) "startPage",(char *) "endPage", NULL
25257     };
25258
25259     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_base_OnBeginDocument",kwnames,&obj0,&obj1,&obj2)) goto fail;
25260     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25261     if (SWIG_arg_fail(1)) SWIG_fail;
25262     {
25263         arg2 = (int)(SWIG_As_int(obj1));
25264         if (SWIG_arg_fail(2)) SWIG_fail;
25265     }
25266     {
25267         arg3 = (int)(SWIG_As_int(obj2));
25268         if (SWIG_arg_fail(3)) SWIG_fail;
25269     }
25270     {
25271         PyThreadState* __tstate = wxPyBeginAllowThreads();
25272         result = (bool)(arg1)->base_OnBeginDocument(arg2,arg3);
25273
25274         wxPyEndAllowThreads(__tstate);
25275         if (PyErr_Occurred()) SWIG_fail;
25276     }
25277     {
25278         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25279     }
25280     return resultobj;
25281     fail:
25282     return NULL;
25283 }
25284
25285
25286 static PyObject *_wrap_Printout_base_OnEndDocument(PyObject *, PyObject *args, PyObject *kwargs) {
25287     PyObject *resultobj;
25288     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25289     PyObject * obj0 = 0 ;
25290     char *kwnames[] = {
25291         (char *) "self", NULL
25292     };
25293
25294     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnEndDocument",kwnames,&obj0)) goto fail;
25295     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25296     if (SWIG_arg_fail(1)) SWIG_fail;
25297     {
25298         PyThreadState* __tstate = wxPyBeginAllowThreads();
25299         (arg1)->base_OnEndDocument();
25300
25301         wxPyEndAllowThreads(__tstate);
25302         if (PyErr_Occurred()) SWIG_fail;
25303     }
25304     Py_INCREF(Py_None); resultobj = Py_None;
25305     return resultobj;
25306     fail:
25307     return NULL;
25308 }
25309
25310
25311 static PyObject *_wrap_Printout_base_OnBeginPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25312     PyObject *resultobj;
25313     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25314     PyObject * obj0 = 0 ;
25315     char *kwnames[] = {
25316         (char *) "self", NULL
25317     };
25318
25319     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnBeginPrinting",kwnames,&obj0)) goto fail;
25320     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25321     if (SWIG_arg_fail(1)) SWIG_fail;
25322     {
25323         PyThreadState* __tstate = wxPyBeginAllowThreads();
25324         (arg1)->base_OnBeginPrinting();
25325
25326         wxPyEndAllowThreads(__tstate);
25327         if (PyErr_Occurred()) SWIG_fail;
25328     }
25329     Py_INCREF(Py_None); resultobj = Py_None;
25330     return resultobj;
25331     fail:
25332     return NULL;
25333 }
25334
25335
25336 static PyObject *_wrap_Printout_base_OnEndPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25337     PyObject *resultobj;
25338     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25339     PyObject * obj0 = 0 ;
25340     char *kwnames[] = {
25341         (char *) "self", NULL
25342     };
25343
25344     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnEndPrinting",kwnames,&obj0)) goto fail;
25345     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25346     if (SWIG_arg_fail(1)) SWIG_fail;
25347     {
25348         PyThreadState* __tstate = wxPyBeginAllowThreads();
25349         (arg1)->base_OnEndPrinting();
25350
25351         wxPyEndAllowThreads(__tstate);
25352         if (PyErr_Occurred()) SWIG_fail;
25353     }
25354     Py_INCREF(Py_None); resultobj = Py_None;
25355     return resultobj;
25356     fail:
25357     return NULL;
25358 }
25359
25360
25361 static PyObject *_wrap_Printout_base_OnPreparePrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25362     PyObject *resultobj;
25363     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25364     PyObject * obj0 = 0 ;
25365     char *kwnames[] = {
25366         (char *) "self", NULL
25367     };
25368
25369     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnPreparePrinting",kwnames,&obj0)) goto fail;
25370     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25371     if (SWIG_arg_fail(1)) SWIG_fail;
25372     {
25373         PyThreadState* __tstate = wxPyBeginAllowThreads();
25374         (arg1)->base_OnPreparePrinting();
25375
25376         wxPyEndAllowThreads(__tstate);
25377         if (PyErr_Occurred()) SWIG_fail;
25378     }
25379     Py_INCREF(Py_None); resultobj = Py_None;
25380     return resultobj;
25381     fail:
25382     return NULL;
25383 }
25384
25385
25386 static PyObject *_wrap_Printout_base_HasPage(PyObject *, PyObject *args, PyObject *kwargs) {
25387     PyObject *resultobj;
25388     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25389     int arg2 ;
25390     bool result;
25391     PyObject * obj0 = 0 ;
25392     PyObject * obj1 = 0 ;
25393     char *kwnames[] = {
25394         (char *) "self",(char *) "page", NULL
25395     };
25396
25397     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_base_HasPage",kwnames,&obj0,&obj1)) goto fail;
25398     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25399     if (SWIG_arg_fail(1)) SWIG_fail;
25400     {
25401         arg2 = (int)(SWIG_As_int(obj1));
25402         if (SWIG_arg_fail(2)) SWIG_fail;
25403     }
25404     {
25405         PyThreadState* __tstate = wxPyBeginAllowThreads();
25406         result = (bool)(arg1)->base_HasPage(arg2);
25407
25408         wxPyEndAllowThreads(__tstate);
25409         if (PyErr_Occurred()) SWIG_fail;
25410     }
25411     {
25412         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25413     }
25414     return resultobj;
25415     fail:
25416     return NULL;
25417 }
25418
25419
25420 static PyObject *_wrap_Printout_base_GetPageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
25421     PyObject *resultobj;
25422     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25423     int *arg2 = (int *) 0 ;
25424     int *arg3 = (int *) 0 ;
25425     int *arg4 = (int *) 0 ;
25426     int *arg5 = (int *) 0 ;
25427     int temp2 ;
25428     int res2 = 0 ;
25429     int temp3 ;
25430     int res3 = 0 ;
25431     int temp4 ;
25432     int res4 = 0 ;
25433     int temp5 ;
25434     int res5 = 0 ;
25435     PyObject * obj0 = 0 ;
25436     char *kwnames[] = {
25437         (char *) "self", NULL
25438     };
25439
25440     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25441     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25442     arg4 = &temp4; res4 = SWIG_NEWOBJ;
25443     arg5 = &temp5; res5 = SWIG_NEWOBJ;
25444     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_GetPageInfo",kwnames,&obj0)) goto fail;
25445     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25446     if (SWIG_arg_fail(1)) SWIG_fail;
25447     {
25448         PyThreadState* __tstate = wxPyBeginAllowThreads();
25449         (arg1)->base_GetPageInfo(arg2,arg3,arg4,arg5);
25450
25451         wxPyEndAllowThreads(__tstate);
25452         if (PyErr_Occurred()) SWIG_fail;
25453     }
25454     Py_INCREF(Py_None); resultobj = Py_None;
25455     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25456     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25457     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25458     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25459     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
25460     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
25461     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
25462     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
25463     return resultobj;
25464     fail:
25465     return NULL;
25466 }
25467
25468
25469 static PyObject * Printout_swigregister(PyObject *, PyObject *args) {
25470     PyObject *obj;
25471     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25472     SWIG_TypeClientData(SWIGTYPE_p_wxPyPrintout, obj);
25473     Py_INCREF(obj);
25474     return Py_BuildValue((char *)"");
25475 }
25476 static PyObject *_wrap_new_PreviewCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
25477     PyObject *resultobj;
25478     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25479     wxWindow *arg2 = (wxWindow *) 0 ;
25480     wxPoint const &arg3_defvalue = wxDefaultPosition ;
25481     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25482     wxSize const &arg4_defvalue = wxDefaultSize ;
25483     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25484     long arg5 = (long) 0 ;
25485     wxString const &arg6_defvalue = wxPyPreviewCanvasNameStr ;
25486     wxString *arg6 = (wxString *) &arg6_defvalue ;
25487     wxPreviewCanvas *result;
25488     wxPoint temp3 ;
25489     wxSize temp4 ;
25490     bool temp6 = false ;
25491     PyObject * obj0 = 0 ;
25492     PyObject * obj1 = 0 ;
25493     PyObject * obj2 = 0 ;
25494     PyObject * obj3 = 0 ;
25495     PyObject * obj4 = 0 ;
25496     PyObject * obj5 = 0 ;
25497     char *kwnames[] = {
25498         (char *) "preview",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25499     };
25500
25501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_PreviewCanvas",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25502     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25503     if (SWIG_arg_fail(1)) SWIG_fail;
25504     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25505     if (SWIG_arg_fail(2)) SWIG_fail;
25506     if (obj2) {
25507         {
25508             arg3 = &temp3;
25509             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25510         }
25511     }
25512     if (obj3) {
25513         {
25514             arg4 = &temp4;
25515             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25516         }
25517     }
25518     if (obj4) {
25519         {
25520             arg5 = (long)(SWIG_As_long(obj4));
25521             if (SWIG_arg_fail(5)) SWIG_fail;
25522         }
25523     }
25524     if (obj5) {
25525         {
25526             arg6 = wxString_in_helper(obj5);
25527             if (arg6 == NULL) SWIG_fail;
25528             temp6 = true;
25529         }
25530     }
25531     {
25532         if (!wxPyCheckForApp()) SWIG_fail;
25533         PyThreadState* __tstate = wxPyBeginAllowThreads();
25534         result = (wxPreviewCanvas *)new wxPreviewCanvas(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25535
25536         wxPyEndAllowThreads(__tstate);
25537         if (PyErr_Occurred()) SWIG_fail;
25538     }
25539     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewCanvas, 1);
25540     {
25541         if (temp6)
25542         delete arg6;
25543     }
25544     return resultobj;
25545     fail:
25546     {
25547         if (temp6)
25548         delete arg6;
25549     }
25550     return NULL;
25551 }
25552
25553
25554 static PyObject * PreviewCanvas_swigregister(PyObject *, PyObject *args) {
25555     PyObject *obj;
25556     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25557     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewCanvas, obj);
25558     Py_INCREF(obj);
25559     return Py_BuildValue((char *)"");
25560 }
25561 static PyObject *_wrap_new_PreviewFrame(PyObject *, PyObject *args, PyObject *kwargs) {
25562     PyObject *resultobj;
25563     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25564     wxFrame *arg2 = (wxFrame *) 0 ;
25565     wxString *arg3 = 0 ;
25566     wxPoint const &arg4_defvalue = wxDefaultPosition ;
25567     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25568     wxSize const &arg5_defvalue = wxDefaultSize ;
25569     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25570     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
25571     wxString const &arg7_defvalue = wxPyFrameNameStr ;
25572     wxString *arg7 = (wxString *) &arg7_defvalue ;
25573     wxPreviewFrame *result;
25574     bool temp3 = false ;
25575     wxPoint temp4 ;
25576     wxSize temp5 ;
25577     bool temp7 = false ;
25578     PyObject * obj0 = 0 ;
25579     PyObject * obj1 = 0 ;
25580     PyObject * obj2 = 0 ;
25581     PyObject * obj3 = 0 ;
25582     PyObject * obj4 = 0 ;
25583     PyObject * obj5 = 0 ;
25584     PyObject * obj6 = 0 ;
25585     char *kwnames[] = {
25586         (char *) "preview",(char *) "parent",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25587     };
25588
25589     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PreviewFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25590     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25591     if (SWIG_arg_fail(1)) SWIG_fail;
25592     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
25593     if (SWIG_arg_fail(2)) SWIG_fail;
25594     {
25595         arg3 = wxString_in_helper(obj2);
25596         if (arg3 == NULL) SWIG_fail;
25597         temp3 = true;
25598     }
25599     if (obj3) {
25600         {
25601             arg4 = &temp4;
25602             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25603         }
25604     }
25605     if (obj4) {
25606         {
25607             arg5 = &temp5;
25608             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25609         }
25610     }
25611     if (obj5) {
25612         {
25613             arg6 = (long)(SWIG_As_long(obj5));
25614             if (SWIG_arg_fail(6)) SWIG_fail;
25615         }
25616     }
25617     if (obj6) {
25618         {
25619             arg7 = wxString_in_helper(obj6);
25620             if (arg7 == NULL) SWIG_fail;
25621             temp7 = true;
25622         }
25623     }
25624     {
25625         if (!wxPyCheckForApp()) SWIG_fail;
25626         PyThreadState* __tstate = wxPyBeginAllowThreads();
25627         result = (wxPreviewFrame *)new wxPreviewFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25628
25629         wxPyEndAllowThreads(__tstate);
25630         if (PyErr_Occurred()) SWIG_fail;
25631     }
25632     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewFrame, 1);
25633     {
25634         if (temp3)
25635         delete arg3;
25636     }
25637     {
25638         if (temp7)
25639         delete arg7;
25640     }
25641     return resultobj;
25642     fail:
25643     {
25644         if (temp3)
25645         delete arg3;
25646     }
25647     {
25648         if (temp7)
25649         delete arg7;
25650     }
25651     return NULL;
25652 }
25653
25654
25655 static PyObject *_wrap_PreviewFrame_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
25656     PyObject *resultobj;
25657     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25658     PyObject * obj0 = 0 ;
25659     char *kwnames[] = {
25660         (char *) "self", NULL
25661     };
25662
25663     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_Initialize",kwnames,&obj0)) goto fail;
25664     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25665     if (SWIG_arg_fail(1)) SWIG_fail;
25666     {
25667         PyThreadState* __tstate = wxPyBeginAllowThreads();
25668         (arg1)->Initialize();
25669
25670         wxPyEndAllowThreads(__tstate);
25671         if (PyErr_Occurred()) SWIG_fail;
25672     }
25673     Py_INCREF(Py_None); resultobj = Py_None;
25674     return resultobj;
25675     fail:
25676     return NULL;
25677 }
25678
25679
25680 static PyObject *_wrap_PreviewFrame_CreateControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25681     PyObject *resultobj;
25682     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25683     PyObject * obj0 = 0 ;
25684     char *kwnames[] = {
25685         (char *) "self", NULL
25686     };
25687
25688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_CreateControlBar",kwnames,&obj0)) goto fail;
25689     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25690     if (SWIG_arg_fail(1)) SWIG_fail;
25691     {
25692         PyThreadState* __tstate = wxPyBeginAllowThreads();
25693         (arg1)->CreateControlBar();
25694
25695         wxPyEndAllowThreads(__tstate);
25696         if (PyErr_Occurred()) SWIG_fail;
25697     }
25698     Py_INCREF(Py_None); resultobj = Py_None;
25699     return resultobj;
25700     fail:
25701     return NULL;
25702 }
25703
25704
25705 static PyObject *_wrap_PreviewFrame_CreateCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
25706     PyObject *resultobj;
25707     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25708     PyObject * obj0 = 0 ;
25709     char *kwnames[] = {
25710         (char *) "self", NULL
25711     };
25712
25713     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_CreateCanvas",kwnames,&obj0)) goto fail;
25714     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25715     if (SWIG_arg_fail(1)) SWIG_fail;
25716     {
25717         PyThreadState* __tstate = wxPyBeginAllowThreads();
25718         (arg1)->CreateCanvas();
25719
25720         wxPyEndAllowThreads(__tstate);
25721         if (PyErr_Occurred()) SWIG_fail;
25722     }
25723     Py_INCREF(Py_None); resultobj = Py_None;
25724     return resultobj;
25725     fail:
25726     return NULL;
25727 }
25728
25729
25730 static PyObject *_wrap_PreviewFrame_GetControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25731     PyObject *resultobj;
25732     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25733     wxPreviewControlBar *result;
25734     PyObject * obj0 = 0 ;
25735     char *kwnames[] = {
25736         (char *) "self", NULL
25737     };
25738
25739     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_GetControlBar",kwnames,&obj0)) goto fail;
25740     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25741     if (SWIG_arg_fail(1)) SWIG_fail;
25742     {
25743         PyThreadState* __tstate = wxPyBeginAllowThreads();
25744         result = (wxPreviewControlBar *)((wxPreviewFrame const *)arg1)->GetControlBar();
25745
25746         wxPyEndAllowThreads(__tstate);
25747         if (PyErr_Occurred()) SWIG_fail;
25748     }
25749     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewControlBar, 0);
25750     return resultobj;
25751     fail:
25752     return NULL;
25753 }
25754
25755
25756 static PyObject * PreviewFrame_swigregister(PyObject *, PyObject *args) {
25757     PyObject *obj;
25758     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25759     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewFrame, obj);
25760     Py_INCREF(obj);
25761     return Py_BuildValue((char *)"");
25762 }
25763 static PyObject *_wrap_new_PreviewControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25764     PyObject *resultobj;
25765     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25766     long arg2 ;
25767     wxWindow *arg3 = (wxWindow *) 0 ;
25768     wxPoint const &arg4_defvalue = wxDefaultPosition ;
25769     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25770     wxSize const &arg5_defvalue = wxDefaultSize ;
25771     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25772     long arg6 = (long) wxTAB_TRAVERSAL ;
25773     wxString const &arg7_defvalue = wxPyPanelNameStr ;
25774     wxString *arg7 = (wxString *) &arg7_defvalue ;
25775     wxPreviewControlBar *result;
25776     wxPoint temp4 ;
25777     wxSize temp5 ;
25778     bool temp7 = false ;
25779     PyObject * obj0 = 0 ;
25780     PyObject * obj1 = 0 ;
25781     PyObject * obj2 = 0 ;
25782     PyObject * obj3 = 0 ;
25783     PyObject * obj4 = 0 ;
25784     PyObject * obj5 = 0 ;
25785     PyObject * obj6 = 0 ;
25786     char *kwnames[] = {
25787         (char *) "preview",(char *) "buttons",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25788     };
25789
25790     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PreviewControlBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25791     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25792     if (SWIG_arg_fail(1)) SWIG_fail;
25793     {
25794         arg2 = (long)(SWIG_As_long(obj1));
25795         if (SWIG_arg_fail(2)) SWIG_fail;
25796     }
25797     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25798     if (SWIG_arg_fail(3)) SWIG_fail;
25799     if (obj3) {
25800         {
25801             arg4 = &temp4;
25802             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25803         }
25804     }
25805     if (obj4) {
25806         {
25807             arg5 = &temp5;
25808             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25809         }
25810     }
25811     if (obj5) {
25812         {
25813             arg6 = (long)(SWIG_As_long(obj5));
25814             if (SWIG_arg_fail(6)) SWIG_fail;
25815         }
25816     }
25817     if (obj6) {
25818         {
25819             arg7 = wxString_in_helper(obj6);
25820             if (arg7 == NULL) SWIG_fail;
25821             temp7 = true;
25822         }
25823     }
25824     {
25825         if (!wxPyCheckForApp()) SWIG_fail;
25826         PyThreadState* __tstate = wxPyBeginAllowThreads();
25827         result = (wxPreviewControlBar *)new wxPreviewControlBar(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25828
25829         wxPyEndAllowThreads(__tstate);
25830         if (PyErr_Occurred()) SWIG_fail;
25831     }
25832     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewControlBar, 1);
25833     {
25834         if (temp7)
25835         delete arg7;
25836     }
25837     return resultobj;
25838     fail:
25839     {
25840         if (temp7)
25841         delete arg7;
25842     }
25843     return NULL;
25844 }
25845
25846
25847 static PyObject *_wrap_PreviewControlBar_GetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
25848     PyObject *resultobj;
25849     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25850     int result;
25851     PyObject * obj0 = 0 ;
25852     char *kwnames[] = {
25853         (char *) "self", NULL
25854     };
25855
25856     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_GetZoomControl",kwnames,&obj0)) goto fail;
25857     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25858     if (SWIG_arg_fail(1)) SWIG_fail;
25859     {
25860         PyThreadState* __tstate = wxPyBeginAllowThreads();
25861         result = (int)(arg1)->GetZoomControl();
25862
25863         wxPyEndAllowThreads(__tstate);
25864         if (PyErr_Occurred()) SWIG_fail;
25865     }
25866     {
25867         resultobj = SWIG_From_int((int)(result));
25868     }
25869     return resultobj;
25870     fail:
25871     return NULL;
25872 }
25873
25874
25875 static PyObject *_wrap_PreviewControlBar_SetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
25876     PyObject *resultobj;
25877     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25878     int arg2 ;
25879     PyObject * obj0 = 0 ;
25880     PyObject * obj1 = 0 ;
25881     char *kwnames[] = {
25882         (char *) "self",(char *) "zoom", NULL
25883     };
25884
25885     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PreviewControlBar_SetZoomControl",kwnames,&obj0,&obj1)) goto fail;
25886     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25887     if (SWIG_arg_fail(1)) SWIG_fail;
25888     {
25889         arg2 = (int)(SWIG_As_int(obj1));
25890         if (SWIG_arg_fail(2)) SWIG_fail;
25891     }
25892     {
25893         PyThreadState* __tstate = wxPyBeginAllowThreads();
25894         (arg1)->SetZoomControl(arg2);
25895
25896         wxPyEndAllowThreads(__tstate);
25897         if (PyErr_Occurred()) SWIG_fail;
25898     }
25899     Py_INCREF(Py_None); resultobj = Py_None;
25900     return resultobj;
25901     fail:
25902     return NULL;
25903 }
25904
25905
25906 static PyObject *_wrap_PreviewControlBar_GetPrintPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25907     PyObject *resultobj;
25908     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25909     wxPrintPreview *result;
25910     PyObject * obj0 = 0 ;
25911     char *kwnames[] = {
25912         (char *) "self", NULL
25913     };
25914
25915     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_GetPrintPreview",kwnames,&obj0)) goto fail;
25916     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25917     if (SWIG_arg_fail(1)) SWIG_fail;
25918     {
25919         PyThreadState* __tstate = wxPyBeginAllowThreads();
25920         result = (wxPrintPreview *)(arg1)->GetPrintPreview();
25921
25922         wxPyEndAllowThreads(__tstate);
25923         if (PyErr_Occurred()) SWIG_fail;
25924     }
25925     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 0);
25926     return resultobj;
25927     fail:
25928     return NULL;
25929 }
25930
25931
25932 static PyObject *_wrap_PreviewControlBar_OnNext(PyObject *, PyObject *args, PyObject *kwargs) {
25933     PyObject *resultobj;
25934     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25935     PyObject * obj0 = 0 ;
25936     char *kwnames[] = {
25937         (char *) "self", NULL
25938     };
25939
25940     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnNext",kwnames,&obj0)) goto fail;
25941     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25942     if (SWIG_arg_fail(1)) SWIG_fail;
25943     {
25944         PyThreadState* __tstate = wxPyBeginAllowThreads();
25945         (arg1)->OnNext();
25946
25947         wxPyEndAllowThreads(__tstate);
25948         if (PyErr_Occurred()) SWIG_fail;
25949     }
25950     Py_INCREF(Py_None); resultobj = Py_None;
25951     return resultobj;
25952     fail:
25953     return NULL;
25954 }
25955
25956
25957 static PyObject *_wrap_PreviewControlBar_OnPrevious(PyObject *, PyObject *args, PyObject *kwargs) {
25958     PyObject *resultobj;
25959     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25960     PyObject * obj0 = 0 ;
25961     char *kwnames[] = {
25962         (char *) "self", NULL
25963     };
25964
25965     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnPrevious",kwnames,&obj0)) goto fail;
25966     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25967     if (SWIG_arg_fail(1)) SWIG_fail;
25968     {
25969         PyThreadState* __tstate = wxPyBeginAllowThreads();
25970         (arg1)->OnPrevious();
25971
25972         wxPyEndAllowThreads(__tstate);
25973         if (PyErr_Occurred()) SWIG_fail;
25974     }
25975     Py_INCREF(Py_None); resultobj = Py_None;
25976     return resultobj;
25977     fail:
25978     return NULL;
25979 }
25980
25981
25982 static PyObject *_wrap_PreviewControlBar_OnFirst(PyObject *, PyObject *args, PyObject *kwargs) {
25983     PyObject *resultobj;
25984     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25985     PyObject * obj0 = 0 ;
25986     char *kwnames[] = {
25987         (char *) "self", NULL
25988     };
25989
25990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnFirst",kwnames,&obj0)) goto fail;
25991     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25992     if (SWIG_arg_fail(1)) SWIG_fail;
25993     {
25994         PyThreadState* __tstate = wxPyBeginAllowThreads();
25995         (arg1)->OnFirst();
25996
25997         wxPyEndAllowThreads(__tstate);
25998         if (PyErr_Occurred()) SWIG_fail;
25999     }
26000     Py_INCREF(Py_None); resultobj = Py_None;
26001     return resultobj;
26002     fail:
26003     return NULL;
26004 }
26005
26006
26007 static PyObject *_wrap_PreviewControlBar_OnLast(PyObject *, PyObject *args, PyObject *kwargs) {
26008     PyObject *resultobj;
26009     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
26010     PyObject * obj0 = 0 ;
26011     char *kwnames[] = {
26012         (char *) "self", NULL
26013     };
26014
26015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnLast",kwnames,&obj0)) goto fail;
26016     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
26017     if (SWIG_arg_fail(1)) SWIG_fail;
26018     {
26019         PyThreadState* __tstate = wxPyBeginAllowThreads();
26020         (arg1)->OnLast();
26021
26022         wxPyEndAllowThreads(__tstate);
26023         if (PyErr_Occurred()) SWIG_fail;
26024     }
26025     Py_INCREF(Py_None); resultobj = Py_None;
26026     return resultobj;
26027     fail:
26028     return NULL;
26029 }
26030
26031
26032 static PyObject *_wrap_PreviewControlBar_OnGoto(PyObject *, PyObject *args, PyObject *kwargs) {
26033     PyObject *resultobj;
26034     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
26035     PyObject * obj0 = 0 ;
26036     char *kwnames[] = {
26037         (char *) "self", NULL
26038     };
26039
26040     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnGoto",kwnames,&obj0)) goto fail;
26041     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
26042     if (SWIG_arg_fail(1)) SWIG_fail;
26043     {
26044         PyThreadState* __tstate = wxPyBeginAllowThreads();
26045         (arg1)->OnGoto();
26046
26047         wxPyEndAllowThreads(__tstate);
26048         if (PyErr_Occurred()) SWIG_fail;
26049     }
26050     Py_INCREF(Py_None); resultobj = Py_None;
26051     return resultobj;
26052     fail:
26053     return NULL;
26054 }
26055
26056
26057 static PyObject * PreviewControlBar_swigregister(PyObject *, PyObject *args) {
26058     PyObject *obj;
26059     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26060     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewControlBar, obj);
26061     Py_INCREF(obj);
26062     return Py_BuildValue((char *)"");
26063 }
26064 static PyObject *_wrap_new_PrintPreview__SWIG_0(PyObject *, PyObject *args) {
26065     PyObject *resultobj;
26066     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26067     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26068     wxPrintDialogData *arg3 = (wxPrintDialogData *) NULL ;
26069     wxPrintPreview *result;
26070     PyObject * obj0 = 0 ;
26071     PyObject * obj1 = 0 ;
26072     PyObject * obj2 = 0 ;
26073
26074     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_PrintPreview",&obj0,&obj1,&obj2)) goto fail;
26075     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26076     if (SWIG_arg_fail(1)) SWIG_fail;
26077     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26078     if (SWIG_arg_fail(2)) SWIG_fail;
26079     if (obj2) {
26080         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
26081         if (SWIG_arg_fail(3)) SWIG_fail;
26082     }
26083     {
26084         if (!wxPyCheckForApp()) SWIG_fail;
26085         PyThreadState* __tstate = wxPyBeginAllowThreads();
26086         result = (wxPrintPreview *)new wxPrintPreview(arg1,arg2,arg3);
26087
26088         wxPyEndAllowThreads(__tstate);
26089         if (PyErr_Occurred()) SWIG_fail;
26090     }
26091     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 1);
26092     return resultobj;
26093     fail:
26094     return NULL;
26095 }
26096
26097
26098 static PyObject *_wrap_new_PrintPreview__SWIG_1(PyObject *, PyObject *args) {
26099     PyObject *resultobj;
26100     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26101     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26102     wxPrintData *arg3 = (wxPrintData *) 0 ;
26103     wxPrintPreview *result;
26104     PyObject * obj0 = 0 ;
26105     PyObject * obj1 = 0 ;
26106     PyObject * obj2 = 0 ;
26107
26108     if(!PyArg_ParseTuple(args,(char *)"OOO:new_PrintPreview",&obj0,&obj1,&obj2)) goto fail;
26109     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26110     if (SWIG_arg_fail(1)) SWIG_fail;
26111     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26112     if (SWIG_arg_fail(2)) SWIG_fail;
26113     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
26114     if (SWIG_arg_fail(3)) SWIG_fail;
26115     {
26116         if (!wxPyCheckForApp()) SWIG_fail;
26117         PyThreadState* __tstate = wxPyBeginAllowThreads();
26118         result = (wxPrintPreview *)new wxPrintPreview(arg1,arg2,arg3);
26119
26120         wxPyEndAllowThreads(__tstate);
26121         if (PyErr_Occurred()) SWIG_fail;
26122     }
26123     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 1);
26124     return resultobj;
26125     fail:
26126     return NULL;
26127 }
26128
26129
26130 static PyObject *_wrap_new_PrintPreview(PyObject *self, PyObject *args) {
26131     int argc;
26132     PyObject *argv[4];
26133     int ii;
26134
26135     argc = PyObject_Length(args);
26136     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
26137         argv[ii] = PyTuple_GetItem(args,ii);
26138     }
26139     if ((argc >= 2) && (argc <= 3)) {
26140         int _v;
26141         {
26142             void *ptr;
26143             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26144                 _v = 0;
26145                 PyErr_Clear();
26146             } else {
26147                 _v = 1;
26148             }
26149         }
26150         if (_v) {
26151             {
26152                 void *ptr;
26153                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26154                     _v = 0;
26155                     PyErr_Clear();
26156                 } else {
26157                     _v = 1;
26158                 }
26159             }
26160             if (_v) {
26161                 if (argc <= 2) {
26162                     return _wrap_new_PrintPreview__SWIG_0(self,args);
26163                 }
26164                 {
26165                     void *ptr;
26166                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
26167                         _v = 0;
26168                         PyErr_Clear();
26169                     } else {
26170                         _v = 1;
26171                     }
26172                 }
26173                 if (_v) {
26174                     return _wrap_new_PrintPreview__SWIG_0(self,args);
26175                 }
26176             }
26177         }
26178     }
26179     if (argc == 3) {
26180         int _v;
26181         {
26182             void *ptr;
26183             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26184                 _v = 0;
26185                 PyErr_Clear();
26186             } else {
26187                 _v = 1;
26188             }
26189         }
26190         if (_v) {
26191             {
26192                 void *ptr;
26193                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26194                     _v = 0;
26195                     PyErr_Clear();
26196                 } else {
26197                     _v = 1;
26198                 }
26199             }
26200             if (_v) {
26201                 {
26202                     void *ptr;
26203                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
26204                         _v = 0;
26205                         PyErr_Clear();
26206                     } else {
26207                         _v = 1;
26208                     }
26209                 }
26210                 if (_v) {
26211                     return _wrap_new_PrintPreview__SWIG_1(self,args);
26212                 }
26213             }
26214         }
26215     }
26216
26217     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintPreview'");
26218     return NULL;
26219 }
26220
26221
26222 static PyObject *_wrap_PrintPreview_SetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26223     PyObject *resultobj;
26224     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26225     int arg2 ;
26226     bool result;
26227     PyObject * obj0 = 0 ;
26228     PyObject * obj1 = 0 ;
26229     char *kwnames[] = {
26230         (char *) "self",(char *) "pageNum", NULL
26231     };
26232
26233     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetCurrentPage",kwnames,&obj0,&obj1)) goto fail;
26234     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26235     if (SWIG_arg_fail(1)) SWIG_fail;
26236     {
26237         arg2 = (int)(SWIG_As_int(obj1));
26238         if (SWIG_arg_fail(2)) SWIG_fail;
26239     }
26240     {
26241         PyThreadState* __tstate = wxPyBeginAllowThreads();
26242         result = (bool)(arg1)->SetCurrentPage(arg2);
26243
26244         wxPyEndAllowThreads(__tstate);
26245         if (PyErr_Occurred()) SWIG_fail;
26246     }
26247     {
26248         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26249     }
26250     return resultobj;
26251     fail:
26252     return NULL;
26253 }
26254
26255
26256 static PyObject *_wrap_PrintPreview_GetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26257     PyObject *resultobj;
26258     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26259     int result;
26260     PyObject * obj0 = 0 ;
26261     char *kwnames[] = {
26262         (char *) "self", NULL
26263     };
26264
26265     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetCurrentPage",kwnames,&obj0)) goto fail;
26266     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26267     if (SWIG_arg_fail(1)) SWIG_fail;
26268     {
26269         PyThreadState* __tstate = wxPyBeginAllowThreads();
26270         result = (int)(arg1)->GetCurrentPage();
26271
26272         wxPyEndAllowThreads(__tstate);
26273         if (PyErr_Occurred()) SWIG_fail;
26274     }
26275     {
26276         resultobj = SWIG_From_int((int)(result));
26277     }
26278     return resultobj;
26279     fail:
26280     return NULL;
26281 }
26282
26283
26284 static PyObject *_wrap_PrintPreview_SetPrintout(PyObject *, PyObject *args, PyObject *kwargs) {
26285     PyObject *resultobj;
26286     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26287     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26288     PyObject * obj0 = 0 ;
26289     PyObject * obj1 = 0 ;
26290     char *kwnames[] = {
26291         (char *) "self",(char *) "printout", NULL
26292     };
26293
26294     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetPrintout",kwnames,&obj0,&obj1)) goto fail;
26295     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26296     if (SWIG_arg_fail(1)) SWIG_fail;
26297     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26298     if (SWIG_arg_fail(2)) SWIG_fail;
26299     {
26300         PyThreadState* __tstate = wxPyBeginAllowThreads();
26301         (arg1)->SetPrintout(arg2);
26302
26303         wxPyEndAllowThreads(__tstate);
26304         if (PyErr_Occurred()) SWIG_fail;
26305     }
26306     Py_INCREF(Py_None); resultobj = Py_None;
26307     return resultobj;
26308     fail:
26309     return NULL;
26310 }
26311
26312
26313 static PyObject *_wrap_PrintPreview_GetPrintout(PyObject *, PyObject *args, PyObject *kwargs) {
26314     PyObject *resultobj;
26315     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26316     wxPyPrintout *result;
26317     PyObject * obj0 = 0 ;
26318     char *kwnames[] = {
26319         (char *) "self", NULL
26320     };
26321
26322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintout",kwnames,&obj0)) goto fail;
26323     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26324     if (SWIG_arg_fail(1)) SWIG_fail;
26325     {
26326         PyThreadState* __tstate = wxPyBeginAllowThreads();
26327         result = (wxPyPrintout *)(arg1)->GetPrintout();
26328
26329         wxPyEndAllowThreads(__tstate);
26330         if (PyErr_Occurred()) SWIG_fail;
26331     }
26332     {
26333         resultobj = wxPyMake_wxObject(result, 0);
26334     }
26335     return resultobj;
26336     fail:
26337     return NULL;
26338 }
26339
26340
26341 static PyObject *_wrap_PrintPreview_GetPrintoutForPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
26342     PyObject *resultobj;
26343     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26344     wxPyPrintout *result;
26345     PyObject * obj0 = 0 ;
26346     char *kwnames[] = {
26347         (char *) "self", NULL
26348     };
26349
26350     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintoutForPrinting",kwnames,&obj0)) goto fail;
26351     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26352     if (SWIG_arg_fail(1)) SWIG_fail;
26353     {
26354         PyThreadState* __tstate = wxPyBeginAllowThreads();
26355         result = (wxPyPrintout *)(arg1)->GetPrintoutForPrinting();
26356
26357         wxPyEndAllowThreads(__tstate);
26358         if (PyErr_Occurred()) SWIG_fail;
26359     }
26360     {
26361         resultobj = wxPyMake_wxObject(result, 0);
26362     }
26363     return resultobj;
26364     fail:
26365     return NULL;
26366 }
26367
26368
26369 static PyObject *_wrap_PrintPreview_SetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
26370     PyObject *resultobj;
26371     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26372     wxFrame *arg2 = (wxFrame *) 0 ;
26373     PyObject * obj0 = 0 ;
26374     PyObject * obj1 = 0 ;
26375     char *kwnames[] = {
26376         (char *) "self",(char *) "frame", NULL
26377     };
26378
26379     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetFrame",kwnames,&obj0,&obj1)) goto fail;
26380     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26381     if (SWIG_arg_fail(1)) SWIG_fail;
26382     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
26383     if (SWIG_arg_fail(2)) SWIG_fail;
26384     {
26385         PyThreadState* __tstate = wxPyBeginAllowThreads();
26386         (arg1)->SetFrame(arg2);
26387
26388         wxPyEndAllowThreads(__tstate);
26389         if (PyErr_Occurred()) SWIG_fail;
26390     }
26391     Py_INCREF(Py_None); resultobj = Py_None;
26392     return resultobj;
26393     fail:
26394     return NULL;
26395 }
26396
26397
26398 static PyObject *_wrap_PrintPreview_SetCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
26399     PyObject *resultobj;
26400     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26401     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26402     PyObject * obj0 = 0 ;
26403     PyObject * obj1 = 0 ;
26404     char *kwnames[] = {
26405         (char *) "self",(char *) "canvas", NULL
26406     };
26407
26408     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetCanvas",kwnames,&obj0,&obj1)) goto fail;
26409     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26410     if (SWIG_arg_fail(1)) SWIG_fail;
26411     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26412     if (SWIG_arg_fail(2)) SWIG_fail;
26413     {
26414         PyThreadState* __tstate = wxPyBeginAllowThreads();
26415         (arg1)->SetCanvas(arg2);
26416
26417         wxPyEndAllowThreads(__tstate);
26418         if (PyErr_Occurred()) SWIG_fail;
26419     }
26420     Py_INCREF(Py_None); resultobj = Py_None;
26421     return resultobj;
26422     fail:
26423     return NULL;
26424 }
26425
26426
26427 static PyObject *_wrap_PrintPreview_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
26428     PyObject *resultobj;
26429     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26430     wxFrame *result;
26431     PyObject * obj0 = 0 ;
26432     char *kwnames[] = {
26433         (char *) "self", NULL
26434     };
26435
26436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetFrame",kwnames,&obj0)) goto fail;
26437     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26438     if (SWIG_arg_fail(1)) SWIG_fail;
26439     {
26440         PyThreadState* __tstate = wxPyBeginAllowThreads();
26441         result = (wxFrame *)(arg1)->GetFrame();
26442
26443         wxPyEndAllowThreads(__tstate);
26444         if (PyErr_Occurred()) SWIG_fail;
26445     }
26446     {
26447         resultobj = wxPyMake_wxObject(result, 0);
26448     }
26449     return resultobj;
26450     fail:
26451     return NULL;
26452 }
26453
26454
26455 static PyObject *_wrap_PrintPreview_GetCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
26456     PyObject *resultobj;
26457     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26458     wxPreviewCanvas *result;
26459     PyObject * obj0 = 0 ;
26460     char *kwnames[] = {
26461         (char *) "self", NULL
26462     };
26463
26464     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetCanvas",kwnames,&obj0)) goto fail;
26465     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26466     if (SWIG_arg_fail(1)) SWIG_fail;
26467     {
26468         PyThreadState* __tstate = wxPyBeginAllowThreads();
26469         result = (wxPreviewCanvas *)(arg1)->GetCanvas();
26470
26471         wxPyEndAllowThreads(__tstate);
26472         if (PyErr_Occurred()) SWIG_fail;
26473     }
26474     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewCanvas, 0);
26475     return resultobj;
26476     fail:
26477     return NULL;
26478 }
26479
26480
26481 static PyObject *_wrap_PrintPreview_PaintPage(PyObject *, PyObject *args, PyObject *kwargs) {
26482     PyObject *resultobj;
26483     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26484     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26485     wxDC *arg3 = 0 ;
26486     bool result;
26487     PyObject * obj0 = 0 ;
26488     PyObject * obj1 = 0 ;
26489     PyObject * obj2 = 0 ;
26490     char *kwnames[] = {
26491         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26492     };
26493
26494     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintPreview_PaintPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26495     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26496     if (SWIG_arg_fail(1)) SWIG_fail;
26497     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26498     if (SWIG_arg_fail(2)) SWIG_fail;
26499     {
26500         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26501         if (SWIG_arg_fail(3)) SWIG_fail;
26502         if (arg3 == NULL) {
26503             SWIG_null_ref("wxDC");
26504         }
26505         if (SWIG_arg_fail(3)) SWIG_fail;
26506     }
26507     {
26508         PyThreadState* __tstate = wxPyBeginAllowThreads();
26509         result = (bool)(arg1)->PaintPage(arg2,*arg3);
26510
26511         wxPyEndAllowThreads(__tstate);
26512         if (PyErr_Occurred()) SWIG_fail;
26513     }
26514     {
26515         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26516     }
26517     return resultobj;
26518     fail:
26519     return NULL;
26520 }
26521
26522
26523 static PyObject *_wrap_PrintPreview_DrawBlankPage(PyObject *, PyObject *args, PyObject *kwargs) {
26524     PyObject *resultobj;
26525     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26526     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26527     wxDC *arg3 = 0 ;
26528     bool result;
26529     PyObject * obj0 = 0 ;
26530     PyObject * obj1 = 0 ;
26531     PyObject * obj2 = 0 ;
26532     char *kwnames[] = {
26533         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26534     };
26535
26536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintPreview_DrawBlankPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26537     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26538     if (SWIG_arg_fail(1)) SWIG_fail;
26539     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26540     if (SWIG_arg_fail(2)) SWIG_fail;
26541     {
26542         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26543         if (SWIG_arg_fail(3)) SWIG_fail;
26544         if (arg3 == NULL) {
26545             SWIG_null_ref("wxDC");
26546         }
26547         if (SWIG_arg_fail(3)) SWIG_fail;
26548     }
26549     {
26550         PyThreadState* __tstate = wxPyBeginAllowThreads();
26551         result = (bool)(arg1)->DrawBlankPage(arg2,*arg3);
26552
26553         wxPyEndAllowThreads(__tstate);
26554         if (PyErr_Occurred()) SWIG_fail;
26555     }
26556     {
26557         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26558     }
26559     return resultobj;
26560     fail:
26561     return NULL;
26562 }
26563
26564
26565 static PyObject *_wrap_PrintPreview_RenderPage(PyObject *, PyObject *args, PyObject *kwargs) {
26566     PyObject *resultobj;
26567     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26568     int arg2 ;
26569     bool result;
26570     PyObject * obj0 = 0 ;
26571     PyObject * obj1 = 0 ;
26572     char *kwnames[] = {
26573         (char *) "self",(char *) "pageNum", NULL
26574     };
26575
26576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_RenderPage",kwnames,&obj0,&obj1)) goto fail;
26577     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26578     if (SWIG_arg_fail(1)) SWIG_fail;
26579     {
26580         arg2 = (int)(SWIG_As_int(obj1));
26581         if (SWIG_arg_fail(2)) SWIG_fail;
26582     }
26583     {
26584         PyThreadState* __tstate = wxPyBeginAllowThreads();
26585         result = (bool)(arg1)->RenderPage(arg2);
26586
26587         wxPyEndAllowThreads(__tstate);
26588         if (PyErr_Occurred()) SWIG_fail;
26589     }
26590     {
26591         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26592     }
26593     return resultobj;
26594     fail:
26595     return NULL;
26596 }
26597
26598
26599 static PyObject *_wrap_PrintPreview_AdjustScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
26600     PyObject *resultobj;
26601     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26602     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26603     PyObject * obj0 = 0 ;
26604     PyObject * obj1 = 0 ;
26605     char *kwnames[] = {
26606         (char *) "self",(char *) "canvas", NULL
26607     };
26608
26609     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_AdjustScrollbars",kwnames,&obj0,&obj1)) goto fail;
26610     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26611     if (SWIG_arg_fail(1)) SWIG_fail;
26612     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26613     if (SWIG_arg_fail(2)) SWIG_fail;
26614     {
26615         PyThreadState* __tstate = wxPyBeginAllowThreads();
26616         (arg1)->AdjustScrollbars(arg2);
26617
26618         wxPyEndAllowThreads(__tstate);
26619         if (PyErr_Occurred()) SWIG_fail;
26620     }
26621     Py_INCREF(Py_None); resultobj = Py_None;
26622     return resultobj;
26623     fail:
26624     return NULL;
26625 }
26626
26627
26628 static PyObject *_wrap_PrintPreview_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
26629     PyObject *resultobj;
26630     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26631     wxPrintDialogData *result;
26632     PyObject * obj0 = 0 ;
26633     char *kwnames[] = {
26634         (char *) "self", NULL
26635     };
26636
26637     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintDialogData",kwnames,&obj0)) goto fail;
26638     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26639     if (SWIG_arg_fail(1)) SWIG_fail;
26640     {
26641         PyThreadState* __tstate = wxPyBeginAllowThreads();
26642         {
26643             wxPrintDialogData &_result_ref = (arg1)->GetPrintDialogData();
26644             result = (wxPrintDialogData *) &_result_ref;
26645         }
26646
26647         wxPyEndAllowThreads(__tstate);
26648         if (PyErr_Occurred()) SWIG_fail;
26649     }
26650     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
26651     return resultobj;
26652     fail:
26653     return NULL;
26654 }
26655
26656
26657 static PyObject *_wrap_PrintPreview_SetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
26658     PyObject *resultobj;
26659     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26660     int arg2 ;
26661     PyObject * obj0 = 0 ;
26662     PyObject * obj1 = 0 ;
26663     char *kwnames[] = {
26664         (char *) "self",(char *) "percent", NULL
26665     };
26666
26667     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetZoom",kwnames,&obj0,&obj1)) goto fail;
26668     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26669     if (SWIG_arg_fail(1)) SWIG_fail;
26670     {
26671         arg2 = (int)(SWIG_As_int(obj1));
26672         if (SWIG_arg_fail(2)) SWIG_fail;
26673     }
26674     {
26675         PyThreadState* __tstate = wxPyBeginAllowThreads();
26676         (arg1)->SetZoom(arg2);
26677
26678         wxPyEndAllowThreads(__tstate);
26679         if (PyErr_Occurred()) SWIG_fail;
26680     }
26681     Py_INCREF(Py_None); resultobj = Py_None;
26682     return resultobj;
26683     fail:
26684     return NULL;
26685 }
26686
26687
26688 static PyObject *_wrap_PrintPreview_GetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
26689     PyObject *resultobj;
26690     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26691     int result;
26692     PyObject * obj0 = 0 ;
26693     char *kwnames[] = {
26694         (char *) "self", NULL
26695     };
26696
26697     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetZoom",kwnames,&obj0)) goto fail;
26698     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26699     if (SWIG_arg_fail(1)) SWIG_fail;
26700     {
26701         PyThreadState* __tstate = wxPyBeginAllowThreads();
26702         result = (int)(arg1)->GetZoom();
26703
26704         wxPyEndAllowThreads(__tstate);
26705         if (PyErr_Occurred()) SWIG_fail;
26706     }
26707     {
26708         resultobj = SWIG_From_int((int)(result));
26709     }
26710     return resultobj;
26711     fail:
26712     return NULL;
26713 }
26714
26715
26716 static PyObject *_wrap_PrintPreview_GetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
26717     PyObject *resultobj;
26718     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26719     int result;
26720     PyObject * obj0 = 0 ;
26721     char *kwnames[] = {
26722         (char *) "self", NULL
26723     };
26724
26725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetMaxPage",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         result = (int)(arg1)->GetMaxPage();
26731
26732         wxPyEndAllowThreads(__tstate);
26733         if (PyErr_Occurred()) SWIG_fail;
26734     }
26735     {
26736         resultobj = SWIG_From_int((int)(result));
26737     }
26738     return resultobj;
26739     fail:
26740     return NULL;
26741 }
26742
26743
26744 static PyObject *_wrap_PrintPreview_GetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
26745     PyObject *resultobj;
26746     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26747     int result;
26748     PyObject * obj0 = 0 ;
26749     char *kwnames[] = {
26750         (char *) "self", NULL
26751     };
26752
26753     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetMinPage",kwnames,&obj0)) goto fail;
26754     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26755     if (SWIG_arg_fail(1)) SWIG_fail;
26756     {
26757         PyThreadState* __tstate = wxPyBeginAllowThreads();
26758         result = (int)(arg1)->GetMinPage();
26759
26760         wxPyEndAllowThreads(__tstate);
26761         if (PyErr_Occurred()) SWIG_fail;
26762     }
26763     {
26764         resultobj = SWIG_From_int((int)(result));
26765     }
26766     return resultobj;
26767     fail:
26768     return NULL;
26769 }
26770
26771
26772 static PyObject *_wrap_PrintPreview_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
26773     PyObject *resultobj;
26774     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26775     bool result;
26776     PyObject * obj0 = 0 ;
26777     char *kwnames[] = {
26778         (char *) "self", NULL
26779     };
26780
26781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_Ok",kwnames,&obj0)) goto fail;
26782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26783     if (SWIG_arg_fail(1)) SWIG_fail;
26784     {
26785         PyThreadState* __tstate = wxPyBeginAllowThreads();
26786         result = (bool)(arg1)->Ok();
26787
26788         wxPyEndAllowThreads(__tstate);
26789         if (PyErr_Occurred()) SWIG_fail;
26790     }
26791     {
26792         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26793     }
26794     return resultobj;
26795     fail:
26796     return NULL;
26797 }
26798
26799
26800 static PyObject *_wrap_PrintPreview_SetOk(PyObject *, PyObject *args, PyObject *kwargs) {
26801     PyObject *resultobj;
26802     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26803     bool arg2 ;
26804     PyObject * obj0 = 0 ;
26805     PyObject * obj1 = 0 ;
26806     char *kwnames[] = {
26807         (char *) "self",(char *) "ok", NULL
26808     };
26809
26810     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetOk",kwnames,&obj0,&obj1)) goto fail;
26811     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26812     if (SWIG_arg_fail(1)) SWIG_fail;
26813     {
26814         arg2 = (bool)(SWIG_As_bool(obj1));
26815         if (SWIG_arg_fail(2)) SWIG_fail;
26816     }
26817     {
26818         PyThreadState* __tstate = wxPyBeginAllowThreads();
26819         (arg1)->SetOk(arg2);
26820
26821         wxPyEndAllowThreads(__tstate);
26822         if (PyErr_Occurred()) SWIG_fail;
26823     }
26824     Py_INCREF(Py_None); resultobj = Py_None;
26825     return resultobj;
26826     fail:
26827     return NULL;
26828 }
26829
26830
26831 static PyObject *_wrap_PrintPreview_Print(PyObject *, PyObject *args, PyObject *kwargs) {
26832     PyObject *resultobj;
26833     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26834     bool arg2 ;
26835     bool result;
26836     PyObject * obj0 = 0 ;
26837     PyObject * obj1 = 0 ;
26838     char *kwnames[] = {
26839         (char *) "self",(char *) "interactive", NULL
26840     };
26841
26842     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_Print",kwnames,&obj0,&obj1)) goto fail;
26843     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26844     if (SWIG_arg_fail(1)) SWIG_fail;
26845     {
26846         arg2 = (bool)(SWIG_As_bool(obj1));
26847         if (SWIG_arg_fail(2)) SWIG_fail;
26848     }
26849     {
26850         PyThreadState* __tstate = wxPyBeginAllowThreads();
26851         result = (bool)(arg1)->Print(arg2);
26852
26853         wxPyEndAllowThreads(__tstate);
26854         if (PyErr_Occurred()) SWIG_fail;
26855     }
26856     {
26857         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26858     }
26859     return resultobj;
26860     fail:
26861     return NULL;
26862 }
26863
26864
26865 static PyObject *_wrap_PrintPreview_DetermineScaling(PyObject *, PyObject *args, PyObject *kwargs) {
26866     PyObject *resultobj;
26867     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26868     PyObject * obj0 = 0 ;
26869     char *kwnames[] = {
26870         (char *) "self", NULL
26871     };
26872
26873     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_DetermineScaling",kwnames,&obj0)) goto fail;
26874     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26875     if (SWIG_arg_fail(1)) SWIG_fail;
26876     {
26877         PyThreadState* __tstate = wxPyBeginAllowThreads();
26878         (arg1)->DetermineScaling();
26879
26880         wxPyEndAllowThreads(__tstate);
26881         if (PyErr_Occurred()) SWIG_fail;
26882     }
26883     Py_INCREF(Py_None); resultobj = Py_None;
26884     return resultobj;
26885     fail:
26886     return NULL;
26887 }
26888
26889
26890 static PyObject * PrintPreview_swigregister(PyObject *, PyObject *args) {
26891     PyObject *obj;
26892     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26893     SWIG_TypeClientData(SWIGTYPE_p_wxPrintPreview, obj);
26894     Py_INCREF(obj);
26895     return Py_BuildValue((char *)"");
26896 }
26897 static PyObject *_wrap_new_PyPrintPreview__SWIG_0(PyObject *, PyObject *args) {
26898     PyObject *resultobj;
26899     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26900     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26901     wxPrintDialogData *arg3 = (wxPrintDialogData *) NULL ;
26902     wxPyPrintPreview *result;
26903     PyObject * obj0 = 0 ;
26904     PyObject * obj1 = 0 ;
26905     PyObject * obj2 = 0 ;
26906
26907     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_PyPrintPreview",&obj0,&obj1,&obj2)) goto fail;
26908     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26909     if (SWIG_arg_fail(1)) SWIG_fail;
26910     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26911     if (SWIG_arg_fail(2)) SWIG_fail;
26912     if (obj2) {
26913         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
26914         if (SWIG_arg_fail(3)) SWIG_fail;
26915     }
26916     {
26917         if (!wxPyCheckForApp()) SWIG_fail;
26918         PyThreadState* __tstate = wxPyBeginAllowThreads();
26919         result = (wxPyPrintPreview *)new wxPyPrintPreview(arg1,arg2,arg3);
26920
26921         wxPyEndAllowThreads(__tstate);
26922         if (PyErr_Occurred()) SWIG_fail;
26923     }
26924     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPrintPreview, 1);
26925     return resultobj;
26926     fail:
26927     return NULL;
26928 }
26929
26930
26931 static PyObject *_wrap_new_PyPrintPreview__SWIG_1(PyObject *, PyObject *args) {
26932     PyObject *resultobj;
26933     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26934     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26935     wxPrintData *arg3 = (wxPrintData *) 0 ;
26936     wxPyPrintPreview *result;
26937     PyObject * obj0 = 0 ;
26938     PyObject * obj1 = 0 ;
26939     PyObject * obj2 = 0 ;
26940
26941     if(!PyArg_ParseTuple(args,(char *)"OOO:new_PyPrintPreview",&obj0,&obj1,&obj2)) goto fail;
26942     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26943     if (SWIG_arg_fail(1)) SWIG_fail;
26944     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26945     if (SWIG_arg_fail(2)) SWIG_fail;
26946     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
26947     if (SWIG_arg_fail(3)) SWIG_fail;
26948     {
26949         if (!wxPyCheckForApp()) SWIG_fail;
26950         PyThreadState* __tstate = wxPyBeginAllowThreads();
26951         result = (wxPyPrintPreview *)new wxPyPrintPreview(arg1,arg2,arg3);
26952
26953         wxPyEndAllowThreads(__tstate);
26954         if (PyErr_Occurred()) SWIG_fail;
26955     }
26956     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPrintPreview, 1);
26957     return resultobj;
26958     fail:
26959     return NULL;
26960 }
26961
26962
26963 static PyObject *_wrap_new_PyPrintPreview(PyObject *self, PyObject *args) {
26964     int argc;
26965     PyObject *argv[4];
26966     int ii;
26967
26968     argc = PyObject_Length(args);
26969     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
26970         argv[ii] = PyTuple_GetItem(args,ii);
26971     }
26972     if ((argc >= 2) && (argc <= 3)) {
26973         int _v;
26974         {
26975             void *ptr;
26976             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26977                 _v = 0;
26978                 PyErr_Clear();
26979             } else {
26980                 _v = 1;
26981             }
26982         }
26983         if (_v) {
26984             {
26985                 void *ptr;
26986                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26987                     _v = 0;
26988                     PyErr_Clear();
26989                 } else {
26990                     _v = 1;
26991                 }
26992             }
26993             if (_v) {
26994                 if (argc <= 2) {
26995                     return _wrap_new_PyPrintPreview__SWIG_0(self,args);
26996                 }
26997                 {
26998                     void *ptr;
26999                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
27000                         _v = 0;
27001                         PyErr_Clear();
27002                     } else {
27003                         _v = 1;
27004                     }
27005                 }
27006                 if (_v) {
27007                     return _wrap_new_PyPrintPreview__SWIG_0(self,args);
27008                 }
27009             }
27010         }
27011     }
27012     if (argc == 3) {
27013         int _v;
27014         {
27015             void *ptr;
27016             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
27017                 _v = 0;
27018                 PyErr_Clear();
27019             } else {
27020                 _v = 1;
27021             }
27022         }
27023         if (_v) {
27024             {
27025                 void *ptr;
27026                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
27027                     _v = 0;
27028                     PyErr_Clear();
27029                 } else {
27030                     _v = 1;
27031                 }
27032             }
27033             if (_v) {
27034                 {
27035                     void *ptr;
27036                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
27037                         _v = 0;
27038                         PyErr_Clear();
27039                     } else {
27040                         _v = 1;
27041                     }
27042                 }
27043                 if (_v) {
27044                     return _wrap_new_PyPrintPreview__SWIG_1(self,args);
27045                 }
27046             }
27047         }
27048     }
27049
27050     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PyPrintPreview'");
27051     return NULL;
27052 }
27053
27054
27055 static PyObject *_wrap_PyPrintPreview__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27056     PyObject *resultobj;
27057     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27058     PyObject *arg2 = (PyObject *) 0 ;
27059     PyObject *arg3 = (PyObject *) 0 ;
27060     PyObject * obj0 = 0 ;
27061     PyObject * obj1 = 0 ;
27062     PyObject * obj2 = 0 ;
27063     char *kwnames[] = {
27064         (char *) "self",(char *) "self",(char *) "_class", NULL
27065     };
27066
27067     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) 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     arg2 = obj1;
27071     arg3 = obj2;
27072     {
27073         PyThreadState* __tstate = wxPyBeginAllowThreads();
27074         (arg1)->_setCallbackInfo(arg2,arg3);
27075
27076         wxPyEndAllowThreads(__tstate);
27077         if (PyErr_Occurred()) SWIG_fail;
27078     }
27079     Py_INCREF(Py_None); resultobj = Py_None;
27080     return resultobj;
27081     fail:
27082     return NULL;
27083 }
27084
27085
27086 static PyObject *_wrap_PyPrintPreview_base_SetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
27087     PyObject *resultobj;
27088     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27089     int arg2 ;
27090     bool result;
27091     PyObject * obj0 = 0 ;
27092     PyObject * obj1 = 0 ;
27093     char *kwnames[] = {
27094         (char *) "self",(char *) "pageNum", NULL
27095     };
27096
27097     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_SetCurrentPage",kwnames,&obj0,&obj1)) goto fail;
27098     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27099     if (SWIG_arg_fail(1)) SWIG_fail;
27100     {
27101         arg2 = (int)(SWIG_As_int(obj1));
27102         if (SWIG_arg_fail(2)) SWIG_fail;
27103     }
27104     {
27105         PyThreadState* __tstate = wxPyBeginAllowThreads();
27106         result = (bool)(arg1)->base_SetCurrentPage(arg2);
27107
27108         wxPyEndAllowThreads(__tstate);
27109         if (PyErr_Occurred()) SWIG_fail;
27110     }
27111     {
27112         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27113     }
27114     return resultobj;
27115     fail:
27116     return NULL;
27117 }
27118
27119
27120 static PyObject *_wrap_PyPrintPreview_base_PaintPage(PyObject *, PyObject *args, PyObject *kwargs) {
27121     PyObject *resultobj;
27122     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27123     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27124     wxDC *arg3 = 0 ;
27125     bool result;
27126     PyObject * obj0 = 0 ;
27127     PyObject * obj1 = 0 ;
27128     PyObject * obj2 = 0 ;
27129     char *kwnames[] = {
27130         (char *) "self",(char *) "canvas",(char *) "dc", NULL
27131     };
27132
27133     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview_base_PaintPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
27134     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27135     if (SWIG_arg_fail(1)) SWIG_fail;
27136     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27137     if (SWIG_arg_fail(2)) SWIG_fail;
27138     {
27139         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
27140         if (SWIG_arg_fail(3)) SWIG_fail;
27141         if (arg3 == NULL) {
27142             SWIG_null_ref("wxDC");
27143         }
27144         if (SWIG_arg_fail(3)) SWIG_fail;
27145     }
27146     {
27147         PyThreadState* __tstate = wxPyBeginAllowThreads();
27148         result = (bool)(arg1)->base_PaintPage(arg2,*arg3);
27149
27150         wxPyEndAllowThreads(__tstate);
27151         if (PyErr_Occurred()) SWIG_fail;
27152     }
27153     {
27154         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27155     }
27156     return resultobj;
27157     fail:
27158     return NULL;
27159 }
27160
27161
27162 static PyObject *_wrap_PyPrintPreview_base_DrawBlankPage(PyObject *, PyObject *args, PyObject *kwargs) {
27163     PyObject *resultobj;
27164     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27165     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27166     wxDC *arg3 = 0 ;
27167     bool result;
27168     PyObject * obj0 = 0 ;
27169     PyObject * obj1 = 0 ;
27170     PyObject * obj2 = 0 ;
27171     char *kwnames[] = {
27172         (char *) "self",(char *) "canvas",(char *) "dc", NULL
27173     };
27174
27175     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview_base_DrawBlankPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
27176     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27177     if (SWIG_arg_fail(1)) SWIG_fail;
27178     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27179     if (SWIG_arg_fail(2)) SWIG_fail;
27180     {
27181         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
27182         if (SWIG_arg_fail(3)) SWIG_fail;
27183         if (arg3 == NULL) {
27184             SWIG_null_ref("wxDC");
27185         }
27186         if (SWIG_arg_fail(3)) SWIG_fail;
27187     }
27188     {
27189         PyThreadState* __tstate = wxPyBeginAllowThreads();
27190         result = (bool)(arg1)->base_DrawBlankPage(arg2,*arg3);
27191
27192         wxPyEndAllowThreads(__tstate);
27193         if (PyErr_Occurred()) SWIG_fail;
27194     }
27195     {
27196         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27197     }
27198     return resultobj;
27199     fail:
27200     return NULL;
27201 }
27202
27203
27204 static PyObject *_wrap_PyPrintPreview_base_RenderPage(PyObject *, PyObject *args, PyObject *kwargs) {
27205     PyObject *resultobj;
27206     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27207     int arg2 ;
27208     bool result;
27209     PyObject * obj0 = 0 ;
27210     PyObject * obj1 = 0 ;
27211     char *kwnames[] = {
27212         (char *) "self",(char *) "pageNum", NULL
27213     };
27214
27215     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_RenderPage",kwnames,&obj0,&obj1)) goto fail;
27216     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27217     if (SWIG_arg_fail(1)) SWIG_fail;
27218     {
27219         arg2 = (int)(SWIG_As_int(obj1));
27220         if (SWIG_arg_fail(2)) SWIG_fail;
27221     }
27222     {
27223         PyThreadState* __tstate = wxPyBeginAllowThreads();
27224         result = (bool)(arg1)->base_RenderPage(arg2);
27225
27226         wxPyEndAllowThreads(__tstate);
27227         if (PyErr_Occurred()) SWIG_fail;
27228     }
27229     {
27230         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27231     }
27232     return resultobj;
27233     fail:
27234     return NULL;
27235 }
27236
27237
27238 static PyObject *_wrap_PyPrintPreview_base_SetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
27239     PyObject *resultobj;
27240     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27241     int arg2 ;
27242     PyObject * obj0 = 0 ;
27243     PyObject * obj1 = 0 ;
27244     char *kwnames[] = {
27245         (char *) "self",(char *) "percent", NULL
27246     };
27247
27248     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_SetZoom",kwnames,&obj0,&obj1)) goto fail;
27249     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27250     if (SWIG_arg_fail(1)) SWIG_fail;
27251     {
27252         arg2 = (int)(SWIG_As_int(obj1));
27253         if (SWIG_arg_fail(2)) SWIG_fail;
27254     }
27255     {
27256         PyThreadState* __tstate = wxPyBeginAllowThreads();
27257         (arg1)->base_SetZoom(arg2);
27258
27259         wxPyEndAllowThreads(__tstate);
27260         if (PyErr_Occurred()) SWIG_fail;
27261     }
27262     Py_INCREF(Py_None); resultobj = Py_None;
27263     return resultobj;
27264     fail:
27265     return NULL;
27266 }
27267
27268
27269 static PyObject *_wrap_PyPrintPreview_base_Print(PyObject *, PyObject *args, PyObject *kwargs) {
27270     PyObject *resultobj;
27271     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27272     bool arg2 ;
27273     bool result;
27274     PyObject * obj0 = 0 ;
27275     PyObject * obj1 = 0 ;
27276     char *kwnames[] = {
27277         (char *) "self",(char *) "interactive", NULL
27278     };
27279
27280     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_Print",kwnames,&obj0,&obj1)) goto fail;
27281     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27282     if (SWIG_arg_fail(1)) SWIG_fail;
27283     {
27284         arg2 = (bool)(SWIG_As_bool(obj1));
27285         if (SWIG_arg_fail(2)) SWIG_fail;
27286     }
27287     {
27288         PyThreadState* __tstate = wxPyBeginAllowThreads();
27289         result = (bool)(arg1)->base_Print(arg2);
27290
27291         wxPyEndAllowThreads(__tstate);
27292         if (PyErr_Occurred()) SWIG_fail;
27293     }
27294     {
27295         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27296     }
27297     return resultobj;
27298     fail:
27299     return NULL;
27300 }
27301
27302
27303 static PyObject *_wrap_PyPrintPreview_base_DetermineScaling(PyObject *, PyObject *args, PyObject *kwargs) {
27304     PyObject *resultobj;
27305     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27306     PyObject * obj0 = 0 ;
27307     char *kwnames[] = {
27308         (char *) "self", NULL
27309     };
27310
27311     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPrintPreview_base_DetermineScaling",kwnames,&obj0)) goto fail;
27312     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27313     if (SWIG_arg_fail(1)) SWIG_fail;
27314     {
27315         PyThreadState* __tstate = wxPyBeginAllowThreads();
27316         (arg1)->base_DetermineScaling();
27317
27318         wxPyEndAllowThreads(__tstate);
27319         if (PyErr_Occurred()) SWIG_fail;
27320     }
27321     Py_INCREF(Py_None); resultobj = Py_None;
27322     return resultobj;
27323     fail:
27324     return NULL;
27325 }
27326
27327
27328 static PyObject * PyPrintPreview_swigregister(PyObject *, PyObject *args) {
27329     PyObject *obj;
27330     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27331     SWIG_TypeClientData(SWIGTYPE_p_wxPyPrintPreview, obj);
27332     Py_INCREF(obj);
27333     return Py_BuildValue((char *)"");
27334 }
27335 static PyObject *_wrap_new_PyPreviewFrame(PyObject *, PyObject *args, PyObject *kwargs) {
27336     PyObject *resultobj;
27337     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
27338     wxFrame *arg2 = (wxFrame *) 0 ;
27339     wxString *arg3 = 0 ;
27340     wxPoint const &arg4_defvalue = wxDefaultPosition ;
27341     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
27342     wxSize const &arg5_defvalue = wxDefaultSize ;
27343     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
27344     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
27345     wxString const &arg7_defvalue = wxPyFrameNameStr ;
27346     wxString *arg7 = (wxString *) &arg7_defvalue ;
27347     wxPyPreviewFrame *result;
27348     bool temp3 = false ;
27349     wxPoint temp4 ;
27350     wxSize temp5 ;
27351     bool temp7 = false ;
27352     PyObject * obj0 = 0 ;
27353     PyObject * obj1 = 0 ;
27354     PyObject * obj2 = 0 ;
27355     PyObject * obj3 = 0 ;
27356     PyObject * obj4 = 0 ;
27357     PyObject * obj5 = 0 ;
27358     PyObject * obj6 = 0 ;
27359     char *kwnames[] = {
27360         (char *) "preview",(char *) "parent",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
27361     };
27362
27363     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PyPreviewFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27364     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27365     if (SWIG_arg_fail(1)) SWIG_fail;
27366     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
27367     if (SWIG_arg_fail(2)) SWIG_fail;
27368     {
27369         arg3 = wxString_in_helper(obj2);
27370         if (arg3 == NULL) SWIG_fail;
27371         temp3 = true;
27372     }
27373     if (obj3) {
27374         {
27375             arg4 = &temp4;
27376             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
27377         }
27378     }
27379     if (obj4) {
27380         {
27381             arg5 = &temp5;
27382             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
27383         }
27384     }
27385     if (obj5) {
27386         {
27387             arg6 = (long)(SWIG_As_long(obj5));
27388             if (SWIG_arg_fail(6)) SWIG_fail;
27389         }
27390     }
27391     if (obj6) {
27392         {
27393             arg7 = wxString_in_helper(obj6);
27394             if (arg7 == NULL) SWIG_fail;
27395             temp7 = true;
27396         }
27397     }
27398     {
27399         if (!wxPyCheckForApp()) SWIG_fail;
27400         PyThreadState* __tstate = wxPyBeginAllowThreads();
27401         result = (wxPyPreviewFrame *)new wxPyPreviewFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
27402
27403         wxPyEndAllowThreads(__tstate);
27404         if (PyErr_Occurred()) SWIG_fail;
27405     }
27406     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPreviewFrame, 1);
27407     {
27408         if (temp3)
27409         delete arg3;
27410     }
27411     {
27412         if (temp7)
27413         delete arg7;
27414     }
27415     return resultobj;
27416     fail:
27417     {
27418         if (temp3)
27419         delete arg3;
27420     }
27421     {
27422         if (temp7)
27423         delete arg7;
27424     }
27425     return NULL;
27426 }
27427
27428
27429 static PyObject *_wrap_PyPreviewFrame__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27430     PyObject *resultobj;
27431     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27432     PyObject *arg2 = (PyObject *) 0 ;
27433     PyObject *arg3 = (PyObject *) 0 ;
27434     PyObject * obj0 = 0 ;
27435     PyObject * obj1 = 0 ;
27436     PyObject * obj2 = 0 ;
27437     char *kwnames[] = {
27438         (char *) "self",(char *) "self",(char *) "_class", NULL
27439     };
27440
27441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPreviewFrame__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27443     if (SWIG_arg_fail(1)) SWIG_fail;
27444     arg2 = obj1;
27445     arg3 = obj2;
27446     {
27447         PyThreadState* __tstate = wxPyBeginAllowThreads();
27448         (arg1)->_setCallbackInfo(arg2,arg3);
27449
27450         wxPyEndAllowThreads(__tstate);
27451         if (PyErr_Occurred()) SWIG_fail;
27452     }
27453     Py_INCREF(Py_None); resultobj = Py_None;
27454     return resultobj;
27455     fail:
27456     return NULL;
27457 }
27458
27459
27460 static PyObject *_wrap_PyPreviewFrame_SetPreviewCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
27461     PyObject *resultobj;
27462     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27463     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27464     PyObject * obj0 = 0 ;
27465     PyObject * obj1 = 0 ;
27466     char *kwnames[] = {
27467         (char *) "self",(char *) "canvas", NULL
27468     };
27469
27470     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewFrame_SetPreviewCanvas",kwnames,&obj0,&obj1)) goto fail;
27471     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27472     if (SWIG_arg_fail(1)) SWIG_fail;
27473     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27474     if (SWIG_arg_fail(2)) SWIG_fail;
27475     {
27476         PyThreadState* __tstate = wxPyBeginAllowThreads();
27477         (arg1)->SetPreviewCanvas(arg2);
27478
27479         wxPyEndAllowThreads(__tstate);
27480         if (PyErr_Occurred()) SWIG_fail;
27481     }
27482     Py_INCREF(Py_None); resultobj = Py_None;
27483     return resultobj;
27484     fail:
27485     return NULL;
27486 }
27487
27488
27489 static PyObject *_wrap_PyPreviewFrame_SetControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27490     PyObject *resultobj;
27491     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27492     wxPreviewControlBar *arg2 = (wxPreviewControlBar *) 0 ;
27493     PyObject * obj0 = 0 ;
27494     PyObject * obj1 = 0 ;
27495     char *kwnames[] = {
27496         (char *) "self",(char *) "bar", NULL
27497     };
27498
27499     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewFrame_SetControlBar",kwnames,&obj0,&obj1)) goto fail;
27500     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27501     if (SWIG_arg_fail(1)) SWIG_fail;
27502     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27503     if (SWIG_arg_fail(2)) SWIG_fail;
27504     {
27505         PyThreadState* __tstate = wxPyBeginAllowThreads();
27506         (arg1)->SetControlBar(arg2);
27507
27508         wxPyEndAllowThreads(__tstate);
27509         if (PyErr_Occurred()) SWIG_fail;
27510     }
27511     Py_INCREF(Py_None); resultobj = Py_None;
27512     return resultobj;
27513     fail:
27514     return NULL;
27515 }
27516
27517
27518 static PyObject *_wrap_PyPreviewFrame_base_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
27519     PyObject *resultobj;
27520     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27521     PyObject * obj0 = 0 ;
27522     char *kwnames[] = {
27523         (char *) "self", NULL
27524     };
27525
27526     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_Initialize",kwnames,&obj0)) goto fail;
27527     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27528     if (SWIG_arg_fail(1)) SWIG_fail;
27529     {
27530         PyThreadState* __tstate = wxPyBeginAllowThreads();
27531         (arg1)->base_Initialize();
27532
27533         wxPyEndAllowThreads(__tstate);
27534         if (PyErr_Occurred()) SWIG_fail;
27535     }
27536     Py_INCREF(Py_None); resultobj = Py_None;
27537     return resultobj;
27538     fail:
27539     return NULL;
27540 }
27541
27542
27543 static PyObject *_wrap_PyPreviewFrame_base_CreateCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
27544     PyObject *resultobj;
27545     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27546     PyObject * obj0 = 0 ;
27547     char *kwnames[] = {
27548         (char *) "self", NULL
27549     };
27550
27551     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_CreateCanvas",kwnames,&obj0)) goto fail;
27552     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27553     if (SWIG_arg_fail(1)) SWIG_fail;
27554     {
27555         PyThreadState* __tstate = wxPyBeginAllowThreads();
27556         (arg1)->base_CreateCanvas();
27557
27558         wxPyEndAllowThreads(__tstate);
27559         if (PyErr_Occurred()) SWIG_fail;
27560     }
27561     Py_INCREF(Py_None); resultobj = Py_None;
27562     return resultobj;
27563     fail:
27564     return NULL;
27565 }
27566
27567
27568 static PyObject *_wrap_PyPreviewFrame_base_CreateControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27569     PyObject *resultobj;
27570     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27571     PyObject * obj0 = 0 ;
27572     char *kwnames[] = {
27573         (char *) "self", NULL
27574     };
27575
27576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_CreateControlBar",kwnames,&obj0)) goto fail;
27577     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27578     if (SWIG_arg_fail(1)) SWIG_fail;
27579     {
27580         PyThreadState* __tstate = wxPyBeginAllowThreads();
27581         (arg1)->base_CreateControlBar();
27582
27583         wxPyEndAllowThreads(__tstate);
27584         if (PyErr_Occurred()) SWIG_fail;
27585     }
27586     Py_INCREF(Py_None); resultobj = Py_None;
27587     return resultobj;
27588     fail:
27589     return NULL;
27590 }
27591
27592
27593 static PyObject * PyPreviewFrame_swigregister(PyObject *, PyObject *args) {
27594     PyObject *obj;
27595     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27596     SWIG_TypeClientData(SWIGTYPE_p_wxPyPreviewFrame, obj);
27597     Py_INCREF(obj);
27598     return Py_BuildValue((char *)"");
27599 }
27600 static PyObject *_wrap_new_PyPreviewControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27601     PyObject *resultobj;
27602     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
27603     long arg2 ;
27604     wxWindow *arg3 = (wxWindow *) 0 ;
27605     wxPoint const &arg4_defvalue = wxDefaultPosition ;
27606     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
27607     wxSize const &arg5_defvalue = wxDefaultSize ;
27608     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
27609     long arg6 = (long) 0 ;
27610     wxString const &arg7_defvalue = wxPyPanelNameStr ;
27611     wxString *arg7 = (wxString *) &arg7_defvalue ;
27612     wxPyPreviewControlBar *result;
27613     wxPoint temp4 ;
27614     wxSize temp5 ;
27615     bool temp7 = false ;
27616     PyObject * obj0 = 0 ;
27617     PyObject * obj1 = 0 ;
27618     PyObject * obj2 = 0 ;
27619     PyObject * obj3 = 0 ;
27620     PyObject * obj4 = 0 ;
27621     PyObject * obj5 = 0 ;
27622     PyObject * obj6 = 0 ;
27623     char *kwnames[] = {
27624         (char *) "preview",(char *) "buttons",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
27625     };
27626
27627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PyPreviewControlBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27628     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27629     if (SWIG_arg_fail(1)) SWIG_fail;
27630     {
27631         arg2 = (long)(SWIG_As_long(obj1));
27632         if (SWIG_arg_fail(2)) SWIG_fail;
27633     }
27634     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27635     if (SWIG_arg_fail(3)) SWIG_fail;
27636     if (obj3) {
27637         {
27638             arg4 = &temp4;
27639             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
27640         }
27641     }
27642     if (obj4) {
27643         {
27644             arg5 = &temp5;
27645             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
27646         }
27647     }
27648     if (obj5) {
27649         {
27650             arg6 = (long)(SWIG_As_long(obj5));
27651             if (SWIG_arg_fail(6)) SWIG_fail;
27652         }
27653     }
27654     if (obj6) {
27655         {
27656             arg7 = wxString_in_helper(obj6);
27657             if (arg7 == NULL) SWIG_fail;
27658             temp7 = true;
27659         }
27660     }
27661     {
27662         if (!wxPyCheckForApp()) SWIG_fail;
27663         PyThreadState* __tstate = wxPyBeginAllowThreads();
27664         result = (wxPyPreviewControlBar *)new wxPyPreviewControlBar(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
27665
27666         wxPyEndAllowThreads(__tstate);
27667         if (PyErr_Occurred()) SWIG_fail;
27668     }
27669     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPreviewControlBar, 1);
27670     {
27671         if (temp7)
27672         delete arg7;
27673     }
27674     return resultobj;
27675     fail:
27676     {
27677         if (temp7)
27678         delete arg7;
27679     }
27680     return NULL;
27681 }
27682
27683
27684 static PyObject *_wrap_PyPreviewControlBar__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27685     PyObject *resultobj;
27686     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27687     PyObject *arg2 = (PyObject *) 0 ;
27688     PyObject *arg3 = (PyObject *) 0 ;
27689     PyObject * obj0 = 0 ;
27690     PyObject * obj1 = 0 ;
27691     PyObject * obj2 = 0 ;
27692     char *kwnames[] = {
27693         (char *) "self",(char *) "self",(char *) "_class", NULL
27694     };
27695
27696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPreviewControlBar__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27697     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27698     if (SWIG_arg_fail(1)) SWIG_fail;
27699     arg2 = obj1;
27700     arg3 = obj2;
27701     {
27702         PyThreadState* __tstate = wxPyBeginAllowThreads();
27703         (arg1)->_setCallbackInfo(arg2,arg3);
27704
27705         wxPyEndAllowThreads(__tstate);
27706         if (PyErr_Occurred()) SWIG_fail;
27707     }
27708     Py_INCREF(Py_None); resultobj = Py_None;
27709     return resultobj;
27710     fail:
27711     return NULL;
27712 }
27713
27714
27715 static PyObject *_wrap_PyPreviewControlBar_SetPrintPreview(PyObject *, PyObject *args, PyObject *kwargs) {
27716     PyObject *resultobj;
27717     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27718     wxPrintPreview *arg2 = (wxPrintPreview *) 0 ;
27719     PyObject * obj0 = 0 ;
27720     PyObject * obj1 = 0 ;
27721     char *kwnames[] = {
27722         (char *) "self",(char *) "preview", NULL
27723     };
27724
27725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewControlBar_SetPrintPreview",kwnames,&obj0,&obj1)) goto fail;
27726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27727     if (SWIG_arg_fail(1)) SWIG_fail;
27728     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27729     if (SWIG_arg_fail(2)) SWIG_fail;
27730     {
27731         PyThreadState* __tstate = wxPyBeginAllowThreads();
27732         (arg1)->SetPrintPreview(arg2);
27733
27734         wxPyEndAllowThreads(__tstate);
27735         if (PyErr_Occurred()) SWIG_fail;
27736     }
27737     Py_INCREF(Py_None); resultobj = Py_None;
27738     return resultobj;
27739     fail:
27740     return NULL;
27741 }
27742
27743
27744 static PyObject *_wrap_PyPreviewControlBar_base_CreateButtons(PyObject *, PyObject *args, PyObject *kwargs) {
27745     PyObject *resultobj;
27746     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27747     PyObject * obj0 = 0 ;
27748     char *kwnames[] = {
27749         (char *) "self", NULL
27750     };
27751
27752     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewControlBar_base_CreateButtons",kwnames,&obj0)) goto fail;
27753     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27754     if (SWIG_arg_fail(1)) SWIG_fail;
27755     {
27756         PyThreadState* __tstate = wxPyBeginAllowThreads();
27757         (arg1)->base_CreateButtons();
27758
27759         wxPyEndAllowThreads(__tstate);
27760         if (PyErr_Occurred()) SWIG_fail;
27761     }
27762     Py_INCREF(Py_None); resultobj = Py_None;
27763     return resultobj;
27764     fail:
27765     return NULL;
27766 }
27767
27768
27769 static PyObject *_wrap_PyPreviewControlBar_base_SetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
27770     PyObject *resultobj;
27771     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27772     int arg2 ;
27773     PyObject * obj0 = 0 ;
27774     PyObject * obj1 = 0 ;
27775     char *kwnames[] = {
27776         (char *) "self",(char *) "zoom", NULL
27777     };
27778
27779     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewControlBar_base_SetZoomControl",kwnames,&obj0,&obj1)) goto fail;
27780     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27781     if (SWIG_arg_fail(1)) SWIG_fail;
27782     {
27783         arg2 = (int)(SWIG_As_int(obj1));
27784         if (SWIG_arg_fail(2)) SWIG_fail;
27785     }
27786     {
27787         PyThreadState* __tstate = wxPyBeginAllowThreads();
27788         (arg1)->base_SetZoomControl(arg2);
27789
27790         wxPyEndAllowThreads(__tstate);
27791         if (PyErr_Occurred()) SWIG_fail;
27792     }
27793     Py_INCREF(Py_None); resultobj = Py_None;
27794     return resultobj;
27795     fail:
27796     return NULL;
27797 }
27798
27799
27800 static PyObject * PyPreviewControlBar_swigregister(PyObject *, PyObject *args) {
27801     PyObject *obj;
27802     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27803     SWIG_TypeClientData(SWIGTYPE_p_wxPyPreviewControlBar, obj);
27804     Py_INCREF(obj);
27805     return Py_BuildValue((char *)"");
27806 }
27807 static PyMethodDef SwigMethods[] = {
27808          { (char *)"new_Panel", (PyCFunction) _wrap_new_Panel, METH_VARARGS | METH_KEYWORDS, NULL},
27809          { (char *)"new_PrePanel", (PyCFunction) _wrap_new_PrePanel, METH_VARARGS | METH_KEYWORDS, NULL},
27810          { (char *)"Panel_Create", (PyCFunction) _wrap_Panel_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27811          { (char *)"Panel_InitDialog", (PyCFunction) _wrap_Panel_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27812          { (char *)"Panel_SetFocus", (PyCFunction) _wrap_Panel_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
27813          { (char *)"Panel_SetFocusIgnoringChildren", (PyCFunction) _wrap_Panel_SetFocusIgnoringChildren, METH_VARARGS | METH_KEYWORDS, NULL},
27814          { (char *)"Panel_GetClassDefaultAttributes", (PyCFunction) _wrap_Panel_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27815          { (char *)"Panel_swigregister", Panel_swigregister, METH_VARARGS, NULL},
27816          { (char *)"new_ScrolledWindow", (PyCFunction) _wrap_new_ScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27817          { (char *)"new_PreScrolledWindow", (PyCFunction) _wrap_new_PreScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27818          { (char *)"ScrolledWindow_Create", (PyCFunction) _wrap_ScrolledWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27819          { (char *)"ScrolledWindow_SetScrollbars", (PyCFunction) _wrap_ScrolledWindow_SetScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
27820          { (char *)"ScrolledWindow_Scroll", (PyCFunction) _wrap_ScrolledWindow_Scroll, METH_VARARGS | METH_KEYWORDS, NULL},
27821          { (char *)"ScrolledWindow_GetScrollPageSize", (PyCFunction) _wrap_ScrolledWindow_GetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
27822          { (char *)"ScrolledWindow_SetScrollPageSize", (PyCFunction) _wrap_ScrolledWindow_SetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
27823          { (char *)"ScrolledWindow_SetScrollRate", (PyCFunction) _wrap_ScrolledWindow_SetScrollRate, METH_VARARGS | METH_KEYWORDS, NULL},
27824          { (char *)"ScrolledWindow_GetScrollPixelsPerUnit", (PyCFunction) _wrap_ScrolledWindow_GetScrollPixelsPerUnit, METH_VARARGS | METH_KEYWORDS, NULL},
27825          { (char *)"ScrolledWindow_EnableScrolling", (PyCFunction) _wrap_ScrolledWindow_EnableScrolling, METH_VARARGS | METH_KEYWORDS, NULL},
27826          { (char *)"ScrolledWindow_GetViewStart", (PyCFunction) _wrap_ScrolledWindow_GetViewStart, METH_VARARGS | METH_KEYWORDS, NULL},
27827          { (char *)"ScrolledWindow_SetScale", (PyCFunction) _wrap_ScrolledWindow_SetScale, METH_VARARGS | METH_KEYWORDS, NULL},
27828          { (char *)"ScrolledWindow_GetScaleX", (PyCFunction) _wrap_ScrolledWindow_GetScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
27829          { (char *)"ScrolledWindow_GetScaleY", (PyCFunction) _wrap_ScrolledWindow_GetScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
27830          { (char *)"ScrolledWindow_CalcScrolledPosition", _wrap_ScrolledWindow_CalcScrolledPosition, METH_VARARGS, NULL},
27831          { (char *)"ScrolledWindow_CalcUnscrolledPosition", _wrap_ScrolledWindow_CalcUnscrolledPosition, METH_VARARGS, NULL},
27832          { (char *)"ScrolledWindow_AdjustScrollbars", (PyCFunction) _wrap_ScrolledWindow_AdjustScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
27833          { (char *)"ScrolledWindow_CalcScrollInc", (PyCFunction) _wrap_ScrolledWindow_CalcScrollInc, METH_VARARGS | METH_KEYWORDS, NULL},
27834          { (char *)"ScrolledWindow_SetTargetWindow", (PyCFunction) _wrap_ScrolledWindow_SetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27835          { (char *)"ScrolledWindow_GetTargetWindow", (PyCFunction) _wrap_ScrolledWindow_GetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27836          { (char *)"ScrolledWindow_SetTargetRect", (PyCFunction) _wrap_ScrolledWindow_SetTargetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27837          { (char *)"ScrolledWindow_GetTargetRect", (PyCFunction) _wrap_ScrolledWindow_GetTargetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27838          { (char *)"ScrolledWindow_DoPrepareDC", (PyCFunction) _wrap_ScrolledWindow_DoPrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
27839          { (char *)"ScrolledWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_ScrolledWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27840          { (char *)"ScrolledWindow_swigregister", ScrolledWindow_swigregister, METH_VARARGS, NULL},
27841          { (char *)"TopLevelWindow_Maximize", (PyCFunction) _wrap_TopLevelWindow_Maximize, METH_VARARGS | METH_KEYWORDS, NULL},
27842          { (char *)"TopLevelWindow_Restore", (PyCFunction) _wrap_TopLevelWindow_Restore, METH_VARARGS | METH_KEYWORDS, NULL},
27843          { (char *)"TopLevelWindow_Iconize", (PyCFunction) _wrap_TopLevelWindow_Iconize, METH_VARARGS | METH_KEYWORDS, NULL},
27844          { (char *)"TopLevelWindow_IsMaximized", (PyCFunction) _wrap_TopLevelWindow_IsMaximized, METH_VARARGS | METH_KEYWORDS, NULL},
27845          { (char *)"TopLevelWindow_IsIconized", (PyCFunction) _wrap_TopLevelWindow_IsIconized, METH_VARARGS | METH_KEYWORDS, NULL},
27846          { (char *)"TopLevelWindow_GetIcon", (PyCFunction) _wrap_TopLevelWindow_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27847          { (char *)"TopLevelWindow_SetIcon", (PyCFunction) _wrap_TopLevelWindow_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27848          { (char *)"TopLevelWindow_SetIcons", (PyCFunction) _wrap_TopLevelWindow_SetIcons, METH_VARARGS | METH_KEYWORDS, NULL},
27849          { (char *)"TopLevelWindow_ShowFullScreen", (PyCFunction) _wrap_TopLevelWindow_ShowFullScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27850          { (char *)"TopLevelWindow_IsFullScreen", (PyCFunction) _wrap_TopLevelWindow_IsFullScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27851          { (char *)"TopLevelWindow_SetTitle", (PyCFunction) _wrap_TopLevelWindow_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
27852          { (char *)"TopLevelWindow_GetTitle", (PyCFunction) _wrap_TopLevelWindow_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
27853          { (char *)"TopLevelWindow_SetShape", (PyCFunction) _wrap_TopLevelWindow_SetShape, METH_VARARGS | METH_KEYWORDS, NULL},
27854          { (char *)"TopLevelWindow_RequestUserAttention", (PyCFunction) _wrap_TopLevelWindow_RequestUserAttention, METH_VARARGS | METH_KEYWORDS, NULL},
27855          { (char *)"TopLevelWindow_IsActive", (PyCFunction) _wrap_TopLevelWindow_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
27856          { (char *)"TopLevelWindow_MacSetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacSetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
27857          { (char *)"TopLevelWindow_MacGetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacGetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
27858          { (char *)"TopLevelWindow_swigregister", TopLevelWindow_swigregister, METH_VARARGS, NULL},
27859          { (char *)"new_Frame", (PyCFunction) _wrap_new_Frame, METH_VARARGS | METH_KEYWORDS, NULL},
27860          { (char *)"new_PreFrame", (PyCFunction) _wrap_new_PreFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27861          { (char *)"Frame_Create", (PyCFunction) _wrap_Frame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27862          { (char *)"Frame_GetClientAreaOrigin", (PyCFunction) _wrap_Frame_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
27863          { (char *)"Frame_SendSizeEvent", (PyCFunction) _wrap_Frame_SendSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27864          { (char *)"Frame_SetMenuBar", (PyCFunction) _wrap_Frame_SetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
27865          { (char *)"Frame_GetMenuBar", (PyCFunction) _wrap_Frame_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
27866          { (char *)"Frame_ProcessCommand", (PyCFunction) _wrap_Frame_ProcessCommand, METH_VARARGS | METH_KEYWORDS, NULL},
27867          { (char *)"Frame_CreateStatusBar", (PyCFunction) _wrap_Frame_CreateStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27868          { (char *)"Frame_GetStatusBar", (PyCFunction) _wrap_Frame_GetStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27869          { (char *)"Frame_SetStatusBar", (PyCFunction) _wrap_Frame_SetStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27870          { (char *)"Frame_SetStatusText", (PyCFunction) _wrap_Frame_SetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27871          { (char *)"Frame_SetStatusWidths", (PyCFunction) _wrap_Frame_SetStatusWidths, METH_VARARGS | METH_KEYWORDS, NULL},
27872          { (char *)"Frame_PushStatusText", (PyCFunction) _wrap_Frame_PushStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27873          { (char *)"Frame_PopStatusText", (PyCFunction) _wrap_Frame_PopStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27874          { (char *)"Frame_SetStatusBarPane", (PyCFunction) _wrap_Frame_SetStatusBarPane, METH_VARARGS | METH_KEYWORDS, NULL},
27875          { (char *)"Frame_GetStatusBarPane", (PyCFunction) _wrap_Frame_GetStatusBarPane, METH_VARARGS | METH_KEYWORDS, NULL},
27876          { (char *)"Frame_CreateToolBar", (PyCFunction) _wrap_Frame_CreateToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27877          { (char *)"Frame_GetToolBar", (PyCFunction) _wrap_Frame_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27878          { (char *)"Frame_SetToolBar", (PyCFunction) _wrap_Frame_SetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27879          { (char *)"Frame_DoGiveHelp", (PyCFunction) _wrap_Frame_DoGiveHelp, METH_VARARGS | METH_KEYWORDS, NULL},
27880          { (char *)"Frame_DoMenuUpdates", (PyCFunction) _wrap_Frame_DoMenuUpdates, METH_VARARGS | METH_KEYWORDS, NULL},
27881          { (char *)"Frame_GetClassDefaultAttributes", (PyCFunction) _wrap_Frame_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27882          { (char *)"Frame_swigregister", Frame_swigregister, METH_VARARGS, NULL},
27883          { (char *)"new_Dialog", (PyCFunction) _wrap_new_Dialog, METH_VARARGS | METH_KEYWORDS, NULL},
27884          { (char *)"new_PreDialog", (PyCFunction) _wrap_new_PreDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27885          { (char *)"Dialog_Create", (PyCFunction) _wrap_Dialog_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27886          { (char *)"Dialog_SetReturnCode", (PyCFunction) _wrap_Dialog_SetReturnCode, METH_VARARGS | METH_KEYWORDS, NULL},
27887          { (char *)"Dialog_GetReturnCode", (PyCFunction) _wrap_Dialog_GetReturnCode, METH_VARARGS | METH_KEYWORDS, NULL},
27888          { (char *)"Dialog_CreateTextSizer", (PyCFunction) _wrap_Dialog_CreateTextSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27889          { (char *)"Dialog_CreateButtonSizer", (PyCFunction) _wrap_Dialog_CreateButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27890          { (char *)"Dialog_CreateStdDialogButtonSizer", (PyCFunction) _wrap_Dialog_CreateStdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27891          { (char *)"Dialog_IsModal", (PyCFunction) _wrap_Dialog_IsModal, METH_VARARGS | METH_KEYWORDS, NULL},
27892          { (char *)"Dialog_ShowModal", (PyCFunction) _wrap_Dialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
27893          { (char *)"Dialog_EndModal", (PyCFunction) _wrap_Dialog_EndModal, METH_VARARGS | METH_KEYWORDS, NULL},
27894          { (char *)"Dialog_GetClassDefaultAttributes", (PyCFunction) _wrap_Dialog_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27895          { (char *)"Dialog_swigregister", Dialog_swigregister, METH_VARARGS, NULL},
27896          { (char *)"new_MiniFrame", (PyCFunction) _wrap_new_MiniFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27897          { (char *)"new_PreMiniFrame", (PyCFunction) _wrap_new_PreMiniFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27898          { (char *)"MiniFrame_Create", (PyCFunction) _wrap_MiniFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27899          { (char *)"MiniFrame_swigregister", MiniFrame_swigregister, METH_VARARGS, NULL},
27900          { (char *)"new_SplashScreenWindow", (PyCFunction) _wrap_new_SplashScreenWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27901          { (char *)"SplashScreenWindow_SetBitmap", (PyCFunction) _wrap_SplashScreenWindow_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
27902          { (char *)"SplashScreenWindow_GetBitmap", (PyCFunction) _wrap_SplashScreenWindow_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
27903          { (char *)"SplashScreenWindow_swigregister", SplashScreenWindow_swigregister, METH_VARARGS, NULL},
27904          { (char *)"new_SplashScreen", (PyCFunction) _wrap_new_SplashScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27905          { (char *)"SplashScreen_GetSplashStyle", (PyCFunction) _wrap_SplashScreen_GetSplashStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27906          { (char *)"SplashScreen_GetSplashWindow", (PyCFunction) _wrap_SplashScreen_GetSplashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27907          { (char *)"SplashScreen_GetTimeout", (PyCFunction) _wrap_SplashScreen_GetTimeout, METH_VARARGS | METH_KEYWORDS, NULL},
27908          { (char *)"SplashScreen_swigregister", SplashScreen_swigregister, METH_VARARGS, NULL},
27909          { (char *)"new_StatusBar", (PyCFunction) _wrap_new_StatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27910          { (char *)"new_PreStatusBar", (PyCFunction) _wrap_new_PreStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27911          { (char *)"StatusBar_Create", (PyCFunction) _wrap_StatusBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27912          { (char *)"StatusBar_SetFieldsCount", (PyCFunction) _wrap_StatusBar_SetFieldsCount, METH_VARARGS | METH_KEYWORDS, NULL},
27913          { (char *)"StatusBar_GetFieldsCount", (PyCFunction) _wrap_StatusBar_GetFieldsCount, METH_VARARGS | METH_KEYWORDS, NULL},
27914          { (char *)"StatusBar_SetStatusText", (PyCFunction) _wrap_StatusBar_SetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27915          { (char *)"StatusBar_GetStatusText", (PyCFunction) _wrap_StatusBar_GetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27916          { (char *)"StatusBar_PushStatusText", (PyCFunction) _wrap_StatusBar_PushStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27917          { (char *)"StatusBar_PopStatusText", (PyCFunction) _wrap_StatusBar_PopStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27918          { (char *)"StatusBar_SetStatusWidths", (PyCFunction) _wrap_StatusBar_SetStatusWidths, METH_VARARGS | METH_KEYWORDS, NULL},
27919          { (char *)"StatusBar_SetStatusStyles", (PyCFunction) _wrap_StatusBar_SetStatusStyles, METH_VARARGS | METH_KEYWORDS, NULL},
27920          { (char *)"StatusBar_GetFieldRect", (PyCFunction) _wrap_StatusBar_GetFieldRect, METH_VARARGS | METH_KEYWORDS, NULL},
27921          { (char *)"StatusBar_SetMinHeight", (PyCFunction) _wrap_StatusBar_SetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
27922          { (char *)"StatusBar_GetBorderX", (PyCFunction) _wrap_StatusBar_GetBorderX, METH_VARARGS | METH_KEYWORDS, NULL},
27923          { (char *)"StatusBar_GetBorderY", (PyCFunction) _wrap_StatusBar_GetBorderY, METH_VARARGS | METH_KEYWORDS, NULL},
27924          { (char *)"StatusBar_GetClassDefaultAttributes", (PyCFunction) _wrap_StatusBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27925          { (char *)"StatusBar_swigregister", StatusBar_swigregister, METH_VARARGS, NULL},
27926          { (char *)"new_SplitterWindow", (PyCFunction) _wrap_new_SplitterWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27927          { (char *)"new_PreSplitterWindow", (PyCFunction) _wrap_new_PreSplitterWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27928          { (char *)"SplitterWindow_Create", (PyCFunction) _wrap_SplitterWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27929          { (char *)"SplitterWindow_GetWindow1", (PyCFunction) _wrap_SplitterWindow_GetWindow1, METH_VARARGS | METH_KEYWORDS, NULL},
27930          { (char *)"SplitterWindow_GetWindow2", (PyCFunction) _wrap_SplitterWindow_GetWindow2, METH_VARARGS | METH_KEYWORDS, NULL},
27931          { (char *)"SplitterWindow_SetSplitMode", (PyCFunction) _wrap_SplitterWindow_SetSplitMode, METH_VARARGS | METH_KEYWORDS, NULL},
27932          { (char *)"SplitterWindow_GetSplitMode", (PyCFunction) _wrap_SplitterWindow_GetSplitMode, METH_VARARGS | METH_KEYWORDS, NULL},
27933          { (char *)"SplitterWindow_Initialize", (PyCFunction) _wrap_SplitterWindow_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
27934          { (char *)"SplitterWindow_SplitVertically", (PyCFunction) _wrap_SplitterWindow_SplitVertically, METH_VARARGS | METH_KEYWORDS, NULL},
27935          { (char *)"SplitterWindow_SplitHorizontally", (PyCFunction) _wrap_SplitterWindow_SplitHorizontally, METH_VARARGS | METH_KEYWORDS, NULL},
27936          { (char *)"SplitterWindow_Unsplit", (PyCFunction) _wrap_SplitterWindow_Unsplit, METH_VARARGS | METH_KEYWORDS, NULL},
27937          { (char *)"SplitterWindow_ReplaceWindow", (PyCFunction) _wrap_SplitterWindow_ReplaceWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27938          { (char *)"SplitterWindow_UpdateSize", (PyCFunction) _wrap_SplitterWindow_UpdateSize, METH_VARARGS | METH_KEYWORDS, NULL},
27939          { (char *)"SplitterWindow_IsSplit", (PyCFunction) _wrap_SplitterWindow_IsSplit, METH_VARARGS | METH_KEYWORDS, NULL},
27940          { (char *)"SplitterWindow_SetSashSize", (PyCFunction) _wrap_SplitterWindow_SetSashSize, METH_VARARGS | METH_KEYWORDS, NULL},
27941          { (char *)"SplitterWindow_SetBorderSize", (PyCFunction) _wrap_SplitterWindow_SetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27942          { (char *)"SplitterWindow_GetSashSize", (PyCFunction) _wrap_SplitterWindow_GetSashSize, METH_VARARGS | METH_KEYWORDS, NULL},
27943          { (char *)"SplitterWindow_GetBorderSize", (PyCFunction) _wrap_SplitterWindow_GetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27944          { (char *)"SplitterWindow_SetSashPosition", (PyCFunction) _wrap_SplitterWindow_SetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27945          { (char *)"SplitterWindow_GetSashPosition", (PyCFunction) _wrap_SplitterWindow_GetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27946          { (char *)"SplitterWindow_SetSashGravity", (PyCFunction) _wrap_SplitterWindow_SetSashGravity, METH_VARARGS | METH_KEYWORDS, NULL},
27947          { (char *)"SplitterWindow_GetSashGravity", (PyCFunction) _wrap_SplitterWindow_GetSashGravity, METH_VARARGS | METH_KEYWORDS, NULL},
27948          { (char *)"SplitterWindow_SetMinimumPaneSize", (PyCFunction) _wrap_SplitterWindow_SetMinimumPaneSize, METH_VARARGS | METH_KEYWORDS, NULL},
27949          { (char *)"SplitterWindow_GetMinimumPaneSize", (PyCFunction) _wrap_SplitterWindow_GetMinimumPaneSize, METH_VARARGS | METH_KEYWORDS, NULL},
27950          { (char *)"SplitterWindow_SashHitTest", (PyCFunction) _wrap_SplitterWindow_SashHitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27951          { (char *)"SplitterWindow_SizeWindows", (PyCFunction) _wrap_SplitterWindow_SizeWindows, METH_VARARGS | METH_KEYWORDS, NULL},
27952          { (char *)"SplitterWindow_SetNeedUpdating", (PyCFunction) _wrap_SplitterWindow_SetNeedUpdating, METH_VARARGS | METH_KEYWORDS, NULL},
27953          { (char *)"SplitterWindow_GetNeedUpdating", (PyCFunction) _wrap_SplitterWindow_GetNeedUpdating, METH_VARARGS | METH_KEYWORDS, NULL},
27954          { (char *)"SplitterWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_SplitterWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27955          { (char *)"SplitterWindow_swigregister", SplitterWindow_swigregister, METH_VARARGS, NULL},
27956          { (char *)"new_SplitterEvent", (PyCFunction) _wrap_new_SplitterEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27957          { (char *)"SplitterEvent_SetSashPosition", (PyCFunction) _wrap_SplitterEvent_SetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27958          { (char *)"SplitterEvent_GetSashPosition", (PyCFunction) _wrap_SplitterEvent_GetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27959          { (char *)"SplitterEvent_GetWindowBeingRemoved", (PyCFunction) _wrap_SplitterEvent_GetWindowBeingRemoved, METH_VARARGS | METH_KEYWORDS, NULL},
27960          { (char *)"SplitterEvent_GetX", (PyCFunction) _wrap_SplitterEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
27961          { (char *)"SplitterEvent_GetY", (PyCFunction) _wrap_SplitterEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
27962          { (char *)"SplitterEvent_swigregister", SplitterEvent_swigregister, METH_VARARGS, NULL},
27963          { (char *)"new_SashWindow", (PyCFunction) _wrap_new_SashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27964          { (char *)"new_PreSashWindow", (PyCFunction) _wrap_new_PreSashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27965          { (char *)"SashWindow_Create", (PyCFunction) _wrap_SashWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27966          { (char *)"SashWindow_SetSashVisible", (PyCFunction) _wrap_SashWindow_SetSashVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27967          { (char *)"SashWindow_GetSashVisible", (PyCFunction) _wrap_SashWindow_GetSashVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27968          { (char *)"SashWindow_SetSashBorder", (PyCFunction) _wrap_SashWindow_SetSashBorder, METH_VARARGS | METH_KEYWORDS, NULL},
27969          { (char *)"SashWindow_HasBorder", (PyCFunction) _wrap_SashWindow_HasBorder, METH_VARARGS | METH_KEYWORDS, NULL},
27970          { (char *)"SashWindow_GetEdgeMargin", (PyCFunction) _wrap_SashWindow_GetEdgeMargin, METH_VARARGS | METH_KEYWORDS, NULL},
27971          { (char *)"SashWindow_SetDefaultBorderSize", (PyCFunction) _wrap_SashWindow_SetDefaultBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27972          { (char *)"SashWindow_GetDefaultBorderSize", (PyCFunction) _wrap_SashWindow_GetDefaultBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27973          { (char *)"SashWindow_SetExtraBorderSize", (PyCFunction) _wrap_SashWindow_SetExtraBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27974          { (char *)"SashWindow_GetExtraBorderSize", (PyCFunction) _wrap_SashWindow_GetExtraBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27975          { (char *)"SashWindow_SetMinimumSizeX", (PyCFunction) _wrap_SashWindow_SetMinimumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27976          { (char *)"SashWindow_SetMinimumSizeY", (PyCFunction) _wrap_SashWindow_SetMinimumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27977          { (char *)"SashWindow_GetMinimumSizeX", (PyCFunction) _wrap_SashWindow_GetMinimumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27978          { (char *)"SashWindow_GetMinimumSizeY", (PyCFunction) _wrap_SashWindow_GetMinimumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27979          { (char *)"SashWindow_SetMaximumSizeX", (PyCFunction) _wrap_SashWindow_SetMaximumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27980          { (char *)"SashWindow_SetMaximumSizeY", (PyCFunction) _wrap_SashWindow_SetMaximumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27981          { (char *)"SashWindow_GetMaximumSizeX", (PyCFunction) _wrap_SashWindow_GetMaximumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27982          { (char *)"SashWindow_GetMaximumSizeY", (PyCFunction) _wrap_SashWindow_GetMaximumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27983          { (char *)"SashWindow_SashHitTest", (PyCFunction) _wrap_SashWindow_SashHitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27984          { (char *)"SashWindow_SizeWindows", (PyCFunction) _wrap_SashWindow_SizeWindows, METH_VARARGS | METH_KEYWORDS, NULL},
27985          { (char *)"SashWindow_swigregister", SashWindow_swigregister, METH_VARARGS, NULL},
27986          { (char *)"new_SashEvent", (PyCFunction) _wrap_new_SashEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27987          { (char *)"SashEvent_SetEdge", (PyCFunction) _wrap_SashEvent_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
27988          { (char *)"SashEvent_GetEdge", (PyCFunction) _wrap_SashEvent_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
27989          { (char *)"SashEvent_SetDragRect", (PyCFunction) _wrap_SashEvent_SetDragRect, METH_VARARGS | METH_KEYWORDS, NULL},
27990          { (char *)"SashEvent_GetDragRect", (PyCFunction) _wrap_SashEvent_GetDragRect, METH_VARARGS | METH_KEYWORDS, NULL},
27991          { (char *)"SashEvent_SetDragStatus", (PyCFunction) _wrap_SashEvent_SetDragStatus, METH_VARARGS | METH_KEYWORDS, NULL},
27992          { (char *)"SashEvent_GetDragStatus", (PyCFunction) _wrap_SashEvent_GetDragStatus, METH_VARARGS | METH_KEYWORDS, NULL},
27993          { (char *)"SashEvent_swigregister", SashEvent_swigregister, METH_VARARGS, NULL},
27994          { (char *)"new_QueryLayoutInfoEvent", (PyCFunction) _wrap_new_QueryLayoutInfoEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27995          { (char *)"QueryLayoutInfoEvent_SetRequestedLength", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetRequestedLength, METH_VARARGS | METH_KEYWORDS, NULL},
27996          { (char *)"QueryLayoutInfoEvent_GetRequestedLength", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetRequestedLength, METH_VARARGS | METH_KEYWORDS, NULL},
27997          { (char *)"QueryLayoutInfoEvent_SetFlags", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27998          { (char *)"QueryLayoutInfoEvent_GetFlags", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27999          { (char *)"QueryLayoutInfoEvent_SetSize", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28000          { (char *)"QueryLayoutInfoEvent_GetSize", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28001          { (char *)"QueryLayoutInfoEvent_SetOrientation", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28002          { (char *)"QueryLayoutInfoEvent_GetOrientation", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28003          { (char *)"QueryLayoutInfoEvent_SetAlignment", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
28004          { (char *)"QueryLayoutInfoEvent_GetAlignment", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
28005          { (char *)"QueryLayoutInfoEvent_swigregister", QueryLayoutInfoEvent_swigregister, METH_VARARGS, NULL},
28006          { (char *)"new_CalculateLayoutEvent", (PyCFunction) _wrap_new_CalculateLayoutEvent, METH_VARARGS | METH_KEYWORDS, NULL},
28007          { (char *)"CalculateLayoutEvent_SetFlags", (PyCFunction) _wrap_CalculateLayoutEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28008          { (char *)"CalculateLayoutEvent_GetFlags", (PyCFunction) _wrap_CalculateLayoutEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28009          { (char *)"CalculateLayoutEvent_SetRect", (PyCFunction) _wrap_CalculateLayoutEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
28010          { (char *)"CalculateLayoutEvent_GetRect", (PyCFunction) _wrap_CalculateLayoutEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
28011          { (char *)"CalculateLayoutEvent_swigregister", CalculateLayoutEvent_swigregister, METH_VARARGS, NULL},
28012          { (char *)"new_SashLayoutWindow", (PyCFunction) _wrap_new_SashLayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28013          { (char *)"new_PreSashLayoutWindow", (PyCFunction) _wrap_new_PreSashLayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28014          { (char *)"SashLayoutWindow_Create", (PyCFunction) _wrap_SashLayoutWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28015          { (char *)"SashLayoutWindow_GetAlignment", (PyCFunction) _wrap_SashLayoutWindow_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
28016          { (char *)"SashLayoutWindow_GetOrientation", (PyCFunction) _wrap_SashLayoutWindow_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28017          { (char *)"SashLayoutWindow_SetAlignment", (PyCFunction) _wrap_SashLayoutWindow_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
28018          { (char *)"SashLayoutWindow_SetDefaultSize", (PyCFunction) _wrap_SashLayoutWindow_SetDefaultSize, METH_VARARGS | METH_KEYWORDS, NULL},
28019          { (char *)"SashLayoutWindow_SetOrientation", (PyCFunction) _wrap_SashLayoutWindow_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28020          { (char *)"SashLayoutWindow_swigregister", SashLayoutWindow_swigregister, METH_VARARGS, NULL},
28021          { (char *)"new_LayoutAlgorithm", (PyCFunction) _wrap_new_LayoutAlgorithm, METH_VARARGS | METH_KEYWORDS, NULL},
28022          { (char *)"delete_LayoutAlgorithm", (PyCFunction) _wrap_delete_LayoutAlgorithm, METH_VARARGS | METH_KEYWORDS, NULL},
28023          { (char *)"LayoutAlgorithm_LayoutMDIFrame", (PyCFunction) _wrap_LayoutAlgorithm_LayoutMDIFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28024          { (char *)"LayoutAlgorithm_LayoutFrame", (PyCFunction) _wrap_LayoutAlgorithm_LayoutFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28025          { (char *)"LayoutAlgorithm_LayoutWindow", (PyCFunction) _wrap_LayoutAlgorithm_LayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28026          { (char *)"LayoutAlgorithm_swigregister", LayoutAlgorithm_swigregister, METH_VARARGS, NULL},
28027          { (char *)"new_PopupWindow", (PyCFunction) _wrap_new_PopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28028          { (char *)"new_PrePopupWindow", (PyCFunction) _wrap_new_PrePopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28029          { (char *)"PopupWindow_Create", (PyCFunction) _wrap_PopupWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28030          { (char *)"PopupWindow_Position", (PyCFunction) _wrap_PopupWindow_Position, METH_VARARGS | METH_KEYWORDS, NULL},
28031          { (char *)"PopupWindow_swigregister", PopupWindow_swigregister, METH_VARARGS, NULL},
28032          { (char *)"new_PopupTransientWindow", (PyCFunction) _wrap_new_PopupTransientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28033          { (char *)"new_PrePopupTransientWindow", (PyCFunction) _wrap_new_PrePopupTransientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28034          { (char *)"PopupTransientWindow__setCallbackInfo", (PyCFunction) _wrap_PopupTransientWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28035          { (char *)"PopupTransientWindow_Popup", (PyCFunction) _wrap_PopupTransientWindow_Popup, METH_VARARGS | METH_KEYWORDS, NULL},
28036          { (char *)"PopupTransientWindow_Dismiss", (PyCFunction) _wrap_PopupTransientWindow_Dismiss, METH_VARARGS | METH_KEYWORDS, NULL},
28037          { (char *)"PopupTransientWindow_swigregister", PopupTransientWindow_swigregister, METH_VARARGS, NULL},
28038          { (char *)"new_TipWindow", (PyCFunction) _wrap_new_TipWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28039          { (char *)"TipWindow_SetBoundingRect", (PyCFunction) _wrap_TipWindow_SetBoundingRect, METH_VARARGS | METH_KEYWORDS, NULL},
28040          { (char *)"TipWindow_Close", (PyCFunction) _wrap_TipWindow_Close, METH_VARARGS | METH_KEYWORDS, NULL},
28041          { (char *)"TipWindow_swigregister", TipWindow_swigregister, METH_VARARGS, NULL},
28042          { (char *)"new_VScrolledWindow", (PyCFunction) _wrap_new_VScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28043          { (char *)"new_PreVScrolledWindow", (PyCFunction) _wrap_new_PreVScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28044          { (char *)"VScrolledWindow__setCallbackInfo", (PyCFunction) _wrap_VScrolledWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28045          { (char *)"VScrolledWindow_Create", (PyCFunction) _wrap_VScrolledWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28046          { (char *)"VScrolledWindow_SetLineCount", (PyCFunction) _wrap_VScrolledWindow_SetLineCount, METH_VARARGS | METH_KEYWORDS, NULL},
28047          { (char *)"VScrolledWindow_ScrollToLine", (PyCFunction) _wrap_VScrolledWindow_ScrollToLine, METH_VARARGS | METH_KEYWORDS, NULL},
28048          { (char *)"VScrolledWindow_ScrollLines", (PyCFunction) _wrap_VScrolledWindow_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
28049          { (char *)"VScrolledWindow_ScrollPages", (PyCFunction) _wrap_VScrolledWindow_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
28050          { (char *)"VScrolledWindow_RefreshLine", (PyCFunction) _wrap_VScrolledWindow_RefreshLine, METH_VARARGS | METH_KEYWORDS, NULL},
28051          { (char *)"VScrolledWindow_RefreshLines", (PyCFunction) _wrap_VScrolledWindow_RefreshLines, METH_VARARGS | METH_KEYWORDS, NULL},
28052          { (char *)"VScrolledWindow_HitTestXY", (PyCFunction) _wrap_VScrolledWindow_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
28053          { (char *)"VScrolledWindow_HitTest", (PyCFunction) _wrap_VScrolledWindow_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
28054          { (char *)"VScrolledWindow_RefreshAll", (PyCFunction) _wrap_VScrolledWindow_RefreshAll, METH_VARARGS | METH_KEYWORDS, NULL},
28055          { (char *)"VScrolledWindow_GetLineCount", (PyCFunction) _wrap_VScrolledWindow_GetLineCount, METH_VARARGS | METH_KEYWORDS, NULL},
28056          { (char *)"VScrolledWindow_GetFirstVisibleLine", (PyCFunction) _wrap_VScrolledWindow_GetFirstVisibleLine, METH_VARARGS | METH_KEYWORDS, NULL},
28057          { (char *)"VScrolledWindow_GetLastVisibleLine", (PyCFunction) _wrap_VScrolledWindow_GetLastVisibleLine, METH_VARARGS | METH_KEYWORDS, NULL},
28058          { (char *)"VScrolledWindow_IsVisible", (PyCFunction) _wrap_VScrolledWindow_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
28059          { (char *)"VScrolledWindow_swigregister", VScrolledWindow_swigregister, METH_VARARGS, NULL},
28060          { (char *)"new_VListBox", (PyCFunction) _wrap_new_VListBox, METH_VARARGS | METH_KEYWORDS, NULL},
28061          { (char *)"new_PreVListBox", (PyCFunction) _wrap_new_PreVListBox, METH_VARARGS | METH_KEYWORDS, NULL},
28062          { (char *)"VListBox__setCallbackInfo", (PyCFunction) _wrap_VListBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28063          { (char *)"VListBox_Create", (PyCFunction) _wrap_VListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28064          { (char *)"VListBox_GetItemCount", (PyCFunction) _wrap_VListBox_GetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
28065          { (char *)"VListBox_HasMultipleSelection", (PyCFunction) _wrap_VListBox_HasMultipleSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28066          { (char *)"VListBox_GetSelection", (PyCFunction) _wrap_VListBox_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28067          { (char *)"VListBox_IsCurrent", (PyCFunction) _wrap_VListBox_IsCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
28068          { (char *)"VListBox_IsSelected", (PyCFunction) _wrap_VListBox_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
28069          { (char *)"VListBox_GetSelectedCount", (PyCFunction) _wrap_VListBox_GetSelectedCount, METH_VARARGS | METH_KEYWORDS, NULL},
28070          { (char *)"VListBox_GetFirstSelected", (PyCFunction) _wrap_VListBox_GetFirstSelected, METH_VARARGS | METH_KEYWORDS, NULL},
28071          { (char *)"VListBox_GetNextSelected", (PyCFunction) _wrap_VListBox_GetNextSelected, METH_VARARGS | METH_KEYWORDS, NULL},
28072          { (char *)"VListBox_GetMargins", (PyCFunction) _wrap_VListBox_GetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28073          { (char *)"VListBox_GetSelectionBackground", (PyCFunction) _wrap_VListBox_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28074          { (char *)"VListBox_SetItemCount", (PyCFunction) _wrap_VListBox_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
28075          { (char *)"VListBox_Clear", (PyCFunction) _wrap_VListBox_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
28076          { (char *)"VListBox_SetSelection", (PyCFunction) _wrap_VListBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28077          { (char *)"VListBox_Select", (PyCFunction) _wrap_VListBox_Select, METH_VARARGS | METH_KEYWORDS, NULL},
28078          { (char *)"VListBox_SelectRange", (PyCFunction) _wrap_VListBox_SelectRange, METH_VARARGS | METH_KEYWORDS, NULL},
28079          { (char *)"VListBox_Toggle", (PyCFunction) _wrap_VListBox_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
28080          { (char *)"VListBox_SelectAll", (PyCFunction) _wrap_VListBox_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
28081          { (char *)"VListBox_DeselectAll", (PyCFunction) _wrap_VListBox_DeselectAll, METH_VARARGS | METH_KEYWORDS, NULL},
28082          { (char *)"VListBox_SetMargins", (PyCFunction) _wrap_VListBox_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28083          { (char *)"VListBox_SetMarginsXY", (PyCFunction) _wrap_VListBox_SetMarginsXY, METH_VARARGS | METH_KEYWORDS, NULL},
28084          { (char *)"VListBox_SetSelectionBackground", (PyCFunction) _wrap_VListBox_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28085          { (char *)"VListBox_swigregister", VListBox_swigregister, METH_VARARGS, NULL},
28086          { (char *)"new_HtmlListBox", (PyCFunction) _wrap_new_HtmlListBox, METH_VARARGS | METH_KEYWORDS, NULL},
28087          { (char *)"new_PreHtmlListBox", (PyCFunction) _wrap_new_PreHtmlListBox, METH_VARARGS | METH_KEYWORDS, NULL},
28088          { (char *)"HtmlListBox__setCallbackInfo", (PyCFunction) _wrap_HtmlListBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28089          { (char *)"HtmlListBox_Create", (PyCFunction) _wrap_HtmlListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28090          { (char *)"HtmlListBox_RefreshAll", (PyCFunction) _wrap_HtmlListBox_RefreshAll, METH_VARARGS | METH_KEYWORDS, NULL},
28091          { (char *)"HtmlListBox_SetItemCount", (PyCFunction) _wrap_HtmlListBox_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
28092          { (char *)"HtmlListBox_GetFileSystem", (PyCFunction) _wrap_HtmlListBox_GetFileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
28093          { (char *)"HtmlListBox_swigregister", HtmlListBox_swigregister, METH_VARARGS, NULL},
28094          { (char *)"new_TaskBarIcon", (PyCFunction) _wrap_new_TaskBarIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28095          { (char *)"TaskBarIcon__setCallbackInfo", (PyCFunction) _wrap_TaskBarIcon__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28096          { (char *)"TaskBarIcon_Destroy", (PyCFunction) _wrap_TaskBarIcon_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
28097          { (char *)"TaskBarIcon_IsOk", (PyCFunction) _wrap_TaskBarIcon_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
28098          { (char *)"TaskBarIcon_IsIconInstalled", (PyCFunction) _wrap_TaskBarIcon_IsIconInstalled, METH_VARARGS | METH_KEYWORDS, NULL},
28099          { (char *)"TaskBarIcon_SetIcon", (PyCFunction) _wrap_TaskBarIcon_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28100          { (char *)"TaskBarIcon_RemoveIcon", (PyCFunction) _wrap_TaskBarIcon_RemoveIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28101          { (char *)"TaskBarIcon_PopupMenu", (PyCFunction) _wrap_TaskBarIcon_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
28102          { (char *)"TaskBarIcon_swigregister", TaskBarIcon_swigregister, METH_VARARGS, NULL},
28103          { (char *)"new_TaskBarIconEvent", (PyCFunction) _wrap_new_TaskBarIconEvent, METH_VARARGS | METH_KEYWORDS, NULL},
28104          { (char *)"TaskBarIconEvent_swigregister", TaskBarIconEvent_swigregister, METH_VARARGS, NULL},
28105          { (char *)"new_ColourData", (PyCFunction) _wrap_new_ColourData, METH_VARARGS | METH_KEYWORDS, NULL},
28106          { (char *)"delete_ColourData", (PyCFunction) _wrap_delete_ColourData, METH_VARARGS | METH_KEYWORDS, NULL},
28107          { (char *)"ColourData_GetChooseFull", (PyCFunction) _wrap_ColourData_GetChooseFull, METH_VARARGS | METH_KEYWORDS, NULL},
28108          { (char *)"ColourData_GetColour", (PyCFunction) _wrap_ColourData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28109          { (char *)"ColourData_GetCustomColour", (PyCFunction) _wrap_ColourData_GetCustomColour, METH_VARARGS | METH_KEYWORDS, NULL},
28110          { (char *)"ColourData_SetChooseFull", (PyCFunction) _wrap_ColourData_SetChooseFull, METH_VARARGS | METH_KEYWORDS, NULL},
28111          { (char *)"ColourData_SetColour", (PyCFunction) _wrap_ColourData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28112          { (char *)"ColourData_SetCustomColour", (PyCFunction) _wrap_ColourData_SetCustomColour, METH_VARARGS | METH_KEYWORDS, NULL},
28113          { (char *)"ColourData_swigregister", ColourData_swigregister, METH_VARARGS, NULL},
28114          { (char *)"new_ColourDialog", (PyCFunction) _wrap_new_ColourDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28115          { (char *)"ColourDialog_GetColourData", (PyCFunction) _wrap_ColourDialog_GetColourData, METH_VARARGS | METH_KEYWORDS, NULL},
28116          { (char *)"ColourDialog_swigregister", ColourDialog_swigregister, METH_VARARGS, NULL},
28117          { (char *)"new_DirDialog", (PyCFunction) _wrap_new_DirDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28118          { (char *)"DirDialog_GetPath", (PyCFunction) _wrap_DirDialog_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
28119          { (char *)"DirDialog_GetMessage", (PyCFunction) _wrap_DirDialog_GetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
28120          { (char *)"DirDialog_GetStyle", (PyCFunction) _wrap_DirDialog_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
28121          { (char *)"DirDialog_SetMessage", (PyCFunction) _wrap_DirDialog_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
28122          { (char *)"DirDialog_SetPath", (PyCFunction) _wrap_DirDialog_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
28123          { (char *)"DirDialog_swigregister", DirDialog_swigregister, METH_VARARGS, NULL},
28124          { (char *)"new_FileDialog", (PyCFunction) _wrap_new_FileDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28125          { (char *)"FileDialog_SetMessage", (PyCFunction) _wrap_FileDialog_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
28126          { (char *)"FileDialog_SetPath", (PyCFunction) _wrap_FileDialog_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
28127          { (char *)"FileDialog_SetDirectory", (PyCFunction) _wrap_FileDialog_SetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
28128          { (char *)"FileDialog_SetFilename", (PyCFunction) _wrap_FileDialog_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28129          { (char *)"FileDialog_SetWildcard", (PyCFunction) _wrap_FileDialog_SetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
28130          { (char *)"FileDialog_SetStyle", (PyCFunction) _wrap_FileDialog_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
28131          { (char *)"FileDialog_SetFilterIndex", (PyCFunction) _wrap_FileDialog_SetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
28132          { (char *)"FileDialog_GetMessage", (PyCFunction) _wrap_FileDialog_GetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
28133          { (char *)"FileDialog_GetPath", (PyCFunction) _wrap_FileDialog_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
28134          { (char *)"FileDialog_GetDirectory", (PyCFunction) _wrap_FileDialog_GetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
28135          { (char *)"FileDialog_GetFilename", (PyCFunction) _wrap_FileDialog_GetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28136          { (char *)"FileDialog_GetWildcard", (PyCFunction) _wrap_FileDialog_GetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
28137          { (char *)"FileDialog_GetStyle", (PyCFunction) _wrap_FileDialog_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
28138          { (char *)"FileDialog_GetFilterIndex", (PyCFunction) _wrap_FileDialog_GetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
28139          { (char *)"FileDialog_GetFilenames", (PyCFunction) _wrap_FileDialog_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
28140          { (char *)"FileDialog_GetPaths", (PyCFunction) _wrap_FileDialog_GetPaths, METH_VARARGS | METH_KEYWORDS, NULL},
28141          { (char *)"FileDialog_swigregister", FileDialog_swigregister, METH_VARARGS, NULL},
28142          { (char *)"new_MultiChoiceDialog", (PyCFunction) _wrap_new_MultiChoiceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28143          { (char *)"MultiChoiceDialog_SetSelections", (PyCFunction) _wrap_MultiChoiceDialog_SetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
28144          { (char *)"MultiChoiceDialog_GetSelections", (PyCFunction) _wrap_MultiChoiceDialog_GetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
28145          { (char *)"MultiChoiceDialog_swigregister", MultiChoiceDialog_swigregister, METH_VARARGS, NULL},
28146          { (char *)"new_SingleChoiceDialog", (PyCFunction) _wrap_new_SingleChoiceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28147          { (char *)"SingleChoiceDialog_GetSelection", (PyCFunction) _wrap_SingleChoiceDialog_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28148          { (char *)"SingleChoiceDialog_GetStringSelection", (PyCFunction) _wrap_SingleChoiceDialog_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28149          { (char *)"SingleChoiceDialog_SetSelection", (PyCFunction) _wrap_SingleChoiceDialog_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28150          { (char *)"SingleChoiceDialog_swigregister", SingleChoiceDialog_swigregister, METH_VARARGS, NULL},
28151          { (char *)"new_TextEntryDialog", (PyCFunction) _wrap_new_TextEntryDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28152          { (char *)"TextEntryDialog_GetValue", (PyCFunction) _wrap_TextEntryDialog_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
28153          { (char *)"TextEntryDialog_SetValue", (PyCFunction) _wrap_TextEntryDialog_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
28154          { (char *)"TextEntryDialog_swigregister", TextEntryDialog_swigregister, METH_VARARGS, NULL},
28155          { (char *)"new_PasswordEntryDialog", (PyCFunction) _wrap_new_PasswordEntryDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28156          { (char *)"PasswordEntryDialog_swigregister", PasswordEntryDialog_swigregister, METH_VARARGS, NULL},
28157          { (char *)"new_FontData", (PyCFunction) _wrap_new_FontData, METH_VARARGS | METH_KEYWORDS, NULL},
28158          { (char *)"delete_FontData", (PyCFunction) _wrap_delete_FontData, METH_VARARGS | METH_KEYWORDS, NULL},
28159          { (char *)"FontData_EnableEffects", (PyCFunction) _wrap_FontData_EnableEffects, METH_VARARGS | METH_KEYWORDS, NULL},
28160          { (char *)"FontData_GetAllowSymbols", (PyCFunction) _wrap_FontData_GetAllowSymbols, METH_VARARGS | METH_KEYWORDS, NULL},
28161          { (char *)"FontData_GetColour", (PyCFunction) _wrap_FontData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28162          { (char *)"FontData_GetChosenFont", (PyCFunction) _wrap_FontData_GetChosenFont, METH_VARARGS | METH_KEYWORDS, NULL},
28163          { (char *)"FontData_GetEnableEffects", (PyCFunction) _wrap_FontData_GetEnableEffects, METH_VARARGS | METH_KEYWORDS, NULL},
28164          { (char *)"FontData_GetInitialFont", (PyCFunction) _wrap_FontData_GetInitialFont, METH_VARARGS | METH_KEYWORDS, NULL},
28165          { (char *)"FontData_GetShowHelp", (PyCFunction) _wrap_FontData_GetShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28166          { (char *)"FontData_SetAllowSymbols", (PyCFunction) _wrap_FontData_SetAllowSymbols, METH_VARARGS | METH_KEYWORDS, NULL},
28167          { (char *)"FontData_SetChosenFont", (PyCFunction) _wrap_FontData_SetChosenFont, METH_VARARGS | METH_KEYWORDS, NULL},
28168          { (char *)"FontData_SetColour", (PyCFunction) _wrap_FontData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28169          { (char *)"FontData_SetInitialFont", (PyCFunction) _wrap_FontData_SetInitialFont, METH_VARARGS | METH_KEYWORDS, NULL},
28170          { (char *)"FontData_SetRange", (PyCFunction) _wrap_FontData_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
28171          { (char *)"FontData_SetShowHelp", (PyCFunction) _wrap_FontData_SetShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28172          { (char *)"FontData_swigregister", FontData_swigregister, METH_VARARGS, NULL},
28173          { (char *)"new_FontDialog", (PyCFunction) _wrap_new_FontDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28174          { (char *)"FontDialog_GetFontData", (PyCFunction) _wrap_FontDialog_GetFontData, METH_VARARGS | METH_KEYWORDS, NULL},
28175          { (char *)"FontDialog_swigregister", FontDialog_swigregister, METH_VARARGS, NULL},
28176          { (char *)"new_MessageDialog", (PyCFunction) _wrap_new_MessageDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28177          { (char *)"MessageDialog_swigregister", MessageDialog_swigregister, METH_VARARGS, NULL},
28178          { (char *)"new_ProgressDialog", (PyCFunction) _wrap_new_ProgressDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28179          { (char *)"ProgressDialog_Update", (PyCFunction) _wrap_ProgressDialog_Update, METH_VARARGS | METH_KEYWORDS, NULL},
28180          { (char *)"ProgressDialog_Resume", (PyCFunction) _wrap_ProgressDialog_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
28181          { (char *)"ProgressDialog_swigregister", ProgressDialog_swigregister, METH_VARARGS, NULL},
28182          { (char *)"new_FindDialogEvent", (PyCFunction) _wrap_new_FindDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
28183          { (char *)"FindDialogEvent_GetFlags", (PyCFunction) _wrap_FindDialogEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28184          { (char *)"FindDialogEvent_GetFindString", (PyCFunction) _wrap_FindDialogEvent_GetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28185          { (char *)"FindDialogEvent_GetReplaceString", (PyCFunction) _wrap_FindDialogEvent_GetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28186          { (char *)"FindDialogEvent_GetDialog", (PyCFunction) _wrap_FindDialogEvent_GetDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28187          { (char *)"FindDialogEvent_SetFlags", (PyCFunction) _wrap_FindDialogEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28188          { (char *)"FindDialogEvent_SetFindString", (PyCFunction) _wrap_FindDialogEvent_SetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28189          { (char *)"FindDialogEvent_SetReplaceString", (PyCFunction) _wrap_FindDialogEvent_SetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28190          { (char *)"FindDialogEvent_swigregister", FindDialogEvent_swigregister, METH_VARARGS, NULL},
28191          { (char *)"new_FindReplaceData", (PyCFunction) _wrap_new_FindReplaceData, METH_VARARGS | METH_KEYWORDS, NULL},
28192          { (char *)"delete_FindReplaceData", (PyCFunction) _wrap_delete_FindReplaceData, METH_VARARGS | METH_KEYWORDS, NULL},
28193          { (char *)"FindReplaceData_GetFindString", (PyCFunction) _wrap_FindReplaceData_GetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28194          { (char *)"FindReplaceData_GetReplaceString", (PyCFunction) _wrap_FindReplaceData_GetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28195          { (char *)"FindReplaceData_GetFlags", (PyCFunction) _wrap_FindReplaceData_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28196          { (char *)"FindReplaceData_SetFlags", (PyCFunction) _wrap_FindReplaceData_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28197          { (char *)"FindReplaceData_SetFindString", (PyCFunction) _wrap_FindReplaceData_SetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28198          { (char *)"FindReplaceData_SetReplaceString", (PyCFunction) _wrap_FindReplaceData_SetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28199          { (char *)"FindReplaceData_swigregister", FindReplaceData_swigregister, METH_VARARGS, NULL},
28200          { (char *)"new_FindReplaceDialog", (PyCFunction) _wrap_new_FindReplaceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28201          { (char *)"new_PreFindReplaceDialog", (PyCFunction) _wrap_new_PreFindReplaceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28202          { (char *)"FindReplaceDialog_Create", (PyCFunction) _wrap_FindReplaceDialog_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28203          { (char *)"FindReplaceDialog_GetData", (PyCFunction) _wrap_FindReplaceDialog_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
28204          { (char *)"FindReplaceDialog_SetData", (PyCFunction) _wrap_FindReplaceDialog_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
28205          { (char *)"FindReplaceDialog_swigregister", FindReplaceDialog_swigregister, METH_VARARGS, NULL},
28206          { (char *)"new_MDIParentFrame", (PyCFunction) _wrap_new_MDIParentFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28207          { (char *)"new_PreMDIParentFrame", (PyCFunction) _wrap_new_PreMDIParentFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28208          { (char *)"MDIParentFrame_Create", (PyCFunction) _wrap_MDIParentFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28209          { (char *)"MDIParentFrame_ActivateNext", (PyCFunction) _wrap_MDIParentFrame_ActivateNext, METH_VARARGS | METH_KEYWORDS, NULL},
28210          { (char *)"MDIParentFrame_ActivatePrevious", (PyCFunction) _wrap_MDIParentFrame_ActivatePrevious, METH_VARARGS | METH_KEYWORDS, NULL},
28211          { (char *)"MDIParentFrame_ArrangeIcons", (PyCFunction) _wrap_MDIParentFrame_ArrangeIcons, METH_VARARGS | METH_KEYWORDS, NULL},
28212          { (char *)"MDIParentFrame_Cascade", (PyCFunction) _wrap_MDIParentFrame_Cascade, METH_VARARGS | METH_KEYWORDS, NULL},
28213          { (char *)"MDIParentFrame_GetActiveChild", (PyCFunction) _wrap_MDIParentFrame_GetActiveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28214          { (char *)"MDIParentFrame_GetClientWindow", (PyCFunction) _wrap_MDIParentFrame_GetClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28215          { (char *)"MDIParentFrame_GetToolBar", (PyCFunction) _wrap_MDIParentFrame_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
28216          { (char *)"MDIParentFrame_GetWindowMenu", (PyCFunction) _wrap_MDIParentFrame_GetWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
28217          { (char *)"MDIParentFrame_SetWindowMenu", (PyCFunction) _wrap_MDIParentFrame_SetWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
28218          { (char *)"MDIParentFrame_SetToolBar", (PyCFunction) _wrap_MDIParentFrame_SetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
28219          { (char *)"MDIParentFrame_Tile", (PyCFunction) _wrap_MDIParentFrame_Tile, METH_VARARGS | METH_KEYWORDS, NULL},
28220          { (char *)"MDIParentFrame_swigregister", MDIParentFrame_swigregister, METH_VARARGS, NULL},
28221          { (char *)"new_MDIChildFrame", (PyCFunction) _wrap_new_MDIChildFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28222          { (char *)"new_PreMDIChildFrame", (PyCFunction) _wrap_new_PreMDIChildFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28223          { (char *)"MDIChildFrame_Create", (PyCFunction) _wrap_MDIChildFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28224          { (char *)"MDIChildFrame_Activate", (PyCFunction) _wrap_MDIChildFrame_Activate, METH_VARARGS | METH_KEYWORDS, NULL},
28225          { (char *)"MDIChildFrame_Maximize", (PyCFunction) _wrap_MDIChildFrame_Maximize, METH_VARARGS | METH_KEYWORDS, NULL},
28226          { (char *)"MDIChildFrame_Restore", (PyCFunction) _wrap_MDIChildFrame_Restore, METH_VARARGS | METH_KEYWORDS, NULL},
28227          { (char *)"MDIChildFrame_swigregister", MDIChildFrame_swigregister, METH_VARARGS, NULL},
28228          { (char *)"new_MDIClientWindow", (PyCFunction) _wrap_new_MDIClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28229          { (char *)"new_PreMDIClientWindow", (PyCFunction) _wrap_new_PreMDIClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28230          { (char *)"MDIClientWindow_Create", (PyCFunction) _wrap_MDIClientWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28231          { (char *)"MDIClientWindow_swigregister", MDIClientWindow_swigregister, METH_VARARGS, NULL},
28232          { (char *)"new_PyWindow", (PyCFunction) _wrap_new_PyWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28233          { (char *)"new_PrePyWindow", (PyCFunction) _wrap_new_PrePyWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28234          { (char *)"PyWindow__setCallbackInfo", (PyCFunction) _wrap_PyWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28235          { (char *)"PyWindow_SetBestSize", (PyCFunction) _wrap_PyWindow_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28236          { (char *)"PyWindow_base_DoMoveWindow", (PyCFunction) _wrap_PyWindow_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28237          { (char *)"PyWindow_base_DoSetSize", (PyCFunction) _wrap_PyWindow_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28238          { (char *)"PyWindow_base_DoSetClientSize", (PyCFunction) _wrap_PyWindow_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28239          { (char *)"PyWindow_base_DoSetVirtualSize", (PyCFunction) _wrap_PyWindow_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28240          { (char *)"PyWindow_base_DoGetSize", (PyCFunction) _wrap_PyWindow_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28241          { (char *)"PyWindow_base_DoGetClientSize", (PyCFunction) _wrap_PyWindow_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28242          { (char *)"PyWindow_base_DoGetPosition", (PyCFunction) _wrap_PyWindow_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28243          { (char *)"PyWindow_base_DoGetVirtualSize", (PyCFunction) _wrap_PyWindow_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28244          { (char *)"PyWindow_base_DoGetBestSize", (PyCFunction) _wrap_PyWindow_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28245          { (char *)"PyWindow_base_InitDialog", (PyCFunction) _wrap_PyWindow_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28246          { (char *)"PyWindow_base_TransferDataToWindow", (PyCFunction) _wrap_PyWindow_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28247          { (char *)"PyWindow_base_TransferDataFromWindow", (PyCFunction) _wrap_PyWindow_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28248          { (char *)"PyWindow_base_Validate", (PyCFunction) _wrap_PyWindow_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28249          { (char *)"PyWindow_base_AcceptsFocus", (PyCFunction) _wrap_PyWindow_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28250          { (char *)"PyWindow_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyWindow_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28251          { (char *)"PyWindow_base_GetMaxSize", (PyCFunction) _wrap_PyWindow_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28252          { (char *)"PyWindow_base_AddChild", (PyCFunction) _wrap_PyWindow_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28253          { (char *)"PyWindow_base_RemoveChild", (PyCFunction) _wrap_PyWindow_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28254          { (char *)"PyWindow_base_ShouldInheritColours", (PyCFunction) _wrap_PyWindow_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28255          { (char *)"PyWindow_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyWindow_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28256          { (char *)"PyWindow_base_GetDefaultAttributes", (PyCFunction) _wrap_PyWindow_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28257          { (char *)"PyWindow_swigregister", PyWindow_swigregister, METH_VARARGS, NULL},
28258          { (char *)"new_PyPanel", (PyCFunction) _wrap_new_PyPanel, METH_VARARGS | METH_KEYWORDS, NULL},
28259          { (char *)"new_PrePyPanel", (PyCFunction) _wrap_new_PrePyPanel, METH_VARARGS | METH_KEYWORDS, NULL},
28260          { (char *)"PyPanel__setCallbackInfo", (PyCFunction) _wrap_PyPanel__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28261          { (char *)"PyPanel_SetBestSize", (PyCFunction) _wrap_PyPanel_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28262          { (char *)"PyPanel_base_DoMoveWindow", (PyCFunction) _wrap_PyPanel_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28263          { (char *)"PyPanel_base_DoSetSize", (PyCFunction) _wrap_PyPanel_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28264          { (char *)"PyPanel_base_DoSetClientSize", (PyCFunction) _wrap_PyPanel_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28265          { (char *)"PyPanel_base_DoSetVirtualSize", (PyCFunction) _wrap_PyPanel_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28266          { (char *)"PyPanel_base_DoGetSize", (PyCFunction) _wrap_PyPanel_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28267          { (char *)"PyPanel_base_DoGetClientSize", (PyCFunction) _wrap_PyPanel_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28268          { (char *)"PyPanel_base_DoGetPosition", (PyCFunction) _wrap_PyPanel_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28269          { (char *)"PyPanel_base_DoGetVirtualSize", (PyCFunction) _wrap_PyPanel_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28270          { (char *)"PyPanel_base_DoGetBestSize", (PyCFunction) _wrap_PyPanel_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28271          { (char *)"PyPanel_base_InitDialog", (PyCFunction) _wrap_PyPanel_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28272          { (char *)"PyPanel_base_TransferDataToWindow", (PyCFunction) _wrap_PyPanel_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28273          { (char *)"PyPanel_base_TransferDataFromWindow", (PyCFunction) _wrap_PyPanel_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28274          { (char *)"PyPanel_base_Validate", (PyCFunction) _wrap_PyPanel_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28275          { (char *)"PyPanel_base_AcceptsFocus", (PyCFunction) _wrap_PyPanel_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28276          { (char *)"PyPanel_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyPanel_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28277          { (char *)"PyPanel_base_GetMaxSize", (PyCFunction) _wrap_PyPanel_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28278          { (char *)"PyPanel_base_AddChild", (PyCFunction) _wrap_PyPanel_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28279          { (char *)"PyPanel_base_RemoveChild", (PyCFunction) _wrap_PyPanel_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28280          { (char *)"PyPanel_base_ShouldInheritColours", (PyCFunction) _wrap_PyPanel_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28281          { (char *)"PyPanel_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyPanel_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28282          { (char *)"PyPanel_base_GetDefaultAttributes", (PyCFunction) _wrap_PyPanel_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28283          { (char *)"PyPanel_swigregister", PyPanel_swigregister, METH_VARARGS, NULL},
28284          { (char *)"new_PyScrolledWindow", (PyCFunction) _wrap_new_PyScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28285          { (char *)"new_PrePyScrolledWindow", (PyCFunction) _wrap_new_PrePyScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28286          { (char *)"PyScrolledWindow__setCallbackInfo", (PyCFunction) _wrap_PyScrolledWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28287          { (char *)"PyScrolledWindow_SetBestSize", (PyCFunction) _wrap_PyScrolledWindow_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28288          { (char *)"PyScrolledWindow_base_DoMoveWindow", (PyCFunction) _wrap_PyScrolledWindow_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28289          { (char *)"PyScrolledWindow_base_DoSetSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28290          { (char *)"PyScrolledWindow_base_DoSetClientSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28291          { (char *)"PyScrolledWindow_base_DoSetVirtualSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28292          { (char *)"PyScrolledWindow_base_DoGetSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28293          { (char *)"PyScrolledWindow_base_DoGetClientSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28294          { (char *)"PyScrolledWindow_base_DoGetPosition", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28295          { (char *)"PyScrolledWindow_base_DoGetVirtualSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28296          { (char *)"PyScrolledWindow_base_DoGetBestSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28297          { (char *)"PyScrolledWindow_base_InitDialog", (PyCFunction) _wrap_PyScrolledWindow_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28298          { (char *)"PyScrolledWindow_base_TransferDataToWindow", (PyCFunction) _wrap_PyScrolledWindow_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28299          { (char *)"PyScrolledWindow_base_TransferDataFromWindow", (PyCFunction) _wrap_PyScrolledWindow_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28300          { (char *)"PyScrolledWindow_base_Validate", (PyCFunction) _wrap_PyScrolledWindow_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28301          { (char *)"PyScrolledWindow_base_AcceptsFocus", (PyCFunction) _wrap_PyScrolledWindow_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28302          { (char *)"PyScrolledWindow_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyScrolledWindow_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28303          { (char *)"PyScrolledWindow_base_GetMaxSize", (PyCFunction) _wrap_PyScrolledWindow_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28304          { (char *)"PyScrolledWindow_base_AddChild", (PyCFunction) _wrap_PyScrolledWindow_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28305          { (char *)"PyScrolledWindow_base_RemoveChild", (PyCFunction) _wrap_PyScrolledWindow_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28306          { (char *)"PyScrolledWindow_base_ShouldInheritColours", (PyCFunction) _wrap_PyScrolledWindow_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28307          { (char *)"PyScrolledWindow_base_ApplyParentThemeBackground", (PyCFunction) _wrap_PyScrolledWindow_base_ApplyParentThemeBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28308          { (char *)"PyScrolledWindow_base_GetDefaultAttributes", (PyCFunction) _wrap_PyScrolledWindow_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28309          { (char *)"PyScrolledWindow_swigregister", PyScrolledWindow_swigregister, METH_VARARGS, NULL},
28310          { (char *)"new_PrintData", _wrap_new_PrintData, METH_VARARGS, NULL},
28311          { (char *)"delete_PrintData", (PyCFunction) _wrap_delete_PrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28312          { (char *)"PrintData_GetNoCopies", (PyCFunction) _wrap_PrintData_GetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28313          { (char *)"PrintData_GetCollate", (PyCFunction) _wrap_PrintData_GetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28314          { (char *)"PrintData_GetOrientation", (PyCFunction) _wrap_PrintData_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28315          { (char *)"PrintData_Ok", (PyCFunction) _wrap_PrintData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28316          { (char *)"PrintData_GetPrinterName", (PyCFunction) _wrap_PrintData_GetPrinterName, METH_VARARGS | METH_KEYWORDS, NULL},
28317          { (char *)"PrintData_GetColour", (PyCFunction) _wrap_PrintData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28318          { (char *)"PrintData_GetDuplex", (PyCFunction) _wrap_PrintData_GetDuplex, METH_VARARGS | METH_KEYWORDS, NULL},
28319          { (char *)"PrintData_GetPaperId", (PyCFunction) _wrap_PrintData_GetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28320          { (char *)"PrintData_GetPaperSize", (PyCFunction) _wrap_PrintData_GetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28321          { (char *)"PrintData_GetQuality", (PyCFunction) _wrap_PrintData_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
28322          { (char *)"PrintData_GetBin", (PyCFunction) _wrap_PrintData_GetBin, METH_VARARGS | METH_KEYWORDS, NULL},
28323          { (char *)"PrintData_GetPrintMode", (PyCFunction) _wrap_PrintData_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
28324          { (char *)"PrintData_SetNoCopies", (PyCFunction) _wrap_PrintData_SetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28325          { (char *)"PrintData_SetCollate", (PyCFunction) _wrap_PrintData_SetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28326          { (char *)"PrintData_SetOrientation", (PyCFunction) _wrap_PrintData_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28327          { (char *)"PrintData_SetPrinterName", (PyCFunction) _wrap_PrintData_SetPrinterName, METH_VARARGS | METH_KEYWORDS, NULL},
28328          { (char *)"PrintData_SetColour", (PyCFunction) _wrap_PrintData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28329          { (char *)"PrintData_SetDuplex", (PyCFunction) _wrap_PrintData_SetDuplex, METH_VARARGS | METH_KEYWORDS, NULL},
28330          { (char *)"PrintData_SetPaperId", (PyCFunction) _wrap_PrintData_SetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28331          { (char *)"PrintData_SetPaperSize", (PyCFunction) _wrap_PrintData_SetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28332          { (char *)"PrintData_SetQuality", (PyCFunction) _wrap_PrintData_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
28333          { (char *)"PrintData_SetBin", (PyCFunction) _wrap_PrintData_SetBin, METH_VARARGS | METH_KEYWORDS, NULL},
28334          { (char *)"PrintData_SetPrintMode", (PyCFunction) _wrap_PrintData_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
28335          { (char *)"PrintData_GetFilename", (PyCFunction) _wrap_PrintData_GetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28336          { (char *)"PrintData_SetFilename", (PyCFunction) _wrap_PrintData_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28337          { (char *)"PrintData_GetPrivData", (PyCFunction) _wrap_PrintData_GetPrivData, METH_VARARGS | METH_KEYWORDS, NULL},
28338          { (char *)"PrintData_SetPrivData", (PyCFunction) _wrap_PrintData_SetPrivData, METH_VARARGS | METH_KEYWORDS, NULL},
28339          { (char *)"PrintData_GetPrinterCommand", (PyCFunction) _wrap_PrintData_GetPrinterCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28340          { (char *)"PrintData_GetPrinterOptions", (PyCFunction) _wrap_PrintData_GetPrinterOptions, METH_VARARGS | METH_KEYWORDS, NULL},
28341          { (char *)"PrintData_GetPreviewCommand", (PyCFunction) _wrap_PrintData_GetPreviewCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28342          { (char *)"PrintData_GetFontMetricPath", (PyCFunction) _wrap_PrintData_GetFontMetricPath, METH_VARARGS | METH_KEYWORDS, NULL},
28343          { (char *)"PrintData_GetPrinterScaleX", (PyCFunction) _wrap_PrintData_GetPrinterScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
28344          { (char *)"PrintData_GetPrinterScaleY", (PyCFunction) _wrap_PrintData_GetPrinterScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
28345          { (char *)"PrintData_GetPrinterTranslateX", (PyCFunction) _wrap_PrintData_GetPrinterTranslateX, METH_VARARGS | METH_KEYWORDS, NULL},
28346          { (char *)"PrintData_GetPrinterTranslateY", (PyCFunction) _wrap_PrintData_GetPrinterTranslateY, METH_VARARGS | METH_KEYWORDS, NULL},
28347          { (char *)"PrintData_SetPrinterCommand", (PyCFunction) _wrap_PrintData_SetPrinterCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28348          { (char *)"PrintData_SetPrinterOptions", (PyCFunction) _wrap_PrintData_SetPrinterOptions, METH_VARARGS | METH_KEYWORDS, NULL},
28349          { (char *)"PrintData_SetPreviewCommand", (PyCFunction) _wrap_PrintData_SetPreviewCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28350          { (char *)"PrintData_SetFontMetricPath", (PyCFunction) _wrap_PrintData_SetFontMetricPath, METH_VARARGS | METH_KEYWORDS, NULL},
28351          { (char *)"PrintData_SetPrinterScaleX", (PyCFunction) _wrap_PrintData_SetPrinterScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
28352          { (char *)"PrintData_SetPrinterScaleY", (PyCFunction) _wrap_PrintData_SetPrinterScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
28353          { (char *)"PrintData_SetPrinterScaling", (PyCFunction) _wrap_PrintData_SetPrinterScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28354          { (char *)"PrintData_SetPrinterTranslateX", (PyCFunction) _wrap_PrintData_SetPrinterTranslateX, METH_VARARGS | METH_KEYWORDS, NULL},
28355          { (char *)"PrintData_SetPrinterTranslateY", (PyCFunction) _wrap_PrintData_SetPrinterTranslateY, METH_VARARGS | METH_KEYWORDS, NULL},
28356          { (char *)"PrintData_SetPrinterTranslation", (PyCFunction) _wrap_PrintData_SetPrinterTranslation, METH_VARARGS | METH_KEYWORDS, NULL},
28357          { (char *)"PrintData_swigregister", PrintData_swigregister, METH_VARARGS, NULL},
28358          { (char *)"new_PageSetupDialogData", _wrap_new_PageSetupDialogData, METH_VARARGS, NULL},
28359          { (char *)"delete_PageSetupDialogData", (PyCFunction) _wrap_delete_PageSetupDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28360          { (char *)"PageSetupDialogData_EnableHelp", (PyCFunction) _wrap_PageSetupDialogData_EnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28361          { (char *)"PageSetupDialogData_EnableMargins", (PyCFunction) _wrap_PageSetupDialogData_EnableMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28362          { (char *)"PageSetupDialogData_EnableOrientation", (PyCFunction) _wrap_PageSetupDialogData_EnableOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28363          { (char *)"PageSetupDialogData_EnablePaper", (PyCFunction) _wrap_PageSetupDialogData_EnablePaper, METH_VARARGS | METH_KEYWORDS, NULL},
28364          { (char *)"PageSetupDialogData_EnablePrinter", (PyCFunction) _wrap_PageSetupDialogData_EnablePrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28365          { (char *)"PageSetupDialogData_GetDefaultMinMargins", (PyCFunction) _wrap_PageSetupDialogData_GetDefaultMinMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28366          { (char *)"PageSetupDialogData_GetEnableMargins", (PyCFunction) _wrap_PageSetupDialogData_GetEnableMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28367          { (char *)"PageSetupDialogData_GetEnableOrientation", (PyCFunction) _wrap_PageSetupDialogData_GetEnableOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28368          { (char *)"PageSetupDialogData_GetEnablePaper", (PyCFunction) _wrap_PageSetupDialogData_GetEnablePaper, METH_VARARGS | METH_KEYWORDS, NULL},
28369          { (char *)"PageSetupDialogData_GetEnablePrinter", (PyCFunction) _wrap_PageSetupDialogData_GetEnablePrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28370          { (char *)"PageSetupDialogData_GetEnableHelp", (PyCFunction) _wrap_PageSetupDialogData_GetEnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28371          { (char *)"PageSetupDialogData_GetDefaultInfo", (PyCFunction) _wrap_PageSetupDialogData_GetDefaultInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28372          { (char *)"PageSetupDialogData_GetMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_GetMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28373          { (char *)"PageSetupDialogData_GetMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_GetMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28374          { (char *)"PageSetupDialogData_GetMinMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_GetMinMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28375          { (char *)"PageSetupDialogData_GetMinMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_GetMinMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28376          { (char *)"PageSetupDialogData_GetPaperId", (PyCFunction) _wrap_PageSetupDialogData_GetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28377          { (char *)"PageSetupDialogData_GetPaperSize", (PyCFunction) _wrap_PageSetupDialogData_GetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28378          { (char *)"PageSetupDialogData_GetPrintData", (PyCFunction) _wrap_PageSetupDialogData_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28379          { (char *)"PageSetupDialogData_Ok", (PyCFunction) _wrap_PageSetupDialogData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28380          { (char *)"PageSetupDialogData_SetDefaultInfo", (PyCFunction) _wrap_PageSetupDialogData_SetDefaultInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28381          { (char *)"PageSetupDialogData_SetDefaultMinMargins", (PyCFunction) _wrap_PageSetupDialogData_SetDefaultMinMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28382          { (char *)"PageSetupDialogData_SetMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_SetMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28383          { (char *)"PageSetupDialogData_SetMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_SetMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28384          { (char *)"PageSetupDialogData_SetMinMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_SetMinMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28385          { (char *)"PageSetupDialogData_SetMinMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_SetMinMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28386          { (char *)"PageSetupDialogData_SetPaperId", (PyCFunction) _wrap_PageSetupDialogData_SetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28387          { (char *)"PageSetupDialogData_SetPaperSize", (PyCFunction) _wrap_PageSetupDialogData_SetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28388          { (char *)"PageSetupDialogData_SetPrintData", (PyCFunction) _wrap_PageSetupDialogData_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28389          { (char *)"PageSetupDialogData_CalculateIdFromPaperSize", (PyCFunction) _wrap_PageSetupDialogData_CalculateIdFromPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28390          { (char *)"PageSetupDialogData_CalculatePaperSizeFromId", (PyCFunction) _wrap_PageSetupDialogData_CalculatePaperSizeFromId, METH_VARARGS | METH_KEYWORDS, NULL},
28391          { (char *)"PageSetupDialogData_swigregister", PageSetupDialogData_swigregister, METH_VARARGS, NULL},
28392          { (char *)"new_PageSetupDialog", (PyCFunction) _wrap_new_PageSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28393          { (char *)"PageSetupDialog_GetPageSetupData", (PyCFunction) _wrap_PageSetupDialog_GetPageSetupData, METH_VARARGS | METH_KEYWORDS, NULL},
28394          { (char *)"PageSetupDialog_GetPageSetupDialogData", (PyCFunction) _wrap_PageSetupDialog_GetPageSetupDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28395          { (char *)"PageSetupDialog_ShowModal", (PyCFunction) _wrap_PageSetupDialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
28396          { (char *)"PageSetupDialog_swigregister", PageSetupDialog_swigregister, METH_VARARGS, NULL},
28397          { (char *)"new_PrintDialogData", _wrap_new_PrintDialogData, METH_VARARGS, NULL},
28398          { (char *)"delete_PrintDialogData", (PyCFunction) _wrap_delete_PrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28399          { (char *)"PrintDialogData_GetFromPage", (PyCFunction) _wrap_PrintDialogData_GetFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
28400          { (char *)"PrintDialogData_GetToPage", (PyCFunction) _wrap_PrintDialogData_GetToPage, METH_VARARGS | METH_KEYWORDS, NULL},
28401          { (char *)"PrintDialogData_GetMinPage", (PyCFunction) _wrap_PrintDialogData_GetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28402          { (char *)"PrintDialogData_GetMaxPage", (PyCFunction) _wrap_PrintDialogData_GetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28403          { (char *)"PrintDialogData_GetNoCopies", (PyCFunction) _wrap_PrintDialogData_GetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28404          { (char *)"PrintDialogData_GetAllPages", (PyCFunction) _wrap_PrintDialogData_GetAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
28405          { (char *)"PrintDialogData_GetSelection", (PyCFunction) _wrap_PrintDialogData_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28406          { (char *)"PrintDialogData_GetCollate", (PyCFunction) _wrap_PrintDialogData_GetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28407          { (char *)"PrintDialogData_GetPrintToFile", (PyCFunction) _wrap_PrintDialogData_GetPrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28408          { (char *)"PrintDialogData_GetSetupDialog", (PyCFunction) _wrap_PrintDialogData_GetSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28409          { (char *)"PrintDialogData_SetSetupDialog", (PyCFunction) _wrap_PrintDialogData_SetSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28410          { (char *)"PrintDialogData_SetFromPage", (PyCFunction) _wrap_PrintDialogData_SetFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
28411          { (char *)"PrintDialogData_SetToPage", (PyCFunction) _wrap_PrintDialogData_SetToPage, METH_VARARGS | METH_KEYWORDS, NULL},
28412          { (char *)"PrintDialogData_SetMinPage", (PyCFunction) _wrap_PrintDialogData_SetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28413          { (char *)"PrintDialogData_SetMaxPage", (PyCFunction) _wrap_PrintDialogData_SetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28414          { (char *)"PrintDialogData_SetNoCopies", (PyCFunction) _wrap_PrintDialogData_SetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28415          { (char *)"PrintDialogData_SetAllPages", (PyCFunction) _wrap_PrintDialogData_SetAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
28416          { (char *)"PrintDialogData_SetSelection", (PyCFunction) _wrap_PrintDialogData_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28417          { (char *)"PrintDialogData_SetCollate", (PyCFunction) _wrap_PrintDialogData_SetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28418          { (char *)"PrintDialogData_SetPrintToFile", (PyCFunction) _wrap_PrintDialogData_SetPrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28419          { (char *)"PrintDialogData_EnablePrintToFile", (PyCFunction) _wrap_PrintDialogData_EnablePrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28420          { (char *)"PrintDialogData_EnableSelection", (PyCFunction) _wrap_PrintDialogData_EnableSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28421          { (char *)"PrintDialogData_EnablePageNumbers", (PyCFunction) _wrap_PrintDialogData_EnablePageNumbers, METH_VARARGS | METH_KEYWORDS, NULL},
28422          { (char *)"PrintDialogData_EnableHelp", (PyCFunction) _wrap_PrintDialogData_EnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28423          { (char *)"PrintDialogData_GetEnablePrintToFile", (PyCFunction) _wrap_PrintDialogData_GetEnablePrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28424          { (char *)"PrintDialogData_GetEnableSelection", (PyCFunction) _wrap_PrintDialogData_GetEnableSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28425          { (char *)"PrintDialogData_GetEnablePageNumbers", (PyCFunction) _wrap_PrintDialogData_GetEnablePageNumbers, METH_VARARGS | METH_KEYWORDS, NULL},
28426          { (char *)"PrintDialogData_GetEnableHelp", (PyCFunction) _wrap_PrintDialogData_GetEnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28427          { (char *)"PrintDialogData_Ok", (PyCFunction) _wrap_PrintDialogData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28428          { (char *)"PrintDialogData_GetPrintData", (PyCFunction) _wrap_PrintDialogData_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28429          { (char *)"PrintDialogData_SetPrintData", (PyCFunction) _wrap_PrintDialogData_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28430          { (char *)"PrintDialogData_swigregister", PrintDialogData_swigregister, METH_VARARGS, NULL},
28431          { (char *)"new_PrintDialog", (PyCFunction) _wrap_new_PrintDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28432          { (char *)"PrintDialog_ShowModal", (PyCFunction) _wrap_PrintDialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
28433          { (char *)"PrintDialog_GetPrintDialogData", (PyCFunction) _wrap_PrintDialog_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28434          { (char *)"PrintDialog_GetPrintData", (PyCFunction) _wrap_PrintDialog_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28435          { (char *)"PrintDialog_GetPrintDC", (PyCFunction) _wrap_PrintDialog_GetPrintDC, METH_VARARGS | METH_KEYWORDS, NULL},
28436          { (char *)"PrintDialog_swigregister", PrintDialog_swigregister, METH_VARARGS, NULL},
28437          { (char *)"new_Printer", (PyCFunction) _wrap_new_Printer, METH_VARARGS | METH_KEYWORDS, NULL},
28438          { (char *)"delete_Printer", (PyCFunction) _wrap_delete_Printer, METH_VARARGS | METH_KEYWORDS, NULL},
28439          { (char *)"Printer_CreateAbortWindow", (PyCFunction) _wrap_Printer_CreateAbortWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28440          { (char *)"Printer_ReportError", (PyCFunction) _wrap_Printer_ReportError, METH_VARARGS | METH_KEYWORDS, NULL},
28441          { (char *)"Printer_Setup", (PyCFunction) _wrap_Printer_Setup, METH_VARARGS | METH_KEYWORDS, NULL},
28442          { (char *)"Printer_Print", (PyCFunction) _wrap_Printer_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28443          { (char *)"Printer_PrintDialog", (PyCFunction) _wrap_Printer_PrintDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28444          { (char *)"Printer_GetPrintDialogData", (PyCFunction) _wrap_Printer_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28445          { (char *)"Printer_GetAbort", (PyCFunction) _wrap_Printer_GetAbort, METH_VARARGS | METH_KEYWORDS, NULL},
28446          { (char *)"Printer_GetLastError", (PyCFunction) _wrap_Printer_GetLastError, METH_VARARGS | METH_KEYWORDS, NULL},
28447          { (char *)"Printer_swigregister", Printer_swigregister, METH_VARARGS, NULL},
28448          { (char *)"new_Printout", (PyCFunction) _wrap_new_Printout, METH_VARARGS | METH_KEYWORDS, NULL},
28449          { (char *)"Printout__setCallbackInfo", (PyCFunction) _wrap_Printout__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28450          { (char *)"Printout_GetTitle", (PyCFunction) _wrap_Printout_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
28451          { (char *)"Printout_GetDC", (PyCFunction) _wrap_Printout_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
28452          { (char *)"Printout_SetDC", (PyCFunction) _wrap_Printout_SetDC, METH_VARARGS | METH_KEYWORDS, NULL},
28453          { (char *)"Printout_SetPageSizePixels", (PyCFunction) _wrap_Printout_SetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
28454          { (char *)"Printout_GetPageSizePixels", (PyCFunction) _wrap_Printout_GetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
28455          { (char *)"Printout_SetPageSizeMM", (PyCFunction) _wrap_Printout_SetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
28456          { (char *)"Printout_GetPageSizeMM", (PyCFunction) _wrap_Printout_GetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
28457          { (char *)"Printout_SetPPIScreen", (PyCFunction) _wrap_Printout_SetPPIScreen, METH_VARARGS | METH_KEYWORDS, NULL},
28458          { (char *)"Printout_GetPPIScreen", (PyCFunction) _wrap_Printout_GetPPIScreen, METH_VARARGS | METH_KEYWORDS, NULL},
28459          { (char *)"Printout_SetPPIPrinter", (PyCFunction) _wrap_Printout_SetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28460          { (char *)"Printout_GetPPIPrinter", (PyCFunction) _wrap_Printout_GetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28461          { (char *)"Printout_IsPreview", (PyCFunction) _wrap_Printout_IsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28462          { (char *)"Printout_SetIsPreview", (PyCFunction) _wrap_Printout_SetIsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28463          { (char *)"Printout_base_OnBeginDocument", (PyCFunction) _wrap_Printout_base_OnBeginDocument, METH_VARARGS | METH_KEYWORDS, NULL},
28464          { (char *)"Printout_base_OnEndDocument", (PyCFunction) _wrap_Printout_base_OnEndDocument, METH_VARARGS | METH_KEYWORDS, NULL},
28465          { (char *)"Printout_base_OnBeginPrinting", (PyCFunction) _wrap_Printout_base_OnBeginPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28466          { (char *)"Printout_base_OnEndPrinting", (PyCFunction) _wrap_Printout_base_OnEndPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28467          { (char *)"Printout_base_OnPreparePrinting", (PyCFunction) _wrap_Printout_base_OnPreparePrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28468          { (char *)"Printout_base_HasPage", (PyCFunction) _wrap_Printout_base_HasPage, METH_VARARGS | METH_KEYWORDS, NULL},
28469          { (char *)"Printout_base_GetPageInfo", (PyCFunction) _wrap_Printout_base_GetPageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28470          { (char *)"Printout_swigregister", Printout_swigregister, METH_VARARGS, NULL},
28471          { (char *)"new_PreviewCanvas", (PyCFunction) _wrap_new_PreviewCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28472          { (char *)"PreviewCanvas_swigregister", PreviewCanvas_swigregister, METH_VARARGS, NULL},
28473          { (char *)"new_PreviewFrame", (PyCFunction) _wrap_new_PreviewFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28474          { (char *)"PreviewFrame_Initialize", (PyCFunction) _wrap_PreviewFrame_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
28475          { (char *)"PreviewFrame_CreateControlBar", (PyCFunction) _wrap_PreviewFrame_CreateControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28476          { (char *)"PreviewFrame_CreateCanvas", (PyCFunction) _wrap_PreviewFrame_CreateCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28477          { (char *)"PreviewFrame_GetControlBar", (PyCFunction) _wrap_PreviewFrame_GetControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28478          { (char *)"PreviewFrame_swigregister", PreviewFrame_swigregister, METH_VARARGS, NULL},
28479          { (char *)"new_PreviewControlBar", (PyCFunction) _wrap_new_PreviewControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28480          { (char *)"PreviewControlBar_GetZoomControl", (PyCFunction) _wrap_PreviewControlBar_GetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28481          { (char *)"PreviewControlBar_SetZoomControl", (PyCFunction) _wrap_PreviewControlBar_SetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28482          { (char *)"PreviewControlBar_GetPrintPreview", (PyCFunction) _wrap_PreviewControlBar_GetPrintPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28483          { (char *)"PreviewControlBar_OnNext", (PyCFunction) _wrap_PreviewControlBar_OnNext, METH_VARARGS | METH_KEYWORDS, NULL},
28484          { (char *)"PreviewControlBar_OnPrevious", (PyCFunction) _wrap_PreviewControlBar_OnPrevious, METH_VARARGS | METH_KEYWORDS, NULL},
28485          { (char *)"PreviewControlBar_OnFirst", (PyCFunction) _wrap_PreviewControlBar_OnFirst, METH_VARARGS | METH_KEYWORDS, NULL},
28486          { (char *)"PreviewControlBar_OnLast", (PyCFunction) _wrap_PreviewControlBar_OnLast, METH_VARARGS | METH_KEYWORDS, NULL},
28487          { (char *)"PreviewControlBar_OnGoto", (PyCFunction) _wrap_PreviewControlBar_OnGoto, METH_VARARGS | METH_KEYWORDS, NULL},
28488          { (char *)"PreviewControlBar_swigregister", PreviewControlBar_swigregister, METH_VARARGS, NULL},
28489          { (char *)"new_PrintPreview", _wrap_new_PrintPreview, METH_VARARGS, NULL},
28490          { (char *)"PrintPreview_SetCurrentPage", (PyCFunction) _wrap_PrintPreview_SetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28491          { (char *)"PrintPreview_GetCurrentPage", (PyCFunction) _wrap_PrintPreview_GetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28492          { (char *)"PrintPreview_SetPrintout", (PyCFunction) _wrap_PrintPreview_SetPrintout, METH_VARARGS | METH_KEYWORDS, NULL},
28493          { (char *)"PrintPreview_GetPrintout", (PyCFunction) _wrap_PrintPreview_GetPrintout, METH_VARARGS | METH_KEYWORDS, NULL},
28494          { (char *)"PrintPreview_GetPrintoutForPrinting", (PyCFunction) _wrap_PrintPreview_GetPrintoutForPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28495          { (char *)"PrintPreview_SetFrame", (PyCFunction) _wrap_PrintPreview_SetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28496          { (char *)"PrintPreview_SetCanvas", (PyCFunction) _wrap_PrintPreview_SetCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28497          { (char *)"PrintPreview_GetFrame", (PyCFunction) _wrap_PrintPreview_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28498          { (char *)"PrintPreview_GetCanvas", (PyCFunction) _wrap_PrintPreview_GetCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28499          { (char *)"PrintPreview_PaintPage", (PyCFunction) _wrap_PrintPreview_PaintPage, METH_VARARGS | METH_KEYWORDS, NULL},
28500          { (char *)"PrintPreview_DrawBlankPage", (PyCFunction) _wrap_PrintPreview_DrawBlankPage, METH_VARARGS | METH_KEYWORDS, NULL},
28501          { (char *)"PrintPreview_RenderPage", (PyCFunction) _wrap_PrintPreview_RenderPage, METH_VARARGS | METH_KEYWORDS, NULL},
28502          { (char *)"PrintPreview_AdjustScrollbars", (PyCFunction) _wrap_PrintPreview_AdjustScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
28503          { (char *)"PrintPreview_GetPrintDialogData", (PyCFunction) _wrap_PrintPreview_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28504          { (char *)"PrintPreview_SetZoom", (PyCFunction) _wrap_PrintPreview_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28505          { (char *)"PrintPreview_GetZoom", (PyCFunction) _wrap_PrintPreview_GetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28506          { (char *)"PrintPreview_GetMaxPage", (PyCFunction) _wrap_PrintPreview_GetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28507          { (char *)"PrintPreview_GetMinPage", (PyCFunction) _wrap_PrintPreview_GetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28508          { (char *)"PrintPreview_Ok", (PyCFunction) _wrap_PrintPreview_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28509          { (char *)"PrintPreview_SetOk", (PyCFunction) _wrap_PrintPreview_SetOk, METH_VARARGS | METH_KEYWORDS, NULL},
28510          { (char *)"PrintPreview_Print", (PyCFunction) _wrap_PrintPreview_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28511          { (char *)"PrintPreview_DetermineScaling", (PyCFunction) _wrap_PrintPreview_DetermineScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28512          { (char *)"PrintPreview_swigregister", PrintPreview_swigregister, METH_VARARGS, NULL},
28513          { (char *)"new_PyPrintPreview", _wrap_new_PyPrintPreview, METH_VARARGS, NULL},
28514          { (char *)"PyPrintPreview__setCallbackInfo", (PyCFunction) _wrap_PyPrintPreview__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28515          { (char *)"PyPrintPreview_base_SetCurrentPage", (PyCFunction) _wrap_PyPrintPreview_base_SetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28516          { (char *)"PyPrintPreview_base_PaintPage", (PyCFunction) _wrap_PyPrintPreview_base_PaintPage, METH_VARARGS | METH_KEYWORDS, NULL},
28517          { (char *)"PyPrintPreview_base_DrawBlankPage", (PyCFunction) _wrap_PyPrintPreview_base_DrawBlankPage, METH_VARARGS | METH_KEYWORDS, NULL},
28518          { (char *)"PyPrintPreview_base_RenderPage", (PyCFunction) _wrap_PyPrintPreview_base_RenderPage, METH_VARARGS | METH_KEYWORDS, NULL},
28519          { (char *)"PyPrintPreview_base_SetZoom", (PyCFunction) _wrap_PyPrintPreview_base_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28520          { (char *)"PyPrintPreview_base_Print", (PyCFunction) _wrap_PyPrintPreview_base_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28521          { (char *)"PyPrintPreview_base_DetermineScaling", (PyCFunction) _wrap_PyPrintPreview_base_DetermineScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28522          { (char *)"PyPrintPreview_swigregister", PyPrintPreview_swigregister, METH_VARARGS, NULL},
28523          { (char *)"new_PyPreviewFrame", (PyCFunction) _wrap_new_PyPreviewFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28524          { (char *)"PyPreviewFrame__setCallbackInfo", (PyCFunction) _wrap_PyPreviewFrame__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28525          { (char *)"PyPreviewFrame_SetPreviewCanvas", (PyCFunction) _wrap_PyPreviewFrame_SetPreviewCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28526          { (char *)"PyPreviewFrame_SetControlBar", (PyCFunction) _wrap_PyPreviewFrame_SetControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28527          { (char *)"PyPreviewFrame_base_Initialize", (PyCFunction) _wrap_PyPreviewFrame_base_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
28528          { (char *)"PyPreviewFrame_base_CreateCanvas", (PyCFunction) _wrap_PyPreviewFrame_base_CreateCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28529          { (char *)"PyPreviewFrame_base_CreateControlBar", (PyCFunction) _wrap_PyPreviewFrame_base_CreateControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28530          { (char *)"PyPreviewFrame_swigregister", PyPreviewFrame_swigregister, METH_VARARGS, NULL},
28531          { (char *)"new_PyPreviewControlBar", (PyCFunction) _wrap_new_PyPreviewControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28532          { (char *)"PyPreviewControlBar__setCallbackInfo", (PyCFunction) _wrap_PyPreviewControlBar__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28533          { (char *)"PyPreviewControlBar_SetPrintPreview", (PyCFunction) _wrap_PyPreviewControlBar_SetPrintPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28534          { (char *)"PyPreviewControlBar_base_CreateButtons", (PyCFunction) _wrap_PyPreviewControlBar_base_CreateButtons, METH_VARARGS | METH_KEYWORDS, NULL},
28535          { (char *)"PyPreviewControlBar_base_SetZoomControl", (PyCFunction) _wrap_PyPreviewControlBar_base_SetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28536          { (char *)"PyPreviewControlBar_swigregister", PyPreviewControlBar_swigregister, METH_VARARGS, NULL},
28537          { NULL, NULL, 0, NULL }
28538 };
28539
28540
28541 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
28542
28543 static void *_p_wxPyPreviewFrameTo_p_wxPreviewFrame(void *x) {
28544     return (void *)((wxPreviewFrame *)  ((wxPyPreviewFrame *) x));
28545 }
28546 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
28547     return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
28548 }
28549 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
28550     return (void *)((wxEvent *)  ((wxMenuEvent *) x));
28551 }
28552 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
28553     return (void *)((wxEvent *)  ((wxCloseEvent *) x));
28554 }
28555 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
28556     return (void *)((wxEvent *)  ((wxMouseEvent *) x));
28557 }
28558 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
28559     return (void *)((wxEvent *)  ((wxEraseEvent *) x));
28560 }
28561 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
28562     return (void *)((wxEvent *)  ((wxSetCursorEvent *) x));
28563 }
28564 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
28565     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
28566 }
28567 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
28568     return (void *)((wxEvent *)  ((wxInitDialogEvent *) x));
28569 }
28570 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
28571     return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
28572 }
28573 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
28574     return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
28575 }
28576 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
28577     return (void *)((wxEvent *)  ((wxPyEvent *) x));
28578 }
28579 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
28580     return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
28581 }
28582 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
28583     return (void *)((wxEvent *)  ((wxCalculateLayoutEvent *) x));
28584 }
28585 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
28586     return (void *)((wxEvent *)  ((wxIdleEvent *) x));
28587 }
28588 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
28589     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
28590 }
28591 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
28592     return (void *)((wxEvent *)  ((wxQueryNewPaletteEvent *) x));
28593 }
28594 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
28595     return (void *)((wxEvent *)  ((wxMaximizeEvent *) x));
28596 }
28597 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
28598     return (void *)((wxEvent *)  ((wxIconizeEvent *) x));
28599 }
28600 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
28601     return (void *)((wxEvent *)  ((wxActivateEvent *) x));
28602 }
28603 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
28604     return (void *)((wxEvent *)  ((wxSizeEvent *) x));
28605 }
28606 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
28607     return (void *)((wxEvent *)  ((wxMoveEvent *) x));
28608 }
28609 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
28610     return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
28611 }
28612 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
28613     return (void *)((wxEvent *)  ((wxPaintEvent *) x));
28614 }
28615 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
28616     return (void *)((wxEvent *)  ((wxNcPaintEvent *) x));
28617 }
28618 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
28619     return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
28620 }
28621 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
28622     return (void *)((wxEvent *)  ((wxPaletteChangedEvent *) x));
28623 }
28624 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
28625     return (void *)((wxEvent *)  ((wxDisplayChangedEvent *) x));
28626 }
28627 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
28628     return (void *)((wxEvent *)  ((wxMouseCaptureChangedEvent *) x));
28629 }
28630 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
28631     return (void *)((wxEvent *)  ((wxSysColourChangedEvent *) x));
28632 }
28633 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
28634     return (void *)((wxEvent *)  ((wxDropFilesEvent *) x));
28635 }
28636 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
28637     return (void *)((wxEvent *)  ((wxFocusEvent *) x));
28638 }
28639 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
28640     return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
28641 }
28642 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
28643     return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
28644 }
28645 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
28646     return (void *)((wxEvent *)  ((wxQueryLayoutInfoEvent *) x));
28647 }
28648 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
28649     return (void *)((wxEvent *)  ((wxShowEvent *) x));
28650 }
28651 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
28652     return (void *)((wxEvent *)  ((wxCommandEvent *) x));
28653 }
28654 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
28655     return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
28656 }
28657 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
28658     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
28659 }
28660 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
28661     return (void *)((wxEvent *)  ((wxNavigationKeyEvent *) x));
28662 }
28663 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
28664     return (void *)((wxEvent *)  ((wxKeyEvent *) x));
28665 }
28666 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
28667     return (void *)((wxEvent *)  ((wxScrollWinEvent *) x));
28668 }
28669 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
28670     return (void *)((wxEvent *)  ((wxTaskBarIconEvent *) x));
28671 }
28672 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
28673     return (void *)((wxNotifyEvent *)  ((wxSplitterEvent *) x));
28674 }
28675 static void *_p_wxPasswordEntryDialogTo_p_wxTextEntryDialog(void *x) {
28676     return (void *)((wxTextEntryDialog *)  ((wxPasswordEntryDialog *) x));
28677 }
28678 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
28679     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
28680 }
28681 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
28682     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
28683 }
28684 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
28685     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
28686 }
28687 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
28688     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
28689 }
28690 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
28691     return (void *)((wxEvtHandler *)  ((wxValidator *) x));
28692 }
28693 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
28694     return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
28695 }
28696 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
28697     return (void *)((wxEvtHandler *)  ((wxMenu *) x));
28698 }
28699 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
28700     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
28701 }
28702 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
28703     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
28704 }
28705 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
28706     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
28707 }
28708 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
28709     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
28710 }
28711 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
28712     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
28713 }
28714 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
28715     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
28716 }
28717 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
28718     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
28719 }
28720 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
28721     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
28722 }
28723 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
28724     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
28725 }
28726 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
28727     return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
28728 }
28729 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
28730     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
28731 }
28732 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
28733     return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
28734 }
28735 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
28736     return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
28737 }
28738 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
28739     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
28740 }
28741 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
28742     return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
28743 }
28744 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
28745     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
28746 }
28747 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
28748     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
28749 }
28750 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
28751     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
28752 }
28753 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
28754     return (void *)((wxEvtHandler *)  ((wxWindow *) x));
28755 }
28756 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
28757     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
28758 }
28759 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
28760     return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
28761 }
28762 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
28763     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
28764 }
28765 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
28766     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
28767 }
28768 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
28769     return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
28770 }
28771 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
28772     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
28773 }
28774 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
28775     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28776 }
28777 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
28778     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
28779 }
28780 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
28781     return (void *)((wxEvtHandler *)  ((wxPyApp *) x));
28782 }
28783 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
28784     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
28785 }
28786 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
28787     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
28788 }
28789 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
28790     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
28791 }
28792 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
28793     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
28794 }
28795 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
28796     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
28797 }
28798 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
28799     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
28800 }
28801 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
28802     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
28803 }
28804 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
28805     return (void *)((wxEvtHandler *)  ((wxPyTaskBarIcon *) x));
28806 }
28807 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
28808     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
28809 }
28810 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
28811     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
28812 }
28813 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
28814     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
28815 }
28816 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
28817     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
28818 }
28819 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
28820     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
28821 }
28822 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
28823     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
28824 }
28825 static void *_p_wxPyHtmlListBoxTo_p_wxPyVListBox(void *x) {
28826     return (void *)((wxPyVListBox *)  ((wxPyHtmlListBox *) x));
28827 }
28828 static void *_p_wxMDIChildFrameTo_p_wxFrame(void *x) {
28829     return (void *)((wxFrame *)  ((wxMDIChildFrame *) x));
28830 }
28831 static void *_p_wxProgressDialogTo_p_wxFrame(void *x) {
28832     return (void *)((wxFrame *)  ((wxProgressDialog *) x));
28833 }
28834 static void *_p_wxPreviewFrameTo_p_wxFrame(void *x) {
28835     return (void *)((wxFrame *)  ((wxPreviewFrame *) x));
28836 }
28837 static void *_p_wxPyPreviewFrameTo_p_wxFrame(void *x) {
28838     return (void *)((wxFrame *) (wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28839 }
28840 static void *_p_wxMiniFrameTo_p_wxFrame(void *x) {
28841     return (void *)((wxFrame *)  ((wxMiniFrame *) x));
28842 }
28843 static void *_p_wxSplashScreenTo_p_wxFrame(void *x) {
28844     return (void *)((wxFrame *)  ((wxSplashScreen *) x));
28845 }
28846 static void *_p_wxMDIParentFrameTo_p_wxFrame(void *x) {
28847     return (void *)((wxFrame *)  ((wxMDIParentFrame *) x));
28848 }
28849 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
28850     return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
28851 }
28852 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
28853     return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
28854 }
28855 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
28856     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
28857 }
28858 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
28859     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28860 }
28861 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
28862     return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
28863 }
28864 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
28865     return (void *)((wxObject *)  ((wxSizerItem *) x));
28866 }
28867 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
28868     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
28869 }
28870 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
28871     return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
28872 }
28873 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
28874     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
28875 }
28876 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
28877     return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
28878 }
28879 static void *_p_wxSizerTo_p_wxObject(void *x) {
28880     return (void *)((wxObject *)  ((wxSizer *) x));
28881 }
28882 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
28883     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
28884 }
28885 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
28886     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
28887 }
28888 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
28889     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
28890 }
28891 static void *_p_wxEventTo_p_wxObject(void *x) {
28892     return (void *)((wxObject *)  ((wxEvent *) x));
28893 }
28894 static void *_p_wxFontDataTo_p_wxObject(void *x) {
28895     return (void *)((wxObject *)  ((wxFontData *) x));
28896 }
28897 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
28898     return (void *)((wxObject *)  ((wxPrintData *) x));
28899 }
28900 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
28901     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
28902 }
28903 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
28904     return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
28905 }
28906 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
28907     return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
28908 }
28909 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
28910     return (void *)((wxObject *)  ((wxLayoutAlgorithm *) x));
28911 }
28912 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
28913     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
28914 }
28915 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
28916     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
28917 }
28918 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
28919     return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
28920 }
28921 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
28922     return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
28923 }
28924 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
28925     return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
28926 }
28927 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
28928     return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
28929 }
28930 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
28931     return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
28932 }
28933 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
28934     return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
28935 }
28936 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
28937     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
28938 }
28939 static void *_p_wxControlTo_p_wxObject(void *x) {
28940     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
28941 }
28942 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
28943     return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
28944 }
28945 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
28946     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
28947 }
28948 static void *_p_wxFSFileTo_p_wxObject(void *x) {
28949     return (void *)((wxObject *)  ((wxFSFile *) x));
28950 }
28951 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
28952     return (void *)((wxObject *)  ((wxFindReplaceData *) x));
28953 }
28954 static void *_p_wxPySizerTo_p_wxObject(void *x) {
28955     return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
28956 }
28957 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
28958     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
28959 }
28960 static void *_p_wxColourDataTo_p_wxObject(void *x) {
28961     return (void *)((wxObject *)  ((wxColourData *) x));
28962 }
28963 static void *_p_wxPyEventTo_p_wxObject(void *x) {
28964     return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
28965 }
28966 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
28967     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
28968 }
28969 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
28970     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
28971 }
28972 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
28973     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
28974 }
28975 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
28976     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
28977 }
28978 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
28979     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
28980 }
28981 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
28982     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
28983 }
28984 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
28985     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
28986 }
28987 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
28988     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
28989 }
28990 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
28991     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
28992 }
28993 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
28994     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
28995 }
28996 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
28997     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
28998 }
28999 static void *_p_wxShowEventTo_p_wxObject(void *x) {
29000     return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
29001 }
29002 static void *_p_wxPrinterTo_p_wxObject(void *x) {
29003     return (void *)((wxObject *)  ((wxPrinter *) x));
29004 }
29005 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
29006     return (void *)((wxObject *)  ((wxMenuItem *) x));
29007 }
29008 static void *_p_wxDateEventTo_p_wxObject(void *x) {
29009     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
29010 }
29011 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
29012     return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
29013 }
29014 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
29015     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
29016 }
29017 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
29018     return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
29019 }
29020 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
29021     return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
29022 }
29023 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
29024     return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
29025 }
29026 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
29027     return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
29028 }
29029 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
29030     return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
29031 }
29032 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
29033     return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
29034 }
29035 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
29036     return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
29037 }
29038 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
29039     return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
29040 }
29041 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
29042     return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
29043 }
29044 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
29045     return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
29046 }
29047 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
29048     return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
29049 }
29050 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
29051     return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
29052 }
29053 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
29054     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
29055 }
29056 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
29057     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
29058 }
29059 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
29060     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
29061 }
29062 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
29063     return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
29064 }
29065 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
29066     return (void *)((wxObject *)  ((wxImageHandler *) x));
29067 }
29068 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
29069     return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
29070 }
29071 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
29072     return (void *)((wxObject *)  ((wxEvtHandler *) x));
29073 }
29074 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
29075     return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
29076 }
29077 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
29078     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29079 }
29080 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
29081     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29082 }
29083 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
29084     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
29085 }
29086 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
29087     return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
29088 }
29089 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
29090     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
29091 }
29092 static void *_p_wxImageTo_p_wxObject(void *x) {
29093     return (void *)((wxObject *)  ((wxImage *) x));
29094 }
29095 static void *_p_wxFrameTo_p_wxObject(void *x) {
29096     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
29097 }
29098 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
29099     return (void *)((wxObject *)  ((wxPyPrintout *) x));
29100 }
29101 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
29102     return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
29103 }
29104 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
29105     return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
29106 }
29107 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
29108     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
29109 }
29110 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
29111     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
29112 }
29113 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
29114     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
29115 }
29116 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
29117     return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
29118 }
29119 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
29120     return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
29121 }
29122 static void *_p_wxWindowTo_p_wxObject(void *x) {
29123     return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
29124 }
29125 static void *_p_wxMenuTo_p_wxObject(void *x) {
29126     return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
29127 }
29128 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
29129     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
29130 }
29131 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
29132     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
29133 }
29134 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
29135     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
29136 }
29137 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
29138     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
29139 }
29140 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
29141     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
29142 }
29143 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
29144     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
29145 }
29146 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
29147     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
29148 }
29149 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
29150     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
29151 }
29152 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
29153     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
29154 }
29155 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
29156     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29157 }
29158 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
29159     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
29160 }
29161 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
29162     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
29163 }
29164 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
29165     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29166 }
29167 static void *_p_wxSashEventTo_p_wxObject(void *x) {
29168     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
29169 }
29170 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
29171     return (void *)((wxObject *)  ((wxPrintPreview *) x));
29172 }
29173 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
29174     return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
29175 }
29176 static void *_p_wxPanelTo_p_wxObject(void *x) {
29177     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
29178 }
29179 static void *_p_wxDialogTo_p_wxObject(void *x) {
29180     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
29181 }
29182 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
29183     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
29184 }
29185 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
29186     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
29187 }
29188 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
29189     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
29190 }
29191 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
29192     return (void *)((wxObject *)  ((wxPageSetupDialog *) x));
29193 }
29194 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
29195     return (void *)((wxObject *)  ((wxPrintDialog *) x));
29196 }
29197 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
29198     return (void *)((wxObject *)  ((wxFileSystem *) x));
29199 }
29200 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
29201     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
29202 }
29203 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
29204     return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
29205 }
29206 static void *_p_wxPyAppTo_p_wxObject(void *x) {
29207     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
29208 }
29209 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
29210     return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
29211 }
29212 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
29213     return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
29214 }
29215 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
29216     return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
29217 }
29218 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
29219     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
29220 }
29221 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
29222     return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
29223 }
29224 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
29225     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
29226 }
29227 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
29228     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29229 }
29230 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
29231     return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
29232 }
29233 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
29234     return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
29235 }
29236 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
29237     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
29238 }
29239 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
29240     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
29241 }
29242 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
29243     return (void *)((wxObject *)  ((wxPageSetupDialogData *) x));
29244 }
29245 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
29246     return (void *)((wxObject *)  ((wxPrintDialogData *) x));
29247 }
29248 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
29249     return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
29250 }
29251 static void *_p_wxValidatorTo_p_wxObject(void *x) {
29252     return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
29253 }
29254 static void *_p_wxPyVListBoxTo_p_wxPyVScrolledWindow(void *x) {
29255     return (void *)((wxPyVScrolledWindow *)  ((wxPyVListBox *) x));
29256 }
29257 static void *_p_wxPyHtmlListBoxTo_p_wxPyVScrolledWindow(void *x) {
29258     return (void *)((wxPyVScrolledWindow *) (wxPyVListBox *) ((wxPyHtmlListBox *) x));
29259 }
29260 static void *_p_wxTipWindowTo_p_wxPyPopupTransientWindow(void *x) {
29261     return (void *)((wxPyPopupTransientWindow *)  ((wxTipWindow *) x));
29262 }
29263 static void *_p_wxPyPopupTransientWindowTo_p_wxPopupWindow(void *x) {
29264     return (void *)((wxPopupWindow *)  ((wxPyPopupTransientWindow *) x));
29265 }
29266 static void *_p_wxTipWindowTo_p_wxPopupWindow(void *x) {
29267     return (void *)((wxPopupWindow *) (wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29268 }
29269 static void *_p_wxSashLayoutWindowTo_p_wxSashWindow(void *x) {
29270     return (void *)((wxSashWindow *)  ((wxSashLayoutWindow *) x));
29271 }
29272 static void *_p_wxFrameTo_p_wxTopLevelWindow(void *x) {
29273     return (void *)((wxTopLevelWindow *)  ((wxFrame *) x));
29274 }
29275 static void *_p_wxMiniFrameTo_p_wxTopLevelWindow(void *x) {
29276     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMiniFrame *) x));
29277 }
29278 static void *_p_wxFontDialogTo_p_wxTopLevelWindow(void *x) {
29279     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFontDialog *) x));
29280 }
29281 static void *_p_wxDirDialogTo_p_wxTopLevelWindow(void *x) {
29282     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxDirDialog *) x));
29283 }
29284 static void *_p_wxColourDialogTo_p_wxTopLevelWindow(void *x) {
29285     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxColourDialog *) x));
29286 }
29287 static void *_p_wxDialogTo_p_wxTopLevelWindow(void *x) {
29288     return (void *)((wxTopLevelWindow *)  ((wxDialog *) x));
29289 }
29290 static void *_p_wxSplashScreenTo_p_wxTopLevelWindow(void *x) {
29291     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxSplashScreen *) x));
29292 }
29293 static void *_p_wxMDIParentFrameTo_p_wxTopLevelWindow(void *x) {
29294     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIParentFrame *) x));
29295 }
29296 static void *_p_wxMDIChildFrameTo_p_wxTopLevelWindow(void *x) {
29297     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIChildFrame *) x));
29298 }
29299 static void *_p_wxProgressDialogTo_p_wxTopLevelWindow(void *x) {
29300     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxProgressDialog *) x));
29301 }
29302 static void *_p_wxMessageDialogTo_p_wxTopLevelWindow(void *x) {
29303     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMessageDialog *) x));
29304 }
29305 static void *_p_wxPasswordEntryDialogTo_p_wxTopLevelWindow(void *x) {
29306     return (void *)((wxTopLevelWindow *) (wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29307 }
29308 static void *_p_wxTextEntryDialogTo_p_wxTopLevelWindow(void *x) {
29309     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxTextEntryDialog *) x));
29310 }
29311 static void *_p_wxSingleChoiceDialogTo_p_wxTopLevelWindow(void *x) {
29312     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxSingleChoiceDialog *) x));
29313 }
29314 static void *_p_wxMultiChoiceDialogTo_p_wxTopLevelWindow(void *x) {
29315     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMultiChoiceDialog *) x));
29316 }
29317 static void *_p_wxFileDialogTo_p_wxTopLevelWindow(void *x) {
29318     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFileDialog *) x));
29319 }
29320 static void *_p_wxFindReplaceDialogTo_p_wxTopLevelWindow(void *x) {
29321     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFindReplaceDialog *) x));
29322 }
29323 static void *_p_wxPreviewFrameTo_p_wxTopLevelWindow(void *x) {
29324     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxPreviewFrame *) x));
29325 }
29326 static void *_p_wxPyPreviewFrameTo_p_wxTopLevelWindow(void *x) {
29327     return (void *)((wxTopLevelWindow *) (wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
29328 }
29329 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
29330     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
29331 }
29332 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
29333     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
29334 }
29335 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
29336     return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
29337 }
29338 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
29339     return (void *)((wxWindow *)  ((wxMenuBar *) x));
29340 }
29341 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
29342     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
29343 }
29344 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
29345     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
29346 }
29347 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
29348     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
29349 }
29350 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
29351     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29352 }
29353 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
29354     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
29355 }
29356 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
29357     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
29358 }
29359 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
29360     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
29361 }
29362 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
29363     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
29364 }
29365 static void *_p_wxPanelTo_p_wxWindow(void *x) {
29366     return (void *)((wxWindow *)  ((wxPanel *) x));
29367 }
29368 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
29369     return (void *)((wxWindow *)  ((wxStatusBar *) x));
29370 }
29371 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
29372     return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
29373 }
29374 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
29375     return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
29376 }
29377 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
29378     return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
29379 }
29380 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
29381     return (void *)((wxWindow *)  ((wxPopupWindow *) x));
29382 }
29383 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
29384     return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
29385 }
29386 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
29387     return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
29388 }
29389 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
29390     return (void *)((wxWindow *)  ((wxTopLevelWindow *) x));
29391 }
29392 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
29393     return (void *)((wxWindow *)  ((wxSplashScreenWindow *) x));
29394 }
29395 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
29396     return (void *)((wxWindow *)  ((wxSplitterWindow *) x));
29397 }
29398 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
29399     return (void *)((wxWindow *)  ((wxSashWindow *) x));
29400 }
29401 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
29402     return (void *)((wxWindow *)  ((wxMDIClientWindow *) x));
29403 }
29404 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
29405     return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29406 }
29407 static void *_p_wxControlTo_p_wxWindow(void *x) {
29408     return (void *)((wxWindow *)  ((wxControl *) x));
29409 }
29410 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
29411     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
29412 }
29413 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
29414     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
29415 }
29416 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
29417     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
29418 }
29419 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
29420     return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
29421 }
29422 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
29423     return (void *)((wxWindow *)  ((wxPyWindow *) x));
29424 }
29425 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
29426     return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
29427 }
29428 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
29429     return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29430 }
29431 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
29432     return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29433 }
29434 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
29435     return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
29436 }
29437 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
29438     return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29439 }
29440 static void *_p_wxFrameTo_p_wxWindow(void *x) {
29441     return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
29442 }
29443 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
29444     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
29445 }
29446 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
29447     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
29448 }
29449 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
29450     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
29451 }
29452 static void *_p_wxDialogTo_p_wxWindow(void *x) {
29453     return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
29454 }
29455 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
29456     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
29457 }
29458 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
29459     return (void *)((wxScrolledWindow *)  ((wxPyScrolledWindow *) x));
29460 }
29461 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
29462     return (void *)((wxScrolledWindow *)  ((wxPreviewCanvas *) x));
29463 }
29464 static void *_p_wxPyPrintPreviewTo_p_wxPrintPreview(void *x) {
29465     return (void *)((wxPrintPreview *)  ((wxPyPrintPreview *) x));
29466 }
29467 static void *_p_wxColourDialogTo_p_wxDialog(void *x) {
29468     return (void *)((wxDialog *)  ((wxColourDialog *) x));
29469 }
29470 static void *_p_wxDirDialogTo_p_wxDialog(void *x) {
29471     return (void *)((wxDialog *)  ((wxDirDialog *) x));
29472 }
29473 static void *_p_wxFontDialogTo_p_wxDialog(void *x) {
29474     return (void *)((wxDialog *)  ((wxFontDialog *) x));
29475 }
29476 static void *_p_wxFileDialogTo_p_wxDialog(void *x) {
29477     return (void *)((wxDialog *)  ((wxFileDialog *) x));
29478 }
29479 static void *_p_wxMultiChoiceDialogTo_p_wxDialog(void *x) {
29480     return (void *)((wxDialog *)  ((wxMultiChoiceDialog *) x));
29481 }
29482 static void *_p_wxSingleChoiceDialogTo_p_wxDialog(void *x) {
29483     return (void *)((wxDialog *)  ((wxSingleChoiceDialog *) x));
29484 }
29485 static void *_p_wxTextEntryDialogTo_p_wxDialog(void *x) {
29486     return (void *)((wxDialog *)  ((wxTextEntryDialog *) x));
29487 }
29488 static void *_p_wxPasswordEntryDialogTo_p_wxDialog(void *x) {
29489     return (void *)((wxDialog *) (wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29490 }
29491 static void *_p_wxMessageDialogTo_p_wxDialog(void *x) {
29492     return (void *)((wxDialog *)  ((wxMessageDialog *) x));
29493 }
29494 static void *_p_wxFindReplaceDialogTo_p_wxDialog(void *x) {
29495     return (void *)((wxDialog *)  ((wxFindReplaceDialog *) x));
29496 }
29497 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
29498     return (void *)((wxPanel *)  ((wxScrolledWindow *) x));
29499 }
29500 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
29501     return (void *)((wxPanel *)  ((wxPyVScrolledWindow *) x));
29502 }
29503 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
29504     return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29505 }
29506 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
29507     return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29508 }
29509 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
29510     return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29511 }
29512 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
29513     return (void *)((wxPanel *)  ((wxPyPanel *) x));
29514 }
29515 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
29516     return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
29517 }
29518 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
29519     return (void *)((wxPanel *)  ((wxPreviewControlBar *) x));
29520 }
29521 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
29522     return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29523 }
29524 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
29525     return (void *)((wxCommandEvent *)  ((wxChildFocusEvent *) x));
29526 }
29527 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
29528     return (void *)((wxCommandEvent *)  ((wxScrollEvent *) x));
29529 }
29530 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
29531     return (void *)((wxCommandEvent *)  ((wxWindowCreateEvent *) x));
29532 }
29533 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
29534     return (void *)((wxCommandEvent *)  ((wxDateEvent *) x));
29535 }
29536 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
29537     return (void *)((wxCommandEvent *)  ((wxUpdateUIEvent *) x));
29538 }
29539 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
29540     return (void *)((wxCommandEvent *)  ((wxFindDialogEvent *) x));
29541 }
29542 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
29543     return (void *)((wxCommandEvent *)  ((wxWindowDestroyEvent *) x));
29544 }
29545 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
29546     return (void *)((wxCommandEvent *)  ((wxContextMenuEvent *) x));
29547 }
29548 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
29549     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
29550 }
29551 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
29552     return (void *)((wxCommandEvent *)  ((wxNotifyEvent *) x));
29553 }
29554 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
29555     return (void *)((wxCommandEvent *)  ((wxPyCommandEvent *) x));
29556 }
29557 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
29558     return (void *)((wxCommandEvent *)  ((wxSashEvent *) x));
29559 }
29560 static void *_p_wxPyPreviewControlBarTo_p_wxPreviewControlBar(void *x) {
29561     return (void *)((wxPreviewControlBar *)  ((wxPyPreviewControlBar *) x));
29562 }
29563 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}};
29564 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}};
29565 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}};
29566 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}};
29567 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}};
29568 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}};
29569 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}};
29570 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}};
29571 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}};
29572 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}};
29573 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}};
29574 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}};
29575 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}};
29576 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}};
29577 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}};
29578 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}};
29579 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}};
29580 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}};
29581 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}};
29582 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}};
29583 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}};
29584 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}};
29585 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}};
29586 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}};
29587 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}};
29588 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}};
29589 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}};
29590 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}};
29591 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}};
29592 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}};
29593 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}};
29594 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}};
29595 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}};
29596 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}};
29597 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}};
29598 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}};
29599 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}};
29600 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}};
29601 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}};
29602 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}};
29603 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}};
29604 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}};
29605 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}};
29606 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}};
29607 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}};
29608 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}};
29609 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}};
29610 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}};
29611 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}};
29612 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}};
29613 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}};
29614 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}};
29615 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}};
29616 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}};
29617 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}};
29618 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}};
29619 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}};
29620 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}};
29621 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}};
29622 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}};
29623 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}};
29624 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}};
29625 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}};
29626 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}};
29627 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}};
29628 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}};
29629 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}};
29630 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}};
29631 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}};
29632 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}};
29633 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}};
29634 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}};
29635 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}};
29636 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}};
29637 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}};
29638 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}};
29639 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}};
29640 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}};
29641 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}};
29642 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}};
29643 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}};
29644 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}};
29645 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}};
29646 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}};
29647 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}};
29648 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}};
29649 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}};
29650 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}};
29651 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}};
29652 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}};
29653 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}};
29654 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}};
29655 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}};
29656 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}};
29657 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}};
29658 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}};
29659 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}};
29660
29661 static swig_type_info *swig_types_initial[] = {
29662 _swigt__p_wxQueryLayoutInfoEvent,
29663 _swigt__p_wxPreviewFrame,
29664 _swigt__p_wxPyPreviewFrame,
29665 _swigt__p_wxPyPanel,
29666 _swigt__p_wxMenu,
29667 _swigt__p_wxFontData,
29668 _swigt__p_wxEvent,
29669 _swigt__p_wxPrintData,
29670 _swigt__p_wxTaskBarIcon,
29671 _swigt__p_wxPyTaskBarIcon,
29672 _swigt__p_wxIconBundle,
29673 _swigt__p_wxLayoutAlgorithm,
29674 _swigt__p_wxFindDialogEvent,
29675 _swigt__p_wxPreviewCanvas,
29676 _swigt__p_wxFont,
29677 _swigt__p_wxSplitterEvent,
29678 _swigt__p_wxRegion,
29679 _swigt__ptrdiff_t,
29680 _swigt__std__ptrdiff_t,
29681 _swigt__p_wxFindReplaceData,
29682 _swigt__p_int,
29683 _swigt__p_wxSize,
29684 _swigt__p_wxDC,
29685 _swigt__p_wxIcon,
29686 _swigt__p_wxVisualAttributes,
29687 _swigt__p_wxMDIChildFrame,
29688 _swigt__p_wxColourData,
29689 _swigt__p_wxNotifyEvent,
29690 _swigt__p_wxPyWindow,
29691 _swigt__p_form_ops_t,
29692 _swigt__p_wxSplashScreen,
29693 _swigt__p_wxPasswordEntryDialog,
29694 _swigt__p_wxSingleChoiceDialog,
29695 _swigt__p_wxMultiChoiceDialog,
29696 _swigt__p_wxFileDialog,
29697 _swigt__p_wxTextEntryDialog,
29698 _swigt__p_wxMessageDialog,
29699 _swigt__p_wxProgressDialog,
29700 _swigt__p_wxFindReplaceDialog,
29701 _swigt__p_wxPrinter,
29702 _swigt__p_wxArrayInt,
29703 _swigt__p_wxDuplexMode,
29704 _swigt__p_wxEvtHandler,
29705 _swigt__p_wxCalculateLayoutEvent,
29706 _swigt__p_wxPyHtmlListBox,
29707 _swigt__p_wxPyVListBox,
29708 _swigt__p_wxRect,
29709 _swigt__p_wxStdDialogButtonSizer,
29710 _swigt__p_char,
29711 _swigt__p_wxMiniFrame,
29712 _swigt__p_wxFrame,
29713 _swigt__p_wxPyPrintout,
29714 _swigt__p_wxTaskBarIconEvent,
29715 _swigt__p_wxScrollWinEvent,
29716 _swigt__p_wxPaperSize,
29717 _swigt__p_wxStatusBar,
29718 _swigt__p_wxMDIParentFrame,
29719 _swigt__p_wxPoint,
29720 _swigt__p_wxObject,
29721 _swigt__p_unsigned_long,
29722 _swigt__p_wxTipWindow,
29723 _swigt__p_wxSashLayoutWindow,
29724 _swigt__p_wxSplitterWindow,
29725 _swigt__p_wxSplashScreenWindow,
29726 _swigt__p_wxPyVScrolledWindow,
29727 _swigt__p_wxPyPopupTransientWindow,
29728 _swigt__p_wxPopupWindow,
29729 _swigt__p_wxSashWindow,
29730 _swigt__p_wxTopLevelWindow,
29731 _swigt__p_wxWindow,
29732 _swigt__p_wxScrolledWindow,
29733 _swigt__p_wxMenuBar,
29734 _swigt__p_wxMDIClientWindow,
29735 _swigt__p_wxPyScrolledWindow,
29736 _swigt__p_wxPrintPreview,
29737 _swigt__p_wxSashEvent,
29738 _swigt__p_wxString,
29739 _swigt__p_wxPyPrintPreview,
29740 _swigt__p_wxDirDialog,
29741 _swigt__p_wxColourDialog,
29742 _swigt__p_wxDialog,
29743 _swigt__p_wxPanel,
29744 _swigt__p_wxFontDialog,
29745 _swigt__p_wxPageSetupDialog,
29746 _swigt__p_wxPrintDialog,
29747 _swigt__p_wxFileSystem,
29748 _swigt__p_wxBitmap,
29749 _swigt__unsigned_int,
29750 _swigt__p_unsigned_int,
29751 _swigt__p_unsigned_char,
29752 _swigt__p_wxCommandEvent,
29753 _swigt__p_wxPreviewControlBar,
29754 _swigt__p_wxPyPreviewControlBar,
29755 _swigt__p_wxColour,
29756 _swigt__p_wxToolBar,
29757 _swigt__p_wxPageSetupDialogData,
29758 _swigt__p_wxPrintDialogData,
29759 0
29760 };
29761
29762
29763 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
29764
29765 static swig_const_info swig_const_table[] = {
29766 {0, 0, 0, 0.0, 0, 0}};
29767
29768 #ifdef __cplusplus
29769 }
29770 #endif
29771
29772
29773 #ifdef __cplusplus
29774 extern "C" {
29775 #endif
29776
29777     /* Python-specific SWIG API */
29778 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
29779 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
29780 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
29781
29782     /* -----------------------------------------------------------------------------
29783      * global variable support code.
29784      * ----------------------------------------------------------------------------- */
29785
29786     typedef struct swig_globalvar {
29787         char       *name;                  /* Name of global variable */
29788         PyObject *(*get_attr)();           /* Return the current value */
29789         int       (*set_attr)(PyObject *); /* Set the value */
29790         struct swig_globalvar *next;
29791     } swig_globalvar;
29792
29793     typedef struct swig_varlinkobject {
29794         PyObject_HEAD
29795         swig_globalvar *vars;
29796     } swig_varlinkobject;
29797
29798     static PyObject *
29799     swig_varlink_repr(swig_varlinkobject *v) {
29800         v = v;
29801         return PyString_FromString("<Swig global variables>");
29802     }
29803
29804     static int
29805     swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
29806         swig_globalvar  *var;
29807         flags = flags;
29808         fprintf(fp,"Swig global variables { ");
29809         for (var = v->vars; var; var=var->next) {
29810             fprintf(fp,"%s", var->name);
29811             if (var->next) fprintf(fp,", ");
29812         }
29813         fprintf(fp," }\n");
29814         return 0;
29815     }
29816
29817     static PyObject *
29818     swig_varlink_getattr(swig_varlinkobject *v, char *n) {
29819         swig_globalvar *var = v->vars;
29820         while (var) {
29821             if (strcmp(var->name,n) == 0) {
29822                 return (*var->get_attr)();
29823             }
29824             var = var->next;
29825         }
29826         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29827         return NULL;
29828     }
29829
29830     static int
29831     swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
29832         swig_globalvar *var = v->vars;
29833         while (var) {
29834             if (strcmp(var->name,n) == 0) {
29835                 return (*var->set_attr)(p);
29836             }
29837             var = var->next;
29838         }
29839         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29840         return 1;
29841     }
29842
29843     static PyTypeObject varlinktype = {
29844         PyObject_HEAD_INIT(0)
29845         0,                                  /* Number of items in variable part (ob_size) */
29846         (char *)"swigvarlink",              /* Type name (tp_name) */
29847         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
29848         0,                                  /* Itemsize (tp_itemsize) */
29849         0,                                  /* Deallocator (tp_dealloc) */
29850         (printfunc) swig_varlink_print,     /* Print (tp_print) */
29851         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
29852         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
29853         0,                                  /* tp_compare */
29854         (reprfunc) swig_varlink_repr,       /* tp_repr */
29855         0,                                  /* tp_as_number */
29856         0,                                  /* tp_as_sequence */
29857         0,                                  /* tp_as_mapping */
29858         0,                                  /* tp_hash */
29859         0,                                  /* tp_call */
29860         0,                                  /* tp_str */
29861         0,                                  /* tp_getattro */
29862         0,                                  /* tp_setattro */
29863         0,                                  /* tp_as_buffer */
29864         0,                                  /* tp_flags */
29865         0,                                  /* tp_doc */
29866 #if PY_VERSION_HEX >= 0x02000000
29867         0,                                  /* tp_traverse */
29868         0,                                  /* tp_clear */
29869 #endif
29870 #if PY_VERSION_HEX >= 0x02010000
29871         0,                                  /* tp_richcompare */
29872         0,                                  /* tp_weaklistoffset */
29873 #endif
29874 #if PY_VERSION_HEX >= 0x02020000
29875         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
29876 #endif
29877 #if PY_VERSION_HEX >= 0x02030000
29878         0,                                  /* tp_del */
29879 #endif
29880 #ifdef COUNT_ALLOCS
29881         0,0,0,0                             /* tp_alloc -> tp_next */
29882 #endif
29883     };
29884
29885     /* Create a variable linking object for use later */
29886     static PyObject *
29887     SWIG_Python_newvarlink(void) {
29888         swig_varlinkobject *result = 0;
29889         result = PyMem_NEW(swig_varlinkobject,1);
29890         varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
29891         result->ob_type = &varlinktype;
29892         result->vars = 0;
29893         result->ob_refcnt = 0;
29894         Py_XINCREF((PyObject *) result);
29895         return ((PyObject*) result);
29896     }
29897
29898     static void
29899     SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
29900         swig_varlinkobject *v;
29901         swig_globalvar *gv;
29902         v= (swig_varlinkobject *) p;
29903         gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
29904         gv->name = (char *) malloc(strlen(name)+1);
29905         strcpy(gv->name,name);
29906         gv->get_attr = get_attr;
29907         gv->set_attr = set_attr;
29908         gv->next = v->vars;
29909         v->vars = gv;
29910     }
29911
29912     /* -----------------------------------------------------------------------------
29913      * constants/methods manipulation
29914      * ----------------------------------------------------------------------------- */
29915
29916     /* Install Constants */
29917     static void
29918     SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
29919         PyObject *obj = 0;
29920         size_t i;
29921         for (i = 0; constants[i].type; i++) {
29922             switch(constants[i].type) {
29923                 case SWIG_PY_INT:
29924                 obj = PyInt_FromLong(constants[i].lvalue);
29925                 break;
29926                 case SWIG_PY_FLOAT:
29927                 obj = PyFloat_FromDouble(constants[i].dvalue);
29928                 break;
29929                 case SWIG_PY_STRING:
29930                 if (constants[i].pvalue) {
29931                     obj = PyString_FromString((char *) constants[i].pvalue);
29932                 } else {
29933                     Py_INCREF(Py_None);
29934                     obj = Py_None;
29935                 }
29936                 break;
29937                 case SWIG_PY_POINTER:
29938                 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
29939                 break;
29940                 case SWIG_PY_BINARY:
29941                 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
29942                 break;
29943                 default:
29944                 obj = 0;
29945                 break;
29946             }
29947             if (obj) {
29948                 PyDict_SetItemString(d,constants[i].name,obj);
29949                 Py_DECREF(obj);
29950             }
29951         }
29952     }
29953
29954     /* -----------------------------------------------------------------------------*/
29955     /* Fix SwigMethods to carry the callback ptrs when needed */
29956     /* -----------------------------------------------------------------------------*/
29957
29958     static void
29959     SWIG_Python_FixMethods(PyMethodDef *methods,
29960     swig_const_info *const_table,
29961     swig_type_info **types,
29962     swig_type_info **types_initial) {
29963         size_t i;
29964         for (i = 0; methods[i].ml_name; ++i) {
29965             char *c = methods[i].ml_doc;
29966             if (c && (c = strstr(c, "swig_ptr: "))) {
29967                 int j;
29968                 swig_const_info *ci = 0;
29969                 char *name = c + 10;
29970                 for (j = 0; const_table[j].type; j++) {
29971                     if (strncmp(const_table[j].name, name,
29972                     strlen(const_table[j].name)) == 0) {
29973                         ci = &(const_table[j]);
29974                         break;
29975                     }
29976                 }
29977                 if (ci) {
29978                     size_t shift = (ci->ptype) - types;
29979                     swig_type_info *ty = types_initial[shift];
29980                     size_t ldoc = (c - methods[i].ml_doc);
29981                     size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
29982                     char *ndoc = (char*)malloc(ldoc + lptr + 10);
29983                     char *buff = ndoc;
29984                     void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
29985                     strncpy(buff, methods[i].ml_doc, ldoc);
29986                     buff += ldoc;
29987                     strncpy(buff, "swig_ptr: ", 10);
29988                     buff += 10;
29989                     SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
29990                     methods[i].ml_doc = ndoc;
29991                 }
29992             }
29993         }
29994     }
29995
29996     /* -----------------------------------------------------------------------------*
29997      *  Initialize type list
29998      * -----------------------------------------------------------------------------*/
29999
30000 #if PY_MAJOR_VERSION < 2
30001     /* PyModule_AddObject function was introduced in Python 2.0.  The following function
30002     is copied out of Python/modsupport.c in python version 2.3.4 */
30003     static int
30004     PyModule_AddObject(PyObject *m, char *name, PyObject *o)
30005     {
30006         PyObject *dict;
30007         if (!PyModule_Check(m)) {
30008             PyErr_SetString(PyExc_TypeError,
30009             "PyModule_AddObject() needs module as first arg");
30010             return -1;
30011         }
30012         if (!o) {
30013             PyErr_SetString(PyExc_TypeError,
30014             "PyModule_AddObject() needs non-NULL value");
30015             return -1;
30016         }
30017
30018         dict = PyModule_GetDict(m);
30019         if (dict == NULL) {
30020             /* Internal error -- modules must have a dict! */
30021             PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
30022             PyModule_GetName(m));
30023             return -1;
30024         }
30025         if (PyDict_SetItemString(dict, name, o))
30026         return -1;
30027         Py_DECREF(o);
30028         return 0;
30029     }
30030 #endif
30031
30032     static swig_type_info **
30033     SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
30034         static PyMethodDef swig_empty_runtime_method_table[] = {
30035             {
30036                 NULL, NULL, 0, NULL
30037             }
30038         };/* Sentinel */
30039
30040         PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
30041         swig_empty_runtime_method_table);
30042         PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
30043         if (pointer && module) {
30044             PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
30045         }
30046         return type_list_handle;
30047     }
30048
30049     static swig_type_info **
30050     SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
30051         swig_type_info **type_pointer;
30052
30053         /* first check if module already created */
30054         type_pointer = SWIG_Python_GetTypeListHandle();
30055         if (type_pointer) {
30056             return type_pointer;
30057         } else {
30058             /* create a new module and variable */
30059             return SWIG_Python_SetTypeListHandle(type_list_handle);
30060         }
30061     }
30062
30063 #ifdef __cplusplus
30064 }
30065 #endif
30066
30067 /* -----------------------------------------------------------------------------*
30068  *  Partial Init method
30069  * -----------------------------------------------------------------------------*/
30070
30071 #ifdef SWIG_LINK_RUNTIME
30072 #ifdef __cplusplus
30073 extern "C"
30074 #endif
30075 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
30076 #endif
30077
30078 #ifdef __cplusplus
30079 extern "C"
30080 #endif
30081 SWIGEXPORT(void) SWIG_init(void) {
30082     static PyObject *SWIG_globals = 0;
30083     static int       typeinit = 0;
30084     PyObject *m, *d;
30085     int       i;
30086     if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
30087
30088     /* Fix SwigMethods to carry the callback ptrs when needed */
30089     SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
30090
30091     m = Py_InitModule((char *) SWIG_name, SwigMethods);
30092     d = PyModule_GetDict(m);
30093
30094     if (!typeinit) {
30095 #ifdef SWIG_LINK_RUNTIME
30096         swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
30097 #else
30098 #  ifndef SWIG_STATIC_RUNTIME
30099         swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
30100 #  endif
30101 #endif
30102         for (i = 0; swig_types_initial[i]; i++) {
30103             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
30104         }
30105         typeinit = 1;
30106     }
30107     SWIG_InstallConstants(d,swig_const_table);
30108
30109     PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
30110     SWIG_addvarlink(SWIG_globals,(char*)"FrameNameStr",_wrap_FrameNameStr_get, _wrap_FrameNameStr_set);
30111     SWIG_addvarlink(SWIG_globals,(char*)"DialogNameStr",_wrap_DialogNameStr_get, _wrap_DialogNameStr_set);
30112     SWIG_addvarlink(SWIG_globals,(char*)"StatusLineNameStr",_wrap_StatusLineNameStr_get, _wrap_StatusLineNameStr_set);
30113     SWIG_addvarlink(SWIG_globals,(char*)"ToolBarNameStr",_wrap_ToolBarNameStr_get, _wrap_ToolBarNameStr_set);
30114     {
30115         PyDict_SetItemString(d,"STAY_ON_TOP", SWIG_From_int((int)(wxSTAY_ON_TOP)));
30116     }
30117     {
30118         PyDict_SetItemString(d,"ICONIZE", SWIG_From_int((int)(wxICONIZE)));
30119     }
30120     {
30121         PyDict_SetItemString(d,"MINIMIZE", SWIG_From_int((int)(wxMINIMIZE)));
30122     }
30123     {
30124         PyDict_SetItemString(d,"MAXIMIZE", SWIG_From_int((int)(wxMAXIMIZE)));
30125     }
30126     {
30127         PyDict_SetItemString(d,"CLOSE_BOX", SWIG_From_int((int)(wxCLOSE_BOX)));
30128     }
30129     {
30130         PyDict_SetItemString(d,"THICK_FRAME", SWIG_From_int((int)(wxTHICK_FRAME)));
30131     }
30132     {
30133         PyDict_SetItemString(d,"SYSTEM_MENU", SWIG_From_int((int)(wxSYSTEM_MENU)));
30134     }
30135     {
30136         PyDict_SetItemString(d,"MINIMIZE_BOX", SWIG_From_int((int)(wxMINIMIZE_BOX)));
30137     }
30138     {
30139         PyDict_SetItemString(d,"MAXIMIZE_BOX", SWIG_From_int((int)(wxMAXIMIZE_BOX)));
30140     }
30141     {
30142         PyDict_SetItemString(d,"TINY_CAPTION_HORIZ", SWIG_From_int((int)(wxTINY_CAPTION_HORIZ)));
30143     }
30144     {
30145         PyDict_SetItemString(d,"TINY_CAPTION_VERT", SWIG_From_int((int)(wxTINY_CAPTION_VERT)));
30146     }
30147     {
30148         PyDict_SetItemString(d,"RESIZE_BOX", SWIG_From_int((int)(wxRESIZE_BOX)));
30149     }
30150     {
30151         PyDict_SetItemString(d,"RESIZE_BORDER", SWIG_From_int((int)(wxRESIZE_BORDER)));
30152     }
30153     {
30154         PyDict_SetItemString(d,"DIALOG_NO_PARENT", SWIG_From_int((int)(wxDIALOG_NO_PARENT)));
30155     }
30156     {
30157         PyDict_SetItemString(d,"DEFAULT_FRAME_STYLE", SWIG_From_int((int)(wxDEFAULT_FRAME_STYLE)));
30158     }
30159     {
30160         PyDict_SetItemString(d,"DEFAULT_DIALOG_STYLE", SWIG_From_int((int)(wxDEFAULT_DIALOG_STYLE)));
30161     }
30162     {
30163         PyDict_SetItemString(d,"FRAME_TOOL_WINDOW", SWIG_From_int((int)(wxFRAME_TOOL_WINDOW)));
30164     }
30165     {
30166         PyDict_SetItemString(d,"FRAME_FLOAT_ON_PARENT", SWIG_From_int((int)(wxFRAME_FLOAT_ON_PARENT)));
30167     }
30168     {
30169         PyDict_SetItemString(d,"FRAME_NO_WINDOW_MENU", SWIG_From_int((int)(wxFRAME_NO_WINDOW_MENU)));
30170     }
30171     {
30172         PyDict_SetItemString(d,"FRAME_NO_TASKBAR", SWIG_From_int((int)(wxFRAME_NO_TASKBAR)));
30173     }
30174     {
30175         PyDict_SetItemString(d,"FRAME_SHAPED", SWIG_From_int((int)(wxFRAME_SHAPED)));
30176     }
30177     {
30178         PyDict_SetItemString(d,"FRAME_DRAWER", SWIG_From_int((int)(wxFRAME_DRAWER)));
30179     }
30180     {
30181         PyDict_SetItemString(d,"FRAME_EX_METAL", SWIG_From_int((int)(wxFRAME_EX_METAL)));
30182     }
30183     {
30184         PyDict_SetItemString(d,"DIALOG_EX_METAL", SWIG_From_int((int)(wxDIALOG_EX_METAL)));
30185     }
30186     {
30187         PyDict_SetItemString(d,"DIALOG_MODAL", SWIG_From_int((int)(wxDIALOG_MODAL)));
30188     }
30189     {
30190         PyDict_SetItemString(d,"DIALOG_MODELESS", SWIG_From_int((int)(wxDIALOG_MODELESS)));
30191     }
30192     {
30193         PyDict_SetItemString(d,"USER_COLOURS", SWIG_From_int((int)(wxUSER_COLOURS)));
30194     }
30195     {
30196         PyDict_SetItemString(d,"NO_3D", SWIG_From_int((int)(wxNO_3D)));
30197     }
30198     {
30199         PyDict_SetItemString(d,"FULLSCREEN_NOMENUBAR", SWIG_From_int((int)(wxFULLSCREEN_NOMENUBAR)));
30200     }
30201     {
30202         PyDict_SetItemString(d,"FULLSCREEN_NOTOOLBAR", SWIG_From_int((int)(wxFULLSCREEN_NOTOOLBAR)));
30203     }
30204     {
30205         PyDict_SetItemString(d,"FULLSCREEN_NOSTATUSBAR", SWIG_From_int((int)(wxFULLSCREEN_NOSTATUSBAR)));
30206     }
30207     {
30208         PyDict_SetItemString(d,"FULLSCREEN_NOBORDER", SWIG_From_int((int)(wxFULLSCREEN_NOBORDER)));
30209     }
30210     {
30211         PyDict_SetItemString(d,"FULLSCREEN_NOCAPTION", SWIG_From_int((int)(wxFULLSCREEN_NOCAPTION)));
30212     }
30213     {
30214         PyDict_SetItemString(d,"FULLSCREEN_ALL", SWIG_From_int((int)(wxFULLSCREEN_ALL)));
30215     }
30216     {
30217         PyDict_SetItemString(d,"TOPLEVEL_EX_DIALOG", SWIG_From_int((int)(wxTOPLEVEL_EX_DIALOG)));
30218     }
30219     {
30220         PyDict_SetItemString(d,"USER_ATTENTION_INFO", SWIG_From_int((int)(wxUSER_ATTENTION_INFO)));
30221     }
30222     {
30223         PyDict_SetItemString(d,"USER_ATTENTION_ERROR", SWIG_From_int((int)(wxUSER_ATTENTION_ERROR)));
30224     }
30225     {
30226         PyDict_SetItemString(d,"SPLASH_CENTRE_ON_PARENT", SWIG_From_int((int)(wxSPLASH_CENTRE_ON_PARENT)));
30227     }
30228     {
30229         PyDict_SetItemString(d,"SPLASH_CENTRE_ON_SCREEN", SWIG_From_int((int)(wxSPLASH_CENTRE_ON_SCREEN)));
30230     }
30231     {
30232         PyDict_SetItemString(d,"SPLASH_NO_CENTRE", SWIG_From_int((int)(wxSPLASH_NO_CENTRE)));
30233     }
30234     {
30235         PyDict_SetItemString(d,"SPLASH_TIMEOUT", SWIG_From_int((int)(wxSPLASH_TIMEOUT)));
30236     }
30237     {
30238         PyDict_SetItemString(d,"SPLASH_NO_TIMEOUT", SWIG_From_int((int)(wxSPLASH_NO_TIMEOUT)));
30239     }
30240     {
30241         PyDict_SetItemString(d,"SB_NORMAL", SWIG_From_int((int)(wxSB_NORMAL)));
30242     }
30243     {
30244         PyDict_SetItemString(d,"SB_FLAT", SWIG_From_int((int)(wxSB_FLAT)));
30245     }
30246     {
30247         PyDict_SetItemString(d,"SB_RAISED", SWIG_From_int((int)(wxSB_RAISED)));
30248     }
30249     SWIG_addvarlink(SWIG_globals,(char*)"SplitterNameStr",_wrap_SplitterNameStr_get, _wrap_SplitterNameStr_set);
30250     {
30251         PyDict_SetItemString(d,"SP_NOBORDER", SWIG_From_int((int)(wxSP_NOBORDER)));
30252     }
30253     {
30254         PyDict_SetItemString(d,"SP_NOSASH", SWIG_From_int((int)(wxSP_NOSASH)));
30255     }
30256     {
30257         PyDict_SetItemString(d,"SP_PERMIT_UNSPLIT", SWIG_From_int((int)(wxSP_PERMIT_UNSPLIT)));
30258     }
30259     {
30260         PyDict_SetItemString(d,"SP_LIVE_UPDATE", SWIG_From_int((int)(wxSP_LIVE_UPDATE)));
30261     }
30262     {
30263         PyDict_SetItemString(d,"SP_3DSASH", SWIG_From_int((int)(wxSP_3DSASH)));
30264     }
30265     {
30266         PyDict_SetItemString(d,"SP_3DBORDER", SWIG_From_int((int)(wxSP_3DBORDER)));
30267     }
30268     {
30269         PyDict_SetItemString(d,"SP_NO_XP_THEME", SWIG_From_int((int)(wxSP_NO_XP_THEME)));
30270     }
30271     {
30272         PyDict_SetItemString(d,"SP_BORDER", SWIG_From_int((int)(wxSP_BORDER)));
30273     }
30274     {
30275         PyDict_SetItemString(d,"SP_3D", SWIG_From_int((int)(wxSP_3D)));
30276     }
30277     {
30278         PyDict_SetItemString(d,"SPLIT_HORIZONTAL", SWIG_From_int((int)(wxSPLIT_HORIZONTAL)));
30279     }
30280     {
30281         PyDict_SetItemString(d,"SPLIT_VERTICAL", SWIG_From_int((int)(wxSPLIT_VERTICAL)));
30282     }
30283     {
30284         PyDict_SetItemString(d,"SPLIT_DRAG_NONE", SWIG_From_int((int)(wxSPLIT_DRAG_NONE)));
30285     }
30286     {
30287         PyDict_SetItemString(d,"SPLIT_DRAG_DRAGGING", SWIG_From_int((int)(wxSPLIT_DRAG_DRAGGING)));
30288     }
30289     {
30290         PyDict_SetItemString(d,"SPLIT_DRAG_LEFT_DOWN", SWIG_From_int((int)(wxSPLIT_DRAG_LEFT_DOWN)));
30291     }
30292     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED));
30293     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING));
30294     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_DOUBLECLICKED));
30295     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_UNSPLIT", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_UNSPLIT));
30296     SWIG_addvarlink(SWIG_globals,(char*)"SashNameStr",_wrap_SashNameStr_get, _wrap_SashNameStr_set);
30297     SWIG_addvarlink(SWIG_globals,(char*)"SashLayoutNameStr",_wrap_SashLayoutNameStr_get, _wrap_SashLayoutNameStr_set);
30298     {
30299         PyDict_SetItemString(d,"SASH_DRAG_NONE", SWIG_From_int((int)(wxSASH_DRAG_NONE)));
30300     }
30301     {
30302         PyDict_SetItemString(d,"SASH_DRAG_DRAGGING", SWIG_From_int((int)(wxSASH_DRAG_DRAGGING)));
30303     }
30304     {
30305         PyDict_SetItemString(d,"SASH_DRAG_LEFT_DOWN", SWIG_From_int((int)(wxSASH_DRAG_LEFT_DOWN)));
30306     }
30307     {
30308         PyDict_SetItemString(d,"SW_NOBORDER", SWIG_From_int((int)(wxSW_NOBORDER)));
30309     }
30310     {
30311         PyDict_SetItemString(d,"SW_BORDER", SWIG_From_int((int)(wxSW_BORDER)));
30312     }
30313     {
30314         PyDict_SetItemString(d,"SW_3DSASH", SWIG_From_int((int)(wxSW_3DSASH)));
30315     }
30316     {
30317         PyDict_SetItemString(d,"SW_3DBORDER", SWIG_From_int((int)(wxSW_3DBORDER)));
30318     }
30319     {
30320         PyDict_SetItemString(d,"SW_3D", SWIG_From_int((int)(wxSW_3D)));
30321     }
30322     {
30323         PyDict_SetItemString(d,"SASH_TOP", SWIG_From_int((int)(wxSASH_TOP)));
30324     }
30325     {
30326         PyDict_SetItemString(d,"SASH_RIGHT", SWIG_From_int((int)(wxSASH_RIGHT)));
30327     }
30328     {
30329         PyDict_SetItemString(d,"SASH_BOTTOM", SWIG_From_int((int)(wxSASH_BOTTOM)));
30330     }
30331     {
30332         PyDict_SetItemString(d,"SASH_LEFT", SWIG_From_int((int)(wxSASH_LEFT)));
30333     }
30334     {
30335         PyDict_SetItemString(d,"SASH_NONE", SWIG_From_int((int)(wxSASH_NONE)));
30336     }
30337     {
30338         PyDict_SetItemString(d,"SASH_STATUS_OK", SWIG_From_int((int)(wxSASH_STATUS_OK)));
30339     }
30340     {
30341         PyDict_SetItemString(d,"SASH_STATUS_OUT_OF_RANGE", SWIG_From_int((int)(wxSASH_STATUS_OUT_OF_RANGE)));
30342     }
30343     PyDict_SetItemString(d, "wxEVT_SASH_DRAGGED", PyInt_FromLong(wxEVT_SASH_DRAGGED));
30344     {
30345         PyDict_SetItemString(d,"LAYOUT_HORIZONTAL", SWIG_From_int((int)(wxLAYOUT_HORIZONTAL)));
30346     }
30347     {
30348         PyDict_SetItemString(d,"LAYOUT_VERTICAL", SWIG_From_int((int)(wxLAYOUT_VERTICAL)));
30349     }
30350     {
30351         PyDict_SetItemString(d,"LAYOUT_NONE", SWIG_From_int((int)(wxLAYOUT_NONE)));
30352     }
30353     {
30354         PyDict_SetItemString(d,"LAYOUT_TOP", SWIG_From_int((int)(wxLAYOUT_TOP)));
30355     }
30356     {
30357         PyDict_SetItemString(d,"LAYOUT_LEFT", SWIG_From_int((int)(wxLAYOUT_LEFT)));
30358     }
30359     {
30360         PyDict_SetItemString(d,"LAYOUT_RIGHT", SWIG_From_int((int)(wxLAYOUT_RIGHT)));
30361     }
30362     {
30363         PyDict_SetItemString(d,"LAYOUT_BOTTOM", SWIG_From_int((int)(wxLAYOUT_BOTTOM)));
30364     }
30365     {
30366         PyDict_SetItemString(d,"LAYOUT_LENGTH_Y", SWIG_From_int((int)(wxLAYOUT_LENGTH_Y)));
30367     }
30368     {
30369         PyDict_SetItemString(d,"LAYOUT_LENGTH_X", SWIG_From_int((int)(wxLAYOUT_LENGTH_X)));
30370     }
30371     {
30372         PyDict_SetItemString(d,"LAYOUT_MRU_LENGTH", SWIG_From_int((int)(wxLAYOUT_MRU_LENGTH)));
30373     }
30374     {
30375         PyDict_SetItemString(d,"LAYOUT_QUERY", SWIG_From_int((int)(wxLAYOUT_QUERY)));
30376     }
30377     PyDict_SetItemString(d, "wxEVT_QUERY_LAYOUT_INFO", PyInt_FromLong(wxEVT_QUERY_LAYOUT_INFO));
30378     PyDict_SetItemString(d, "wxEVT_CALCULATE_LAYOUT", PyInt_FromLong(wxEVT_CALCULATE_LAYOUT));
30379     SWIG_addvarlink(SWIG_globals,(char*)"VListBoxNameStr",_wrap_VListBoxNameStr_get, _wrap_VListBoxNameStr_set);
30380
30381     // Map renamed classes back to their common name for OOR
30382     wxPyPtrTypeMap_Add("wxHtmlListBox",     "wxPyHtmlListBox");
30383     wxPyPtrTypeMap_Add("wxVListBox",        "wxPyVListBox");
30384     wxPyPtrTypeMap_Add("wxVScrolledWindow", "wxPyVScrolledWindow");
30385
30386     PyDict_SetItemString(d, "wxEVT_TASKBAR_MOVE", PyInt_FromLong(wxEVT_TASKBAR_MOVE));
30387     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DOWN", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DOWN));
30388     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_UP", PyInt_FromLong(wxEVT_TASKBAR_LEFT_UP));
30389     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DOWN", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DOWN));
30390     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_UP", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_UP));
30391     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DCLICK));
30392     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DCLICK));
30393     SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
30394     SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
30395     SWIG_addvarlink(SWIG_globals,(char*)"DirDialogNameStr",_wrap_DirDialogNameStr_get, _wrap_DirDialogNameStr_set);
30396     SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
30397     SWIG_addvarlink(SWIG_globals,(char*)"GetTextFromUserPromptStr",_wrap_GetTextFromUserPromptStr_get, _wrap_GetTextFromUserPromptStr_set);
30398     SWIG_addvarlink(SWIG_globals,(char*)"MessageBoxCaptionStr",_wrap_MessageBoxCaptionStr_get, _wrap_MessageBoxCaptionStr_set);
30399     {
30400         PyDict_SetItemString(d,"CHOICEDLG_STYLE", SWIG_From_int((int)(wxCHOICEDLG_STYLE)));
30401     }
30402     {
30403         PyDict_SetItemString(d,"TextEntryDialogStyle", SWIG_From_int((int)(wxTextEntryDialogStyle)));
30404     }
30405     SWIG_addvarlink(SWIG_globals,(char*)"GetPasswordFromUserPromptStr",_wrap_GetPasswordFromUserPromptStr_get, _wrap_GetPasswordFromUserPromptStr_set);
30406     {
30407         PyDict_SetItemString(d,"FR_DOWN", SWIG_From_int((int)(wxFR_DOWN)));
30408     }
30409     {
30410         PyDict_SetItemString(d,"FR_WHOLEWORD", SWIG_From_int((int)(wxFR_WHOLEWORD)));
30411     }
30412     {
30413         PyDict_SetItemString(d,"FR_MATCHCASE", SWIG_From_int((int)(wxFR_MATCHCASE)));
30414     }
30415     {
30416         PyDict_SetItemString(d,"FR_REPLACEDIALOG", SWIG_From_int((int)(wxFR_REPLACEDIALOG)));
30417     }
30418     {
30419         PyDict_SetItemString(d,"FR_NOUPDOWN", SWIG_From_int((int)(wxFR_NOUPDOWN)));
30420     }
30421     {
30422         PyDict_SetItemString(d,"FR_NOMATCHCASE", SWIG_From_int((int)(wxFR_NOMATCHCASE)));
30423     }
30424     {
30425         PyDict_SetItemString(d,"FR_NOWHOLEWORD", SWIG_From_int((int)(wxFR_NOWHOLEWORD)));
30426     }
30427     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND", PyInt_FromLong(wxEVT_COMMAND_FIND));
30428     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_NEXT", PyInt_FromLong(wxEVT_COMMAND_FIND_NEXT));
30429     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE));
30430     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE_ALL", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE_ALL));
30431     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_CLOSE", PyInt_FromLong(wxEVT_COMMAND_FIND_CLOSE));
30432     {
30433         PyDict_SetItemString(d,"IDM_WINDOWTILE", SWIG_From_int((int)(4001)));
30434     }
30435     {
30436         PyDict_SetItemString(d,"IDM_WINDOWTILEHOR", SWIG_From_int((int)(4001)));
30437     }
30438     {
30439         PyDict_SetItemString(d,"IDM_WINDOWCASCADE", SWIG_From_int((int)(4002)));
30440     }
30441     {
30442         PyDict_SetItemString(d,"IDM_WINDOWICONS", SWIG_From_int((int)(4003)));
30443     }
30444     {
30445         PyDict_SetItemString(d,"IDM_WINDOWNEXT", SWIG_From_int((int)(4004)));
30446     }
30447     {
30448         PyDict_SetItemString(d,"IDM_WINDOWTILEVERT", SWIG_From_int((int)(4005)));
30449     }
30450     {
30451         PyDict_SetItemString(d,"IDM_WINDOWPREV", SWIG_From_int((int)(4006)));
30452     }
30453     {
30454         PyDict_SetItemString(d,"FIRST_MDI_CHILD", SWIG_From_int((int)(4100)));
30455     }
30456     {
30457         PyDict_SetItemString(d,"LAST_MDI_CHILD", SWIG_From_int((int)(4600)));
30458     }
30459     SWIG_addvarlink(SWIG_globals,(char*)"PrintoutTitleStr",_wrap_PrintoutTitleStr_get, _wrap_PrintoutTitleStr_set);
30460     SWIG_addvarlink(SWIG_globals,(char*)"PreviewCanvasNameStr",_wrap_PreviewCanvasNameStr_get, _wrap_PreviewCanvasNameStr_set);
30461     {
30462         PyDict_SetItemString(d,"PRINT_MODE_NONE", SWIG_From_int((int)(wxPRINT_MODE_NONE)));
30463     }
30464     {
30465         PyDict_SetItemString(d,"PRINT_MODE_PREVIEW", SWIG_From_int((int)(wxPRINT_MODE_PREVIEW)));
30466     }
30467     {
30468         PyDict_SetItemString(d,"PRINT_MODE_FILE", SWIG_From_int((int)(wxPRINT_MODE_FILE)));
30469     }
30470     {
30471         PyDict_SetItemString(d,"PRINT_MODE_PRINTER", SWIG_From_int((int)(wxPRINT_MODE_PRINTER)));
30472     }
30473     {
30474         PyDict_SetItemString(d,"PRINT_MODE_STREAM", SWIG_From_int((int)(wxPRINT_MODE_STREAM)));
30475     }
30476     {
30477         PyDict_SetItemString(d,"PRINTBIN_DEFAULT", SWIG_From_int((int)(wxPRINTBIN_DEFAULT)));
30478     }
30479     {
30480         PyDict_SetItemString(d,"PRINTBIN_ONLYONE", SWIG_From_int((int)(wxPRINTBIN_ONLYONE)));
30481     }
30482     {
30483         PyDict_SetItemString(d,"PRINTBIN_LOWER", SWIG_From_int((int)(wxPRINTBIN_LOWER)));
30484     }
30485     {
30486         PyDict_SetItemString(d,"PRINTBIN_MIDDLE", SWIG_From_int((int)(wxPRINTBIN_MIDDLE)));
30487     }
30488     {
30489         PyDict_SetItemString(d,"PRINTBIN_MANUAL", SWIG_From_int((int)(wxPRINTBIN_MANUAL)));
30490     }
30491     {
30492         PyDict_SetItemString(d,"PRINTBIN_ENVELOPE", SWIG_From_int((int)(wxPRINTBIN_ENVELOPE)));
30493     }
30494     {
30495         PyDict_SetItemString(d,"PRINTBIN_ENVMANUAL", SWIG_From_int((int)(wxPRINTBIN_ENVMANUAL)));
30496     }
30497     {
30498         PyDict_SetItemString(d,"PRINTBIN_AUTO", SWIG_From_int((int)(wxPRINTBIN_AUTO)));
30499     }
30500     {
30501         PyDict_SetItemString(d,"PRINTBIN_TRACTOR", SWIG_From_int((int)(wxPRINTBIN_TRACTOR)));
30502     }
30503     {
30504         PyDict_SetItemString(d,"PRINTBIN_SMALLFMT", SWIG_From_int((int)(wxPRINTBIN_SMALLFMT)));
30505     }
30506     {
30507         PyDict_SetItemString(d,"PRINTBIN_LARGEFMT", SWIG_From_int((int)(wxPRINTBIN_LARGEFMT)));
30508     }
30509     {
30510         PyDict_SetItemString(d,"PRINTBIN_LARGECAPACITY", SWIG_From_int((int)(wxPRINTBIN_LARGECAPACITY)));
30511     }
30512     {
30513         PyDict_SetItemString(d,"PRINTBIN_CASSETTE", SWIG_From_int((int)(wxPRINTBIN_CASSETTE)));
30514     }
30515     {
30516         PyDict_SetItemString(d,"PRINTBIN_FORMSOURCE", SWIG_From_int((int)(wxPRINTBIN_FORMSOURCE)));
30517     }
30518     {
30519         PyDict_SetItemString(d,"PRINTBIN_USER", SWIG_From_int((int)(wxPRINTBIN_USER)));
30520     }
30521     {
30522         PyDict_SetItemString(d,"PRINTER_NO_ERROR", SWIG_From_int((int)(wxPRINTER_NO_ERROR)));
30523     }
30524     {
30525         PyDict_SetItemString(d,"PRINTER_CANCELLED", SWIG_From_int((int)(wxPRINTER_CANCELLED)));
30526     }
30527     {
30528         PyDict_SetItemString(d,"PRINTER_ERROR", SWIG_From_int((int)(wxPRINTER_ERROR)));
30529     }
30530     {
30531         PyDict_SetItemString(d,"PREVIEW_PRINT", SWIG_From_int((int)(wxPREVIEW_PRINT)));
30532     }
30533     {
30534         PyDict_SetItemString(d,"PREVIEW_PREVIOUS", SWIG_From_int((int)(wxPREVIEW_PREVIOUS)));
30535     }
30536     {
30537         PyDict_SetItemString(d,"PREVIEW_NEXT", SWIG_From_int((int)(wxPREVIEW_NEXT)));
30538     }
30539     {
30540         PyDict_SetItemString(d,"PREVIEW_ZOOM", SWIG_From_int((int)(wxPREVIEW_ZOOM)));
30541     }
30542     {
30543         PyDict_SetItemString(d,"PREVIEW_FIRST", SWIG_From_int((int)(wxPREVIEW_FIRST)));
30544     }
30545     {
30546         PyDict_SetItemString(d,"PREVIEW_LAST", SWIG_From_int((int)(wxPREVIEW_LAST)));
30547     }
30548     {
30549         PyDict_SetItemString(d,"PREVIEW_GOTO", SWIG_From_int((int)(wxPREVIEW_GOTO)));
30550     }
30551     {
30552         PyDict_SetItemString(d,"PREVIEW_DEFAULT", SWIG_From_int((int)(wxPREVIEW_DEFAULT)));
30553     }
30554     {
30555         PyDict_SetItemString(d,"ID_PREVIEW_CLOSE", SWIG_From_int((int)(wxID_PREVIEW_CLOSE)));
30556     }
30557     {
30558         PyDict_SetItemString(d,"ID_PREVIEW_NEXT", SWIG_From_int((int)(wxID_PREVIEW_NEXT)));
30559     }
30560     {
30561         PyDict_SetItemString(d,"ID_PREVIEW_PREVIOUS", SWIG_From_int((int)(wxID_PREVIEW_PREVIOUS)));
30562     }
30563     {
30564         PyDict_SetItemString(d,"ID_PREVIEW_PRINT", SWIG_From_int((int)(wxID_PREVIEW_PRINT)));
30565     }
30566     {
30567         PyDict_SetItemString(d,"ID_PREVIEW_ZOOM", SWIG_From_int((int)(wxID_PREVIEW_ZOOM)));
30568     }
30569     {
30570         PyDict_SetItemString(d,"ID_PREVIEW_FIRST", SWIG_From_int((int)(wxID_PREVIEW_FIRST)));
30571     }
30572     {
30573         PyDict_SetItemString(d,"ID_PREVIEW_LAST", SWIG_From_int((int)(wxID_PREVIEW_LAST)));
30574     }
30575     {
30576         PyDict_SetItemString(d,"ID_PREVIEW_GOTO", SWIG_From_int((int)(wxID_PREVIEW_GOTO)));
30577     }
30578
30579     wxPyPtrTypeMap_Add("wxPrintout", "wxPyPrintout");
30580
30581 }
30582