wxPython/src/mac/_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         if (str)
1041           Py_DECREF(str);
1042         return;
1043       }
1044     }
1045     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046   } else {
1047     PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048   }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054   if (type) {
1055     PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056   } else {
1057     PyErr_Format(PyExc_TypeError, "null reference was received");
1058   }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064   if (PyErr_Occurred()) {
1065     PyObject *type = 0;
1066     PyObject *value = 0;
1067     PyObject *traceback = 0;
1068     PyErr_Fetch(&type, &value, &traceback);
1069     if (value) {
1070       PyObject *old_str = PyObject_Str(value);
1071       Py_XINCREF(type);
1072       PyErr_Clear();
1073       if (infront) {
1074         PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075       } else {
1076         PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077       }
1078       Py_DECREF(old_str);
1079     }
1080     return 1;
1081   } else {
1082     return 0;
1083   }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089   if (PyErr_Occurred()) {
1090     /* add information about failing argument */
1091     char mesg[256];
1092     sprintf(mesg, "argument number %d:", argnum);
1093     return SWIG_Python_AddErrMesg(mesg, 1);
1094   } else {
1095     return 0;
1096   }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101  * pointers/data manipulation
1102  * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107   swig_type_info *tc;
1108   const char *c = 0;
1109   static PyObject *SWIG_this = 0;
1110   int    newref = 0;
1111   PyObject  *pyobj = 0;
1112   void *vptr;
1113
1114   if (!obj) return 0;
1115   if (obj == Py_None) {
1116     *ptr = 0;
1117     return 0;
1118   }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121   if (!(PySwigObject_Check(obj))) {
1122     if (!SWIG_this)
1123       SWIG_this = PyString_FromString("this");
1124     pyobj = obj;
1125     obj = PyObject_GetAttr(obj,SWIG_this);
1126     newref = 1;
1127     if (!obj) goto type_error;
1128     if (!PySwigObject_Check(obj)) {
1129       Py_DECREF(obj);
1130       goto type_error;
1131     }
1132   }
1133   vptr = PySwigObject_AsVoidPtr(obj);
1134   c = (const char *) PySwigObject_GetDesc(obj);
1135   if (newref) { Py_DECREF(obj); }
1136   goto type_check;
1137 #else
1138   if (!(PyString_Check(obj))) {
1139     if (!SWIG_this)
1140       SWIG_this = PyString_FromString("this");
1141     pyobj = obj;
1142     obj = PyObject_GetAttr(obj,SWIG_this);
1143     newref = 1;
1144     if (!obj) goto type_error;
1145     if (!PyString_Check(obj)) {
1146       Py_DECREF(obj);
1147       goto type_error;
1148     }
1149   }
1150   c = PyString_AS_STRING(obj);
1151   /* Pointer values must start with leading underscore */
1152   c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153   if (newref) { Py_DECREF(obj); }
1154   if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159   if (ty) {
1160     tc = SWIG_TypeCheck(c,ty);
1161     if (!tc) goto type_error;
1162     *ptr = SWIG_TypeCast(tc,vptr);
1163   } else {
1164     *ptr = vptr;
1165   }
1166
1167   if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168     PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169   }
1170   return 0;
1171
1172 type_error:
1173   PyErr_Clear();
1174   if (pyobj && !obj) {
1175     obj = pyobj;
1176     if (PyCFunction_Check(obj)) {
1177       /* here we get the method pointer for callbacks */
1178       char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179       c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180       if (c) {
1181         c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182         if (!c) goto type_error;
1183         goto type_check;
1184       }
1185     }
1186   }
1187   if (flags & SWIG_POINTER_EXCEPTION) {
1188     if (ty) {
1189       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190     } else {
1191       SWIG_Python_TypeError("C/C++ pointer", obj);
1192     }
1193   }
1194   return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200   void *result;
1201   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202     PyErr_Clear();
1203     if (flags & SWIG_POINTER_EXCEPTION) {
1204       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205       SWIG_Python_ArgFail(argnum);
1206     }
1207   }
1208   return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214   swig_type_info *tc;
1215   const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218   c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220   if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221   c = PyString_AS_STRING(obj);
1222   /* Pointer values must start with leading underscore */
1223   c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225   if (!c) goto type_error;
1226   if (ty) {
1227     tc = SWIG_TypeCheck(c,ty);
1228     if (!tc) goto type_error;
1229   }
1230   return 0;
1231
1232 type_error:
1233   PyErr_Clear();
1234   if (flags & SWIG_POINTER_EXCEPTION) {
1235     if (ty) {
1236       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237     } else {
1238       SWIG_Python_TypeError("C/C++ packed data", obj);
1239     }
1240   }
1241   return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247   PyObject *robj = 0;
1248   if (!ptr) {
1249     Py_INCREF(Py_None);
1250     return Py_None;
1251   }
1252 #ifdef SWIG_COBJECT_TYPES
1253   robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255   {
1256     char result[SWIG_BUFFER_SIZE];
1257     robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258       PyString_FromString(result) : 0;
1259   }
1260 #endif
1261   if (!robj || (robj == Py_None)) return robj;
1262   if (type->clientdata) {
1263     PyObject *inst;
1264     PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265     Py_DECREF(robj);
1266     inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267     Py_DECREF(args);
1268     if (inst) {
1269       if (own) {
1270         PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271       }
1272       robj = inst;
1273     }
1274   }
1275   return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280   PyObject *robj = 0;
1281   if (!ptr) {
1282     Py_INCREF(Py_None);
1283     return Py_None;
1284   }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286   robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288   {
1289     char result[SWIG_BUFFER_SIZE];
1290     robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291       PyString_FromString(result) : 0;
1292   }
1293 #endif
1294   return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298  *  Get type list
1299  * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307   static void *type_pointer = (void *)0;
1308   /* first check if module already created */
1309   if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315     if (PyErr_Occurred()) {
1316       PyErr_Clear();
1317       type_pointer = (void *)0;
1318     }
1319   }
1320 #endif
1321   return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325   Search for a swig_type_info structure
1326  */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329   swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330   return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define  SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[0]
1343 #define  SWIGTYPE_p_wxPreviewFrame swig_types[1]
1344 #define  SWIGTYPE_p_wxPyPreviewFrame swig_types[2]
1345 #define  SWIGTYPE_p_wxPyPanel swig_types[3]
1346 #define  SWIGTYPE_p_wxMenu swig_types[4]
1347 #define  SWIGTYPE_p_wxFontData swig_types[5]
1348 #define  SWIGTYPE_p_wxEvent swig_types[6]
1349 #define  SWIGTYPE_p_wxPrintData swig_types[7]
1350 #define  SWIGTYPE_p_wxTaskBarIcon swig_types[8]
1351 #define  SWIGTYPE_p_wxPyTaskBarIcon swig_types[9]
1352 #define  SWIGTYPE_p_wxIconBundle swig_types[10]
1353 #define  SWIGTYPE_p_wxLayoutAlgorithm swig_types[11]
1354 #define  SWIGTYPE_p_wxFindDialogEvent swig_types[12]
1355 #define  SWIGTYPE_p_wxPreviewCanvas swig_types[13]
1356 #define  SWIGTYPE_p_wxFont swig_types[14]
1357 #define  SWIGTYPE_p_wxSplitterEvent swig_types[15]
1358 #define  SWIGTYPE_p_wxRegion swig_types[16]
1359 #define  SWIGTYPE_ptrdiff_t swig_types[17]
1360 #define  SWIGTYPE_std__ptrdiff_t swig_types[18]
1361 #define  SWIGTYPE_p_wxFindReplaceData swig_types[19]
1362 #define  SWIGTYPE_p_int swig_types[20]
1363 #define  SWIGTYPE_p_wxSize swig_types[21]
1364 #define  SWIGTYPE_p_wxDC swig_types[22]
1365 #define  SWIGTYPE_p_wxIcon swig_types[23]
1366 #define  SWIGTYPE_p_wxVisualAttributes swig_types[24]
1367 #define  SWIGTYPE_p_wxMDIChildFrame swig_types[25]
1368 #define  SWIGTYPE_p_wxColourData swig_types[26]
1369 #define  SWIGTYPE_p_wxNotifyEvent swig_types[27]
1370 #define  SWIGTYPE_p_wxPyWindow swig_types[28]
1371 #define  SWIGTYPE_p_form_ops_t swig_types[29]
1372 #define  SWIGTYPE_p_wxSplashScreen swig_types[30]
1373 #define  SWIGTYPE_p_wxPasswordEntryDialog swig_types[31]
1374 #define  SWIGTYPE_p_wxSingleChoiceDialog swig_types[32]
1375 #define  SWIGTYPE_p_wxMultiChoiceDialog swig_types[33]
1376 #define  SWIGTYPE_p_wxFileDialog swig_types[34]
1377 #define  SWIGTYPE_p_wxTextEntryDialog swig_types[35]
1378 #define  SWIGTYPE_p_wxMessageDialog swig_types[36]
1379 #define  SWIGTYPE_p_wxProgressDialog swig_types[37]
1380 #define  SWIGTYPE_p_wxFindReplaceDialog swig_types[38]
1381 #define  SWIGTYPE_p_wxPrinter swig_types[39]
1382 #define  SWIGTYPE_p_wxArrayInt swig_types[40]
1383 #define  SWIGTYPE_p_wxDuplexMode swig_types[41]
1384 #define  SWIGTYPE_p_wxEvtHandler swig_types[42]
1385 #define  SWIGTYPE_p_wxCalculateLayoutEvent swig_types[43]
1386 #define  SWIGTYPE_p_wxPyHtmlListBox swig_types[44]
1387 #define  SWIGTYPE_p_wxPyVListBox swig_types[45]
1388 #define  SWIGTYPE_p_wxRect swig_types[46]
1389 #define  SWIGTYPE_p_wxStdDialogButtonSizer swig_types[47]
1390 #define  SWIGTYPE_p_char swig_types[48]
1391 #define  SWIGTYPE_p_wxMiniFrame swig_types[49]
1392 #define  SWIGTYPE_p_wxFrame swig_types[50]
1393 #define  SWIGTYPE_p_wxPyPrintout swig_types[51]
1394 #define  SWIGTYPE_p_wxTaskBarIconEvent swig_types[52]
1395 #define  SWIGTYPE_p_wxScrollWinEvent swig_types[53]
1396 #define  SWIGTYPE_p_wxPaperSize swig_types[54]
1397 #define  SWIGTYPE_p_wxStatusBar swig_types[55]
1398 #define  SWIGTYPE_p_wxMDIParentFrame swig_types[56]
1399 #define  SWIGTYPE_p_wxPoint swig_types[57]
1400 #define  SWIGTYPE_p_wxObject swig_types[58]
1401 #define  SWIGTYPE_p_unsigned_long swig_types[59]
1402 #define  SWIGTYPE_p_wxTipWindow swig_types[60]
1403 #define  SWIGTYPE_p_wxPyPopupTransientWindow swig_types[61]
1404 #define  SWIGTYPE_p_wxSashLayoutWindow swig_types[62]
1405 #define  SWIGTYPE_p_wxSplitterWindow swig_types[63]
1406 #define  SWIGTYPE_p_wxSplashScreenWindow swig_types[64]
1407 #define  SWIGTYPE_p_wxPyVScrolledWindow swig_types[65]
1408 #define  SWIGTYPE_p_wxPopupWindow swig_types[66]
1409 #define  SWIGTYPE_p_wxSashWindow swig_types[67]
1410 #define  SWIGTYPE_p_wxTopLevelWindow swig_types[68]
1411 #define  SWIGTYPE_p_wxWindow swig_types[69]
1412 #define  SWIGTYPE_p_wxScrolledWindow swig_types[70]
1413 #define  SWIGTYPE_p_wxMenuBar swig_types[71]
1414 #define  SWIGTYPE_p_wxMDIClientWindow swig_types[72]
1415 #define  SWIGTYPE_p_wxPyScrolledWindow swig_types[73]
1416 #define  SWIGTYPE_p_wxPrintPreview swig_types[74]
1417 #define  SWIGTYPE_p_wxSashEvent swig_types[75]
1418 #define  SWIGTYPE_p_wxString swig_types[76]
1419 #define  SWIGTYPE_p_wxPyPrintPreview swig_types[77]
1420 #define  SWIGTYPE_p_wxDirDialog swig_types[78]
1421 #define  SWIGTYPE_p_wxColourDialog swig_types[79]
1422 #define  SWIGTYPE_p_wxDialog swig_types[80]
1423 #define  SWIGTYPE_p_wxPanel swig_types[81]
1424 #define  SWIGTYPE_p_wxFontDialog swig_types[82]
1425 #define  SWIGTYPE_p_wxPageSetupDialog swig_types[83]
1426 #define  SWIGTYPE_p_wxPrintDialog swig_types[84]
1427 #define  SWIGTYPE_p_wxFileSystem swig_types[85]
1428 #define  SWIGTYPE_p_wxBitmap swig_types[86]
1429 #define  SWIGTYPE_unsigned_int swig_types[87]
1430 #define  SWIGTYPE_p_unsigned_int swig_types[88]
1431 #define  SWIGTYPE_p_unsigned_char swig_types[89]
1432 #define  SWIGTYPE_p_wxCommandEvent swig_types[90]
1433 #define  SWIGTYPE_p_wxPreviewControlBar swig_types[91]
1434 #define  SWIGTYPE_p_wxPyPreviewControlBar swig_types[92]
1435 #define  SWIGTYPE_p_wxColour swig_types[93]
1436 #define  SWIGTYPE_p_wxToolBar swig_types[94]
1437 #define  SWIGTYPE_p_wxPageSetupDialogData swig_types[95]
1438 #define  SWIGTYPE_p_wxPrintDialogData swig_types[96]
1439 static swig_type_info *swig_types[98];
1440
1441 /* -------- TYPES TABLE (END) -------- */
1442
1443
1444 /*-----------------------------------------------
1445               @(target):= _windows_.so
1446   ------------------------------------------------*/
1447 #define SWIG_init    init_windows_
1448
1449 #define SWIG_name    "_windows_"
1450
1451 #include "wx/wxPython/wxPython.h"
1452 #include "wx/wxPython/pyclasses.h"
1453
1454
1455  static const wxString wxPyEmptyString(wxEmptyString);
1456  static const wxString wxPyPanelNameStr(wxPanelNameStr);
1457
1458
1459
1460 #include <limits.h>
1461
1462
1463 SWIGINTERN int
1464   SWIG_CheckLongInRange(long value, long min_value, long max_value,
1465                         const char *errmsg)
1466 {
1467   if (value < min_value) {
1468     if (errmsg) {
1469       PyErr_Format(PyExc_OverflowError,
1470                    "value %ld is less than '%s' minimum %ld",
1471                    value, errmsg, min_value);
1472     }
1473     return 0;
1474   } else if (value > max_value) {
1475     if (errmsg) {
1476       PyErr_Format(PyExc_OverflowError,
1477                    "value %ld is greater than '%s' maximum %ld",
1478                    value, errmsg, max_value);
1479     }
1480     return 0;
1481   }
1482   return 1;
1483 }
1484
1485
1486 SWIGINTERN int
1487 SWIG_AsVal_long(PyObject* obj, long* val)
1488 {
1489     if (PyNumber_Check(obj)) {
1490         if (val) *val = PyInt_AsLong(obj);
1491         return 1;
1492     }
1493     else {
1494         SWIG_type_error("number", obj);
1495     }
1496     return 0;
1497 }
1498
1499
1500 #if INT_MAX != LONG_MAX
1501 SWIGINTERN int
1502   SWIG_AsVal_int(PyObject *obj, int *val)
1503 {
1504   const char* errmsg = val ? "int" : (char*)0;
1505   long v;
1506   if (SWIG_AsVal_long(obj, &v)) {
1507     if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1508       if (val) *val = (int)(v);
1509       return 1;
1510     } else {
1511       return 0;
1512     }
1513   } else {
1514     PyErr_Clear();
1515   }
1516   if (val) {
1517     SWIG_type_error(errmsg, obj);
1518   }
1519   return 0;
1520 }
1521 #else
1522 SWIGINTERNSHORT int
1523   SWIG_AsVal_int(PyObject *obj, int *val)
1524 {
1525   return SWIG_AsVal_long(obj,(long*)val);
1526 }
1527 #endif
1528
1529
1530 SWIGINTERNSHORT int
1531 SWIG_As_int(PyObject* obj)
1532 {
1533   int v;
1534   if (!SWIG_AsVal_int(obj, &v)) {
1535     /*
1536       this is needed to make valgrind/purify happier.
1537      */
1538     memset((void*)&v, 0, sizeof(int));
1539   }
1540   return v;
1541 }
1542
1543
1544 SWIGINTERNSHORT long
1545 SWIG_As_long(PyObject* obj)
1546 {
1547   long v;
1548   if (!SWIG_AsVal_long(obj, &v)) {
1549     /*
1550       this is needed to make valgrind/purify happier.
1551      */
1552     memset((void*)&v, 0, sizeof(long));
1553   }
1554   return v;
1555 }
1556
1557
1558 SWIGINTERNSHORT int
1559 SWIG_Check_int(PyObject* obj)
1560 {
1561   return SWIG_AsVal_int(obj, (int*)0);
1562 }
1563
1564
1565 SWIGINTERNSHORT int
1566 SWIG_Check_long(PyObject* obj)
1567 {
1568   return SWIG_AsVal_long(obj, (long*)0);
1569 }
1570
1571
1572 SWIGINTERN int
1573   SWIG_AsVal_bool(PyObject *obj, bool *val)
1574 {
1575   if (obj == Py_True) {
1576     if (val) *val = true;
1577     return 1;
1578   }
1579   if (obj == Py_False) {
1580     if (val) *val = false;
1581     return 1;
1582   }
1583   int res = 0;
1584   if (SWIG_AsVal_int(obj, &res)) {
1585     if (val) *val = res ? true : false;
1586     return 1;
1587   } else {
1588     PyErr_Clear();
1589   }
1590   if (val) {
1591     SWIG_type_error("bool", obj);
1592   }
1593   return 0;
1594 }
1595
1596
1597 SWIGINTERNSHORT bool
1598 SWIG_As_bool(PyObject* obj)
1599 {
1600   bool v;
1601   if (!SWIG_AsVal_bool(obj, &v)) {
1602     /*
1603       this is needed to make valgrind/purify happier.
1604      */
1605     memset((void*)&v, 0, sizeof(bool));
1606   }
1607   return v;
1608 }
1609
1610
1611 SWIGINTERNSHORT int
1612 SWIG_Check_bool(PyObject* obj)
1613 {
1614   return SWIG_AsVal_bool(obj, (bool*)0);
1615 }
1616
1617
1618   /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1619 #define SWIG_From_int PyInt_FromLong
1620 /*@@*/
1621
1622
1623   static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1624     PyObject*   o2;
1625     PyObject*   o3;
1626
1627     if (!target) {
1628         target = o;
1629     } else if (target == Py_None) {
1630         Py_DECREF(Py_None);
1631         target = o;
1632     } else {
1633         if (!PyTuple_Check(target)) {
1634             o2 = target;
1635             target = PyTuple_New(1);
1636             PyTuple_SetItem(target, 0, o2);
1637         }
1638         o3 = PyTuple_New(1);
1639         PyTuple_SetItem(o3, 0, o);
1640
1641         o2 = target;
1642         target = PySequence_Concat(o2, o3);
1643         Py_DECREF(o2);
1644         Py_DECREF(o3);
1645     }
1646     return target;
1647   }
1648
1649
1650
1651 SWIGINTERN int
1652 SWIG_AsVal_double(PyObject *obj, double* val)
1653 {
1654     if (PyNumber_Check(obj)) {
1655         if (val) *val = PyFloat_AsDouble(obj);
1656         return 1;
1657     }
1658     else {
1659         SWIG_type_error("number", obj);
1660     }
1661     return 0;
1662 }
1663
1664
1665 SWIGINTERNSHORT double
1666 SWIG_As_double(PyObject* obj)
1667 {
1668   double v;
1669   if (!SWIG_AsVal_double(obj, &v)) {
1670     /*
1671       this is needed to make valgrind/purify happier.
1672      */
1673     memset((void*)&v, 0, sizeof(double));
1674   }
1675   return v;
1676 }
1677
1678
1679 SWIGINTERNSHORT int
1680 SWIG_Check_double(PyObject* obj)
1681 {
1682   return SWIG_AsVal_double(obj, (double*)0);
1683 }
1684
1685
1686   /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1687 #define SWIG_From_double PyFloat_FromDouble
1688 /*@@*/
1689
1690  static const wxString wxPyFrameNameStr(wxFrameNameStr);
1691  static const wxString wxPyDialogNameStr(wxDialogNameStr);
1692  static const wxString wxPyStatusLineNameStr(wxStatusLineNameStr);
1693  static const wxString wxPyToolBarNameStr(wxToolBarNameStr);
1694
1695   /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1696 #define SWIG_From_long PyInt_FromLong
1697 /*@@*/
1698
1699
1700
1701 static wxRect wxStatusBar_GetFieldRect(wxStatusBar *self,int i){
1702             wxRect r;
1703             self->GetFieldRect(i, r);
1704             return r;
1705         }
1706  static const wxString wxPySplitterNameStr(wxT("splitter"));
1707  static const wxString wxPySashNameStr(wxT("sashWindow"));
1708  static const wxString wxPySashLayoutNameStr(wxT("layoutWindow"));
1709
1710 #include <wx/popupwin.h>
1711
1712
1713 class wxPopupWindow : public wxWindow {
1714 public:
1715     wxPopupWindow(wxWindow *, int)  { wxPyRaiseNotImplemented(); }
1716     wxPopupWindow()                 { wxPyRaiseNotImplemented(); }
1717 };
1718
1719 class wxPyPopupTransientWindow : public wxPopupWindow
1720 {
1721 public:
1722     wxPyPopupTransientWindow(wxWindow *, int)  { wxPyRaiseNotImplemented(); }
1723     wxPyPopupTransientWindow()                 { wxPyRaiseNotImplemented(); }
1724 };
1725
1726
1727 #include <wx/tipwin.h>
1728
1729 static wxTipWindow *new_wxTipWindow(wxWindow *parent,wxString const &text,int maxLength=100,wxRect *rectBound=NULL){
1730             return new wxTipWindow(parent, text, maxLength, NULL, rectBound);
1731         }
1732
1733 #include <wx/tipwin.h>
1734
1735
1736 #include <wx/vscroll.h>
1737
1738
1739 class wxPyVScrolledWindow  : public wxVScrolledWindow
1740 {
1741     DECLARE_ABSTRACT_CLASS(wxPyVScrolledWindow);
1742 public:
1743     wxPyVScrolledWindow() : wxVScrolledWindow() {}
1744
1745     wxPyVScrolledWindow(wxWindow *parent,
1746                         wxWindowID id = wxID_ANY,
1747                         const wxPoint& pos = wxDefaultPosition,
1748                         const wxSize& size = wxDefaultSize,
1749                         long style = 0,
1750                         const wxString& name = wxPyPanelNameStr)
1751         : wxVScrolledWindow(parent, id, pos, size, style, name)
1752     {}
1753
1754     // Overridable virtuals
1755
1756     // this function must be overridden in the derived class and it should
1757     // return the height of the given line in pixels
1758     DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetLineHeight);
1759
1760
1761     // this function doesn't have to be overridden but it may be useful to do
1762     // it if calculating the lines heights is a relatively expensive operation
1763     // as it gives the user code a possibility to calculate several of them at
1764     // once
1765     //
1766     // OnGetLinesHint() is normally called just before OnGetLineHeight() but you
1767     // shouldn't rely on the latter being called for all lines in the interval
1768     // specified here. It is also possible that OnGetLineHeight() will be
1769     // called for the lines outside of this interval, so this is really just a
1770     // hint, not a promise.
1771     //
1772     // finally note that lineMin is inclusive, while lineMax is exclusive, as
1773     // usual
1774     DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetLinesHint);
1775
1776
1777     // when the number of lines changes, we try to estimate the total height
1778     // of all lines which is a rather expensive operation in terms of lines
1779     // access, so if the user code may estimate the average height
1780     // better/faster than we do, it should override this function to implement
1781     // its own logic
1782     //
1783     // this function should return the best guess for the total height it may
1784     // make
1785     DEC_PYCALLBACK_COORD_const(EstimateTotalHeight);
1786
1787
1788     // Also expose some other interesting protected methods
1789
1790
1791     // find the index of the line we need to show at the top of the window such
1792     // that the last (fully or partially) visible line is the given one
1793     size_t FindFirstFromBottom(size_t lineLast, bool fullyVisible = false)
1794     { return wxVScrolledWindow::FindFirstFromBottom(lineLast, fullyVisible); }
1795
1796     // get the total height of the lines between lineMin (inclusive) and
1797     // lineMax (exclusive)
1798     wxCoord GetLinesHeight(size_t lineMin, size_t lineMax) const
1799     { return wxVScrolledWindow::GetLinesHeight(lineMin, lineMax); }
1800
1801
1802     PYPRIVATE;
1803 };
1804
1805 IMPLEMENT_ABSTRACT_CLASS(wxPyVScrolledWindow, wxVScrolledWindow);
1806
1807 IMP_PYCALLBACK_COORD_SIZET_constpure(wxPyVScrolledWindow, wxVScrolledWindow, OnGetLineHeight);
1808 IMP_PYCALLBACK_VOID_SIZETSIZET_const(wxPyVScrolledWindow, wxVScrolledWindow, OnGetLinesHint);
1809 IMP_PYCALLBACK_COORD_const          (wxPyVScrolledWindow, wxVScrolledWindow, EstimateTotalHeight);
1810
1811
1812 SWIGINTERN int
1813 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1814 {
1815     long v = 0;
1816     if (SWIG_AsVal_long(obj, &v) && v < 0) {
1817         SWIG_type_error("unsigned number", obj);
1818     }
1819     else if (val)
1820         *val = (unsigned long)v;
1821     return 1;
1822 }
1823
1824
1825 SWIGINTERNSHORT unsigned long
1826 SWIG_As_unsigned_SS_long(PyObject* obj)
1827 {
1828   unsigned long v;
1829   if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1830     /*
1831       this is needed to make valgrind/purify happier.
1832      */
1833     memset((void*)&v, 0, sizeof(unsigned long));
1834   }
1835   return v;
1836 }
1837
1838
1839 SWIGINTERNSHORT int
1840 SWIG_Check_unsigned_SS_long(PyObject* obj)
1841 {
1842   return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1843 }
1844
1845
1846 SWIGINTERNSHORT PyObject*
1847   SWIG_From_unsigned_SS_long(unsigned long value)
1848 {
1849   return (value > LONG_MAX) ?
1850     PyLong_FromUnsignedLong(value)
1851     : PyInt_FromLong((long)(value));
1852 }
1853
1854
1855 #include <wx/vlbox.h>
1856
1857  static const wxString wxPyVListBoxNameStr(wxVListBoxNameStr);
1858
1859 class wxPyVListBox  : public wxVListBox
1860 {
1861     DECLARE_ABSTRACT_CLASS(wxPyVListBox);
1862 public:
1863     wxPyVListBox() : wxVListBox() {}
1864
1865     wxPyVListBox(wxWindow *parent,
1866                  wxWindowID id = wxID_ANY,
1867                  const wxPoint& pos = wxDefaultPosition,
1868                  const wxSize& size = wxDefaultSize,
1869                  long style = 0,
1870                  const wxString& name = wxPyVListBoxNameStr)
1871         : wxVListBox(parent, id, pos, size, style, name)
1872     {}
1873
1874     // Overridable virtuals
1875
1876     // the derived class must implement this function to actually draw the item
1877     // with the given index on the provided DC
1878     // virtual void OnDrawItem(wxDC& dc, const wxRect& rect, size_t n) const = 0;
1879     DEC_PYCALLBACK__DCRECTSIZET_constpure(OnDrawItem);
1880
1881
1882     // the derived class must implement this method to return the height of the
1883     // specified item
1884     // virtual wxCoord OnMeasureItem(size_t n) const = 0;
1885     DEC_PYCALLBACK_COORD_SIZET_constpure(OnMeasureItem);
1886
1887
1888     // this method may be used to draw separators between the lines; note that
1889     // the rectangle may be modified, typically to deflate it a bit before
1890     // passing to OnDrawItem()
1891     //
1892     // the base class version doesn't do anything
1893     //    virtual void OnDrawSeparator(wxDC& dc, wxRect& rect, size_t n) const;
1894     DEC_PYCALLBACK__DCRECTSIZET_constpure(OnDrawSeparator);
1895
1896
1897     // this method is used to draw the items background and, maybe, a border
1898     // around it
1899     //
1900     // the base class version implements a reasonable default behaviour which
1901     // consists in drawing the selected item with the standard background
1902     // colour and drawing a border around the item if it is either selected or
1903     // current
1904     //     virtual void OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const;
1905     DEC_PYCALLBACK__DCRECTSIZET_const(OnDrawBackground);
1906
1907
1908     PYPRIVATE;
1909 };
1910
1911 IMPLEMENT_ABSTRACT_CLASS(wxPyVListBox, wxVListBox);
1912
1913 IMP_PYCALLBACK__DCRECTSIZET_constpure(wxPyVListBox, wxVListBox, OnDrawItem);
1914 IMP_PYCALLBACK_COORD_SIZET_constpure (wxPyVListBox, wxVListBox, OnMeasureItem);
1915 IMP_PYCALLBACK__DCRECTSIZET_constpure(wxPyVListBox, wxVListBox, OnDrawSeparator);
1916 IMP_PYCALLBACK__DCRECTSIZET_const    (wxPyVListBox, wxVListBox, OnDrawBackground);
1917
1918
1919 static PyObject *wxPyVListBox_GetFirstSelected(wxPyVListBox *self){
1920             unsigned long cookie = 0;
1921             int selected = self->GetFirstSelected(cookie);
1922             wxPyBlock_t blocked = wxPyBeginBlockThreads();
1923             PyObject* tup = PyTuple_New(2);
1924             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(selected));
1925             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(cookie));
1926             wxPyEndBlockThreads(blocked);
1927             return tup;
1928         }
1929 static PyObject *wxPyVListBox_GetNextSelected(wxPyVListBox *self,unsigned long cookie){
1930             int selected = self->GetNextSelected(cookie);
1931             wxPyBlock_t blocked = wxPyBeginBlockThreads();
1932             PyObject* tup = PyTuple_New(2);
1933             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(selected));
1934             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(cookie));
1935             wxPyEndBlockThreads(blocked);
1936             return tup;
1937         }
1938
1939 #include <wx/htmllbox.h>
1940
1941
1942 class wxPyHtmlListBox  : public wxHtmlListBox
1943 {
1944     DECLARE_ABSTRACT_CLASS(wxPyHtmlListBox);
1945 public:
1946     wxPyHtmlListBox() : wxHtmlListBox() {}
1947
1948     wxPyHtmlListBox(wxWindow *parent,
1949                     wxWindowID id = wxID_ANY,
1950                     const wxPoint& pos = wxDefaultPosition,
1951                     const wxSize& size = wxDefaultSize,
1952                     long style = 0,
1953                     const wxString& name = wxPyVListBoxNameStr)
1954         : wxHtmlListBox(parent, id, pos, size, style, name)
1955     {}
1956
1957     // Overridable virtuals
1958
1959     // this method must be implemented in the derived class and should return
1960     // the body (i.e. without <html>) of the HTML for the given item
1961     DEC_PYCALLBACK_STRING_SIZET_pure(OnGetItem);
1962
1963     // this function may be overridden to decorate HTML returned by OnGetItem()
1964     DEC_PYCALLBACK_STRING_SIZET(OnGetItemMarkup);
1965
1966 // TODO:
1967 //     // this method allows to customize the selection appearance: it may be used
1968 //     // to specify the colour of the text which normally has the given colour
1969 //     // colFg when it is inside the selection
1970 //     //
1971 //     // by default, the original colour is not used at all and all text has the
1972 //     // same (default for this system) colour inside selection
1973 //     virtual wxColour GetSelectedTextColour(const wxColour& colFg) const;
1974
1975 //     // this is the same as GetSelectedTextColour() but allows to customize the
1976 //     // background colour -- this is even more rarely used as you can change it
1977 //     // globally using SetSelectionBackground()
1978 //     virtual wxColour GetSelectedTextBgColour(const wxColour& colBg) const;
1979
1980
1981     PYPRIVATE;
1982 };
1983
1984
1985 IMPLEMENT_ABSTRACT_CLASS(wxPyHtmlListBox, wxHtmlListBox)
1986
1987 IMP_PYCALLBACK_STRING_SIZET_pure(wxPyHtmlListBox, wxHtmlListBox, OnGetItem);
1988 IMP_PYCALLBACK_STRING_SIZET     (wxPyHtmlListBox, wxHtmlListBox, OnGetItemMarkup);
1989
1990
1991
1992
1993
1994 #ifndef wxHAS_TASK_BAR_ICON
1995 // implement dummy classes for platforms that don't have it
1996
1997 class wxTaskBarIcon : public wxEvtHandler
1998 {
1999 public:
2000     wxTaskBarIcon()  { wxPyRaiseNotImplemented(); }
2001 };
2002
2003
2004 class wxTaskBarIconEvent : public wxEvent
2005 {
2006 public:
2007     wxTaskBarIconEvent(wxEventType, wxTaskBarIcon *)
2008         { wxPyRaiseNotImplemented(); }
2009     virtual wxEvent* Clone() const { return NULL; }
2010     bool IsOk() const { return false; }
2011     bool IsIconInstalled() const { return false; }
2012     bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxPyEmptyString) { return false; }
2013     bool RemoveIcon() { return false; }
2014     bool PopupMenu(wxMenu *menu) { return false; }
2015 };
2016
2017 enum {
2018     wxEVT_TASKBAR_MOVE = 0,
2019     wxEVT_TASKBAR_LEFT_DOWN = 0,
2020     wxEVT_TASKBAR_LEFT_UP = 0,
2021     wxEVT_TASKBAR_RIGHT_DOWN = 0,
2022     wxEVT_TASKBAR_RIGHT_UP = 0,
2023     wxEVT_TASKBAR_LEFT_DCLICK = 0,
2024     wxEVT_TASKBAR_RIGHT_DCLICK = 0,
2025 };
2026
2027
2028 #else
2029 // Otherwise make a class that can virtualize CreatePopupMenu
2030 class wxPyTaskBarIcon : public wxTaskBarIcon
2031 {
2032     DECLARE_ABSTRACT_CLASS(wxPyTaskBarIcon);
2033 public:
2034     wxPyTaskBarIcon() : wxTaskBarIcon()
2035     {}
2036
2037     wxMenu* CreatePopupMenu() {
2038         wxMenu *rval = NULL;
2039         bool found;
2040         wxPyBlock_t blocked = wxPyBeginBlockThreads();
2041         if ((found = wxPyCBH_findCallback(m_myInst, "CreatePopupMenu"))) {
2042             PyObject* ro;
2043             wxMenu* ptr;
2044             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2045             if (ro) {
2046                 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxMenu")))
2047                     rval = ptr;
2048                 Py_DECREF(ro);
2049             }
2050         }
2051         wxPyEndBlockThreads(blocked);
2052         if (! found)
2053             rval = wxTaskBarIcon::CreatePopupMenu();
2054         return rval;
2055     }
2056
2057     PYPRIVATE;
2058 };
2059
2060 IMPLEMENT_ABSTRACT_CLASS(wxPyTaskBarIcon, wxTaskBarIcon);
2061
2062 #endif
2063
2064 static void wxPyTaskBarIcon_Destroy(wxPyTaskBarIcon *self){
2065             self->RemoveIcon();
2066             delete self;
2067         }
2068  static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2069  static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2070  static const wxString wxPyDirDialogNameStr(wxDirDialogNameStr);
2071  static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2072  static const wxString wxPyGetTextFromUserPromptStr(wxGetTextFromUserPromptStr);
2073  static const wxString wxPyMessageBoxCaptionStr(wxMessageBoxCaptionStr);
2074 static PyObject *wxFileDialog_GetFilenames(wxFileDialog *self){
2075             wxArrayString arr;
2076             self->GetFilenames(arr);
2077             return wxArrayString2PyList_helper(arr);
2078         }
2079 static PyObject *wxFileDialog_GetPaths(wxFileDialog *self){
2080             wxArrayString arr;
2081             self->GetPaths(arr);
2082             return wxArrayString2PyList_helper(arr);
2083         }
2084 static PyObject *wxMultiChoiceDialog_GetSelections(wxMultiChoiceDialog *self){
2085             return wxArrayInt2PyList_helper(self->GetSelections());
2086         }
2087 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){
2088             return new wxSingleChoiceDialog(parent, message, caption,
2089                                             choices, choices_array, NULL, style, pos);
2090         }
2091  static const wxString wxPyGetPasswordFromUserPromptStr(wxGetPasswordFromUserPromptStr);
2092
2093 #include <wx/mdi.h>
2094
2095  // C++ version of Python aware wxWindow
2096 class wxPyWindow : public wxWindow
2097 {
2098     DECLARE_DYNAMIC_CLASS(wxPyWindow)
2099 public:
2100     wxPyWindow() : wxWindow() {}
2101     wxPyWindow(wxWindow* parent, const wxWindowID id,
2102                const wxPoint& pos = wxDefaultPosition,
2103                const wxSize& size = wxDefaultSize,
2104                long style = 0,
2105                const wxString& name = wxPyPanelNameStr)
2106         : wxWindow(parent, id, pos, size, style, name) {}
2107
2108     void SetBestSize(const wxSize& size) { wxWindow::SetBestSize(size); }
2109
2110     bool DoEraseBackground(wxDC* dc) {
2111 #ifdef __WXMSW__
2112         return wxWindow::DoEraseBackground(dc->GetHDC());
2113 #else
2114         dc->SetBackground(wxBrush(GetBackgroundColour()));
2115         dc->Clear();
2116         return true;
2117 #endif
2118     }
2119
2120     DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
2121     DEC_PYCALLBACK_VOID_INT5(DoSetSize);
2122     DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
2123     DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
2124
2125     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
2126     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
2127     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
2128
2129     DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
2130     DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
2131
2132     DEC_PYCALLBACK__(InitDialog);
2133     DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
2134     DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
2135     DEC_PYCALLBACK_BOOL_(Validate);
2136
2137     DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
2138     DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
2139     DEC_PYCALLBACK_SIZE_const(GetMaxSize);
2140
2141     DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
2142     DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
2143
2144     DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
2145     DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
2146
2147     DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
2148
2149     PYPRIVATE;
2150 };
2151
2152 IMPLEMENT_DYNAMIC_CLASS(wxPyWindow, wxWindow);
2153
2154 IMP_PYCALLBACK_VOID_INT4(wxPyWindow, wxWindow, DoMoveWindow);
2155 IMP_PYCALLBACK_VOID_INT5(wxPyWindow, wxWindow, DoSetSize);
2156 IMP_PYCALLBACK_VOID_INTINT(wxPyWindow, wxWindow, DoSetClientSize);
2157 IMP_PYCALLBACK_VOID_INTINT(wxPyWindow, wxWindow, DoSetVirtualSize);
2158
2159 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetSize);
2160 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetClientSize);
2161 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWindow, wxWindow, DoGetPosition);
2162
2163 IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetVirtualSize);
2164 IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, DoGetBestSize);
2165
2166 IMP_PYCALLBACK__(wxPyWindow, wxWindow, InitDialog);
2167 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, TransferDataFromWindow);
2168 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, TransferDataToWindow);
2169 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, Validate);
2170
2171 IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, AcceptsFocus);
2172 IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, AcceptsFocusFromKeyboard);
2173 IMP_PYCALLBACK_SIZE_const(wxPyWindow, wxWindow, GetMaxSize);
2174
2175 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWindow, wxWindow, AddChild);
2176 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWindow, wxWindow, RemoveChild);
2177
2178 IMP_PYCALLBACK_BOOL_const(wxPyWindow, wxWindow, ShouldInheritColours);
2179 IMP_PYCALLBACK_VIZATTR_(wxPyWindow, wxWindow, GetDefaultAttributes);
2180
2181 IMP_PYCALLBACK_BOOL_(wxPyWindow, wxWindow, HasTransparentBackground);
2182
2183  // C++ version of Python aware wxPanel
2184 class wxPyPanel : public wxPanel
2185 {
2186     DECLARE_DYNAMIC_CLASS(wxPyPanel)
2187 public:
2188     wxPyPanel() : wxPanel() {}
2189     wxPyPanel(wxWindow* parent, const wxWindowID id,
2190                const wxPoint& pos = wxDefaultPosition,
2191                const wxSize& size = wxDefaultSize,
2192                long style = 0,
2193                const wxString& name = wxPyPanelNameStr)
2194         : wxPanel(parent, id, pos, size, style, name) {}
2195
2196     void SetBestSize(const wxSize& size) { wxPanel::SetBestSize(size); }
2197     bool DoEraseBackground(wxDC* dc) {
2198 #ifdef __WXMSW__
2199         return wxWindow::DoEraseBackground(dc->GetHDC());
2200 #else
2201         dc->SetBackground(wxBrush(GetBackgroundColour()));
2202         dc->Clear();
2203         return true;
2204 #endif
2205     }
2206
2207
2208     DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
2209     DEC_PYCALLBACK_VOID_INT5(DoSetSize);
2210     DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
2211     DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
2212
2213     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
2214     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
2215     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
2216
2217     DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
2218     DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
2219
2220     DEC_PYCALLBACK__(InitDialog);
2221     DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
2222     DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
2223     DEC_PYCALLBACK_BOOL_(Validate);
2224
2225     DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
2226     DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
2227     DEC_PYCALLBACK_SIZE_const(GetMaxSize);
2228
2229     DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
2230     DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
2231
2232     DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
2233     DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
2234
2235     DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
2236
2237     PYPRIVATE;
2238 };
2239
2240 IMPLEMENT_DYNAMIC_CLASS(wxPyPanel, wxPanel);
2241
2242 IMP_PYCALLBACK_VOID_INT4(wxPyPanel, wxPanel, DoMoveWindow);
2243 IMP_PYCALLBACK_VOID_INT5(wxPyPanel, wxPanel, DoSetSize);
2244 IMP_PYCALLBACK_VOID_INTINT(wxPyPanel, wxPanel, DoSetClientSize);
2245 IMP_PYCALLBACK_VOID_INTINT(wxPyPanel, wxPanel, DoSetVirtualSize);
2246
2247 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyPanel, wxPanel, DoGetSize);
2248 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyPanel, wxPanel, DoGetClientSize);
2249 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyPanel, wxPanel, DoGetPosition);
2250
2251 IMP_PYCALLBACK_SIZE_const(wxPyPanel, wxPanel, DoGetVirtualSize);
2252 IMP_PYCALLBACK_SIZE_const(wxPyPanel, wxPanel, DoGetBestSize);
2253
2254 IMP_PYCALLBACK__(wxPyPanel, wxPanel, InitDialog);
2255 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, TransferDataFromWindow);
2256 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, TransferDataToWindow);
2257 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, Validate);
2258
2259 IMP_PYCALLBACK_BOOL_const(wxPyPanel, wxPanel, AcceptsFocus);
2260 IMP_PYCALLBACK_BOOL_const(wxPyPanel, wxPanel, AcceptsFocusFromKeyboard);
2261 IMP_PYCALLBACK_SIZE_const(wxPyPanel, wxPanel, GetMaxSize);
2262
2263 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyPanel, wxPanel, AddChild);
2264 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyPanel, wxPanel, RemoveChild);
2265
2266 IMP_PYCALLBACK_BOOL_const(wxPyPanel, wxPanel, ShouldInheritColours);
2267 IMP_PYCALLBACK_VIZATTR_(wxPyPanel, wxPanel, GetDefaultAttributes);
2268
2269 IMP_PYCALLBACK_BOOL_(wxPyPanel, wxPanel, HasTransparentBackground);
2270
2271  // C++ version of Python aware wxScrolledWindow
2272 class wxPyScrolledWindow : public wxScrolledWindow
2273 {
2274     DECLARE_DYNAMIC_CLASS(wxPyScrolledWindow)
2275 public:
2276     wxPyScrolledWindow() : wxScrolledWindow() {}
2277     wxPyScrolledWindow(wxWindow* parent, const wxWindowID id,
2278                const wxPoint& pos = wxDefaultPosition,
2279                const wxSize& size = wxDefaultSize,
2280                long style = 0,
2281                const wxString& name = wxPyPanelNameStr)
2282         : wxScrolledWindow(parent, id, pos, size, style, name) {}
2283
2284     void SetBestSize(const wxSize& size) { wxScrolledWindow::SetBestSize(size); }
2285     bool DoEraseBackground(wxDC* dc) {
2286 #ifdef __WXMSW__
2287         return wxWindow::DoEraseBackground(dc->GetHDC());
2288 #else
2289         dc->SetBackground(wxBrush(GetBackgroundColour()));
2290         dc->Clear();
2291         return true;
2292 #endif
2293     }
2294
2295     DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
2296     DEC_PYCALLBACK_VOID_INT5(DoSetSize);
2297     DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
2298     DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
2299
2300     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
2301     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
2302     DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
2303
2304     DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
2305     DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
2306
2307     DEC_PYCALLBACK__(InitDialog);
2308     DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
2309     DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
2310     DEC_PYCALLBACK_BOOL_(Validate);
2311
2312     DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
2313     DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
2314     DEC_PYCALLBACK_SIZE_const(GetMaxSize);
2315
2316     DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
2317     DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
2318
2319     DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
2320     DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
2321
2322     DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
2323
2324     PYPRIVATE;
2325 };
2326
2327 IMPLEMENT_DYNAMIC_CLASS(wxPyScrolledWindow, wxScrolledWindow);
2328
2329 IMP_PYCALLBACK_VOID_INT4(wxPyScrolledWindow, wxScrolledWindow, DoMoveWindow);
2330 IMP_PYCALLBACK_VOID_INT5(wxPyScrolledWindow, wxScrolledWindow, DoSetSize);
2331 IMP_PYCALLBACK_VOID_INTINT(wxPyScrolledWindow, wxScrolledWindow, DoSetClientSize);
2332 IMP_PYCALLBACK_VOID_INTINT(wxPyScrolledWindow, wxScrolledWindow, DoSetVirtualSize);
2333
2334 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyScrolledWindow, wxScrolledWindow, DoGetSize);
2335 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyScrolledWindow, wxScrolledWindow, DoGetClientSize);
2336 IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyScrolledWindow, wxScrolledWindow, DoGetPosition);
2337
2338 IMP_PYCALLBACK_SIZE_const(wxPyScrolledWindow, wxScrolledWindow, DoGetVirtualSize);
2339 IMP_PYCALLBACK_SIZE_const(wxPyScrolledWindow, wxScrolledWindow, DoGetBestSize);
2340
2341 IMP_PYCALLBACK__(wxPyScrolledWindow, wxScrolledWindow, InitDialog);
2342 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, TransferDataFromWindow);
2343 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, TransferDataToWindow);
2344 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, Validate);
2345
2346 IMP_PYCALLBACK_BOOL_const(wxPyScrolledWindow, wxScrolledWindow, AcceptsFocus);
2347 IMP_PYCALLBACK_BOOL_const(wxPyScrolledWindow, wxScrolledWindow, AcceptsFocusFromKeyboard);
2348 IMP_PYCALLBACK_SIZE_const(wxPyScrolledWindow, wxScrolledWindow, GetMaxSize);
2349
2350 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyScrolledWindow, wxScrolledWindow, AddChild);
2351 IMP_PYCALLBACK_VOID_WXWINBASE(wxPyScrolledWindow, wxScrolledWindow, RemoveChild);
2352
2353 IMP_PYCALLBACK_BOOL_const(wxPyScrolledWindow, wxScrolledWindow, ShouldInheritColours);
2354 IMP_PYCALLBACK_VIZATTR_(wxPyScrolledWindow, wxScrolledWindow, GetDefaultAttributes);
2355
2356 IMP_PYCALLBACK_BOOL_(wxPyScrolledWindow, wxScrolledWindow, HasTransparentBackground);
2357
2358
2359 #include "wx/wxPython/printfw.h"
2360
2361
2362  static const wxString wxPyPrintoutTitleStr(wxT("Printout"));
2363  static const wxString wxPyPreviewCanvasNameStr(wxT("previewcanvas"));
2364 static PyObject *wxPrintData_GetPrivData(wxPrintData *self){
2365             PyObject* data;
2366             wxPyBlock_t blocked = wxPyBeginBlockThreads();
2367             data = PyString_FromStringAndSize(self->GetPrivData(),
2368                                               self->GetPrivDataLen());
2369             wxPyEndBlockThreads(blocked);
2370             return data;
2371         }
2372 static void wxPrintData_SetPrivData(wxPrintData *self,PyObject *data){
2373             if (! PyString_Check(data)) {
2374                 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2375                                                   "Expected string object"));
2376                 return /* NULL */ ;
2377             }
2378
2379             wxPyBlock_t blocked = wxPyBeginBlockThreads();
2380             self->SetPrivData(PyString_AS_STRING(data), PyString_GET_SIZE(data));
2381             wxPyEndBlockThreads(blocked);
2382         }
2383
2384
2385 IMPLEMENT_ABSTRACT_CLASS(wxPyPrintout, wxPrintout);
2386
2387 // Since this one would be tough and ugly to do with the Macros...
2388 void wxPyPrintout::GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo) {
2389     bool hadErr = false;
2390     bool found;
2391
2392     wxPyBlock_t blocked = wxPyBeginBlockThreads();
2393     if ((found = wxPyCBH_findCallback(m_myInst, "GetPageInfo"))) {
2394         PyObject* result = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2395         if (result && PyTuple_Check(result) && PyTuple_Size(result) == 4) {
2396             PyObject* val;
2397
2398             val = PyTuple_GetItem(result, 0);
2399             if (PyInt_Check(val))    *minPage = PyInt_AsLong(val);
2400             else hadErr = true;
2401
2402             val = PyTuple_GetItem(result, 1);
2403             if (PyInt_Check(val))    *maxPage = PyInt_AsLong(val);
2404             else hadErr = true;
2405
2406             val = PyTuple_GetItem(result, 2);
2407             if (PyInt_Check(val))    *pageFrom = PyInt_AsLong(val);
2408             else hadErr = true;
2409
2410             val = PyTuple_GetItem(result, 3);
2411             if (PyInt_Check(val))    *pageTo = PyInt_AsLong(val);
2412             else hadErr = true;
2413         }
2414         else
2415             hadErr = true;
2416
2417         if (hadErr) {
2418             PyErr_SetString(PyExc_TypeError, "GetPageInfo should return a tuple of 4 integers.");
2419             PyErr_Print();
2420         }
2421         Py_DECREF(result);
2422     }
2423     wxPyEndBlockThreads(blocked);
2424     if (! found)
2425         wxPrintout::GetPageInfo(minPage, maxPage, pageFrom, pageTo);
2426 }
2427
2428 void wxPyPrintout::base_GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo) {
2429     wxPrintout::GetPageInfo(minPage, maxPage, pageFrom, pageTo);
2430 }
2431
2432
2433 IMP_PYCALLBACK_BOOL_INTINT(wxPyPrintout, wxPrintout, OnBeginDocument);
2434 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnEndDocument);
2435 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnBeginPrinting);
2436 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnEndPrinting);
2437 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnPreparePrinting);
2438 IMP_PYCALLBACK_BOOL_INT_pure(wxPyPrintout, wxPrintout, OnPrintPage);
2439 IMP_PYCALLBACK_BOOL_INT(wxPyPrintout, wxPrintout, HasPage);
2440
2441
2442
2443
2444
2445 #define DEC_PYCALLBACK_BOOL_PREWINDC(CBNAME)                                            \
2446     bool CBNAME(wxPreviewCanvas* a, wxDC& b);                                           \
2447     bool base_##CBNAME(wxPreviewCanvas* a, wxDC& b)
2448
2449
2450 #define IMP_PYCALLBACK_BOOL_PREWINDC(CLASS, PCLASS, CBNAME)                             \
2451     bool CLASS::CBNAME(wxPreviewCanvas* a, wxDC& b) {                                   \
2452         bool rval=false;                                                                \
2453         bool found;                                                                     \
2454         wxPyBlock_t blocked = wxPyBeginBlockThreads();                                         \
2455         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
2456             PyObject* win = wxPyMake_wxObject(a,false);                                 \
2457             PyObject* dc  = wxPyMake_wxObject(&b,false);                                \
2458             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", win, dc));      \
2459             Py_DECREF(win);                                                             \
2460             Py_DECREF(dc);                                                              \
2461         }                                                                               \
2462         wxPyEndBlockThreads(blocked);                                                   \
2463         if (! found)                                                                    \
2464             rval = PCLASS::CBNAME(a, b);                                                \
2465         return rval;                                                                    \
2466     }                                                                                   \
2467     bool CLASS::base_##CBNAME(wxPreviewCanvas* a, wxDC& b) {                            \
2468         return PCLASS::CBNAME(a, b);                                                    \
2469     }
2470
2471
2472
2473
2474 class wxPyPrintPreview : public wxPrintPreview
2475 {
2476     DECLARE_CLASS(wxPyPrintPreview)
2477 public:
2478     wxPyPrintPreview(wxPyPrintout* printout,
2479                      wxPyPrintout* printoutForPrinting,
2480                      wxPrintDialogData* data=NULL)
2481         : wxPrintPreview(printout, printoutForPrinting, data)
2482     {}
2483     wxPyPrintPreview(wxPyPrintout* printout,
2484                      wxPyPrintout* printoutForPrinting,
2485                      wxPrintData* data=NULL)
2486         : wxPrintPreview(printout, printoutForPrinting, data)
2487     {}
2488
2489     DEC_PYCALLBACK_BOOL_INT(SetCurrentPage);
2490     DEC_PYCALLBACK_BOOL_PREWINDC(PaintPage);
2491     DEC_PYCALLBACK_BOOL_PREWINDC(DrawBlankPage);
2492     DEC_PYCALLBACK_BOOL_INT(RenderPage);
2493     DEC_PYCALLBACK_VOID_INT(SetZoom);
2494     DEC_PYCALLBACK_BOOL_BOOL(Print);
2495     DEC_PYCALLBACK_VOID_(DetermineScaling);
2496
2497     PYPRIVATE;
2498 };
2499
2500 // Stupid renamed classes...  Fix this in 2.5...
2501 #if defined(__WXMSW__)
2502 IMPLEMENT_CLASS( wxPyPrintPreview, wxWindowsPrintPreview );
2503 #elif defined(__WXMAC__)
2504 IMPLEMENT_CLASS( wxPyPrintPreview, wxMacPrintPreview );
2505 #else
2506 IMPLEMENT_CLASS( wxPyPrintPreview, wxPostScriptPrintPreview );
2507 #endif
2508
2509 IMP_PYCALLBACK_BOOL_INT     (wxPyPrintPreview, wxPrintPreview, SetCurrentPage);
2510 IMP_PYCALLBACK_BOOL_PREWINDC(wxPyPrintPreview, wxPrintPreview, PaintPage);
2511 IMP_PYCALLBACK_BOOL_PREWINDC(wxPyPrintPreview, wxPrintPreview, DrawBlankPage);
2512 IMP_PYCALLBACK_BOOL_INT     (wxPyPrintPreview, wxPrintPreview, RenderPage);
2513 IMP_PYCALLBACK_VOID_INT     (wxPyPrintPreview, wxPrintPreview, SetZoom);
2514 IMP_PYCALLBACK_BOOL_BOOL    (wxPyPrintPreview, wxPrintPreview, Print);
2515 IMP_PYCALLBACK_VOID_        (wxPyPrintPreview, wxPrintPreview, DetermineScaling);
2516
2517
2518 class wxPyPreviewFrame : public wxPreviewFrame
2519 {
2520     DECLARE_CLASS(wxPyPreviewFrame);
2521 public:
2522     wxPyPreviewFrame(wxPrintPreview* preview, wxFrame* parent,
2523                      const wxString& title,
2524                      const wxPoint& pos = wxDefaultPosition,
2525                      const wxSize&  size = wxDefaultSize,
2526                      long style = wxDEFAULT_FRAME_STYLE,
2527                      const wxString& name = wxPyFrameNameStr)
2528         : wxPreviewFrame(preview, parent, title, pos, size, style, name)
2529     {}
2530
2531     void SetPreviewCanvas(wxPreviewCanvas* canvas) { m_previewCanvas = canvas; }
2532     void SetControlBar(wxPreviewControlBar* bar) { m_controlBar = bar; }
2533
2534     DEC_PYCALLBACK_VOID_(Initialize);
2535     DEC_PYCALLBACK_VOID_(CreateCanvas);
2536     DEC_PYCALLBACK_VOID_(CreateControlBar);
2537
2538     PYPRIVATE;
2539 };
2540
2541 IMPLEMENT_CLASS(wxPyPreviewFrame, wxPreviewFrame);
2542
2543 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, Initialize);
2544 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, CreateCanvas);
2545 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, CreateControlBar);
2546
2547
2548 class wxPyPreviewControlBar : public wxPreviewControlBar
2549 {
2550     DECLARE_CLASS(wxPyPreviewControlBar);
2551 public:
2552     wxPyPreviewControlBar(wxPrintPreview *preview,
2553                           long buttons,
2554                           wxWindow *parent,
2555                           const wxPoint& pos = wxDefaultPosition,
2556                           const wxSize& size = wxDefaultSize,
2557                           long style = 0,
2558                           const wxString& name = wxPyPanelNameStr)
2559         : wxPreviewControlBar(preview, buttons, parent, pos, size, style, name)
2560     {}
2561
2562     void SetPrintPreview(wxPrintPreview* preview) { m_printPreview = preview; }
2563
2564     DEC_PYCALLBACK_VOID_(CreateButtons);
2565     DEC_PYCALLBACK_VOID_INT(SetZoomControl);
2566
2567     PYPRIVATE;
2568 };
2569
2570 IMPLEMENT_CLASS(wxPyPreviewControlBar, wxPreviewControlBar);
2571 IMP_PYCALLBACK_VOID_(wxPyPreviewControlBar, wxPreviewControlBar, CreateButtons);
2572 IMP_PYCALLBACK_VOID_INT(wxPyPreviewControlBar, wxPreviewControlBar, SetZoomControl);
2573
2574 #ifdef __cplusplus
2575 extern "C" {
2576 #endif
2577 static PyObject *_wrap_new_Panel(PyObject *, PyObject *args, PyObject *kwargs) {
2578     PyObject *resultobj;
2579     wxWindow *arg1 = (wxWindow *) 0 ;
2580     int arg2 = (int) (int)-1 ;
2581     wxPoint const &arg3_defvalue = wxDefaultPosition ;
2582     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
2583     wxSize const &arg4_defvalue = wxDefaultSize ;
2584     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
2585     long arg5 = (long) wxTAB_TRAVERSAL|wxNO_BORDER ;
2586     wxString const &arg6_defvalue = wxPyPanelNameStr ;
2587     wxString *arg6 = (wxString *) &arg6_defvalue ;
2588     wxPanel *result;
2589     wxPoint temp3 ;
2590     wxSize temp4 ;
2591     bool temp6 = false ;
2592     PyObject * obj0 = 0 ;
2593     PyObject * obj1 = 0 ;
2594     PyObject * obj2 = 0 ;
2595     PyObject * obj3 = 0 ;
2596     PyObject * obj4 = 0 ;
2597     PyObject * obj5 = 0 ;
2598     char *kwnames[] = {
2599         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
2600     };
2601
2602     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Panel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2603     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2604     if (SWIG_arg_fail(1)) SWIG_fail;
2605     if (obj1) {
2606         {
2607             arg2 = (int const)(SWIG_As_int(obj1));
2608             if (SWIG_arg_fail(2)) SWIG_fail;
2609         }
2610     }
2611     if (obj2) {
2612         {
2613             arg3 = &temp3;
2614             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
2615         }
2616     }
2617     if (obj3) {
2618         {
2619             arg4 = &temp4;
2620             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
2621         }
2622     }
2623     if (obj4) {
2624         {
2625             arg5 = (long)(SWIG_As_long(obj4));
2626             if (SWIG_arg_fail(5)) SWIG_fail;
2627         }
2628     }
2629     if (obj5) {
2630         {
2631             arg6 = wxString_in_helper(obj5);
2632             if (arg6 == NULL) SWIG_fail;
2633             temp6 = true;
2634         }
2635     }
2636     {
2637         if (!wxPyCheckForApp()) SWIG_fail;
2638         PyThreadState* __tstate = wxPyBeginAllowThreads();
2639         result = (wxPanel *)new wxPanel(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
2640
2641         wxPyEndAllowThreads(__tstate);
2642         if (PyErr_Occurred()) SWIG_fail;
2643     }
2644     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPanel, 1);
2645     {
2646         if (temp6)
2647         delete arg6;
2648     }
2649     return resultobj;
2650     fail:
2651     {
2652         if (temp6)
2653         delete arg6;
2654     }
2655     return NULL;
2656 }
2657
2658
2659 static PyObject *_wrap_new_PrePanel(PyObject *, PyObject *args, PyObject *kwargs) {
2660     PyObject *resultobj;
2661     wxPanel *result;
2662     char *kwnames[] = {
2663         NULL
2664     };
2665
2666     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePanel",kwnames)) goto fail;
2667     {
2668         if (!wxPyCheckForApp()) SWIG_fail;
2669         PyThreadState* __tstate = wxPyBeginAllowThreads();
2670         result = (wxPanel *)new wxPanel();
2671
2672         wxPyEndAllowThreads(__tstate);
2673         if (PyErr_Occurred()) SWIG_fail;
2674     }
2675     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPanel, 1);
2676     return resultobj;
2677     fail:
2678     return NULL;
2679 }
2680
2681
2682 static PyObject *_wrap_Panel_Create(PyObject *, PyObject *args, PyObject *kwargs) {
2683     PyObject *resultobj;
2684     wxPanel *arg1 = (wxPanel *) 0 ;
2685     wxWindow *arg2 = (wxWindow *) 0 ;
2686     int arg3 = (int) (int)-1 ;
2687     wxPoint const &arg4_defvalue = wxDefaultPosition ;
2688     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
2689     wxSize const &arg5_defvalue = wxDefaultSize ;
2690     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
2691     long arg6 = (long) wxTAB_TRAVERSAL|wxNO_BORDER ;
2692     wxString const &arg7_defvalue = wxPyPanelNameStr ;
2693     wxString *arg7 = (wxString *) &arg7_defvalue ;
2694     bool result;
2695     wxPoint temp4 ;
2696     wxSize temp5 ;
2697     bool temp7 = false ;
2698     PyObject * obj0 = 0 ;
2699     PyObject * obj1 = 0 ;
2700     PyObject * obj2 = 0 ;
2701     PyObject * obj3 = 0 ;
2702     PyObject * obj4 = 0 ;
2703     PyObject * obj5 = 0 ;
2704     PyObject * obj6 = 0 ;
2705     char *kwnames[] = {
2706         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
2707     };
2708
2709     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Panel_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2710     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2711     if (SWIG_arg_fail(1)) SWIG_fail;
2712     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2713     if (SWIG_arg_fail(2)) SWIG_fail;
2714     if (obj2) {
2715         {
2716             arg3 = (int const)(SWIG_As_int(obj2));
2717             if (SWIG_arg_fail(3)) SWIG_fail;
2718         }
2719     }
2720     if (obj3) {
2721         {
2722             arg4 = &temp4;
2723             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
2724         }
2725     }
2726     if (obj4) {
2727         {
2728             arg5 = &temp5;
2729             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
2730         }
2731     }
2732     if (obj5) {
2733         {
2734             arg6 = (long)(SWIG_As_long(obj5));
2735             if (SWIG_arg_fail(6)) SWIG_fail;
2736         }
2737     }
2738     if (obj6) {
2739         {
2740             arg7 = wxString_in_helper(obj6);
2741             if (arg7 == NULL) SWIG_fail;
2742             temp7 = true;
2743         }
2744     }
2745     {
2746         PyThreadState* __tstate = wxPyBeginAllowThreads();
2747         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
2748
2749         wxPyEndAllowThreads(__tstate);
2750         if (PyErr_Occurred()) SWIG_fail;
2751     }
2752     {
2753         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2754     }
2755     {
2756         if (temp7)
2757         delete arg7;
2758     }
2759     return resultobj;
2760     fail:
2761     {
2762         if (temp7)
2763         delete arg7;
2764     }
2765     return NULL;
2766 }
2767
2768
2769 static PyObject *_wrap_Panel_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
2770     PyObject *resultobj;
2771     wxPanel *arg1 = (wxPanel *) 0 ;
2772     PyObject * obj0 = 0 ;
2773     char *kwnames[] = {
2774         (char *) "self", NULL
2775     };
2776
2777     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Panel_InitDialog",kwnames,&obj0)) goto fail;
2778     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2779     if (SWIG_arg_fail(1)) SWIG_fail;
2780     {
2781         PyThreadState* __tstate = wxPyBeginAllowThreads();
2782         (arg1)->InitDialog();
2783
2784         wxPyEndAllowThreads(__tstate);
2785         if (PyErr_Occurred()) SWIG_fail;
2786     }
2787     Py_INCREF(Py_None); resultobj = Py_None;
2788     return resultobj;
2789     fail:
2790     return NULL;
2791 }
2792
2793
2794 static PyObject *_wrap_Panel_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
2795     PyObject *resultobj;
2796     wxPanel *arg1 = (wxPanel *) 0 ;
2797     PyObject * obj0 = 0 ;
2798     char *kwnames[] = {
2799         (char *) "self", NULL
2800     };
2801
2802     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Panel_SetFocus",kwnames,&obj0)) goto fail;
2803     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2804     if (SWIG_arg_fail(1)) SWIG_fail;
2805     {
2806         PyThreadState* __tstate = wxPyBeginAllowThreads();
2807         (arg1)->SetFocus();
2808
2809         wxPyEndAllowThreads(__tstate);
2810         if (PyErr_Occurred()) SWIG_fail;
2811     }
2812     Py_INCREF(Py_None); resultobj = Py_None;
2813     return resultobj;
2814     fail:
2815     return NULL;
2816 }
2817
2818
2819 static PyObject *_wrap_Panel_SetFocusIgnoringChildren(PyObject *, PyObject *args, PyObject *kwargs) {
2820     PyObject *resultobj;
2821     wxPanel *arg1 = (wxPanel *) 0 ;
2822     PyObject * obj0 = 0 ;
2823     char *kwnames[] = {
2824         (char *) "self", NULL
2825     };
2826
2827     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Panel_SetFocusIgnoringChildren",kwnames,&obj0)) goto fail;
2828     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPanel, SWIG_POINTER_EXCEPTION | 0);
2829     if (SWIG_arg_fail(1)) SWIG_fail;
2830     {
2831         PyThreadState* __tstate = wxPyBeginAllowThreads();
2832         (arg1)->SetFocusIgnoringChildren();
2833
2834         wxPyEndAllowThreads(__tstate);
2835         if (PyErr_Occurred()) SWIG_fail;
2836     }
2837     Py_INCREF(Py_None); resultobj = Py_None;
2838     return resultobj;
2839     fail:
2840     return NULL;
2841 }
2842
2843
2844 static PyObject *_wrap_Panel_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
2845     PyObject *resultobj;
2846     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
2847     wxVisualAttributes result;
2848     PyObject * obj0 = 0 ;
2849     char *kwnames[] = {
2850         (char *) "variant", NULL
2851     };
2852
2853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Panel_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
2854     if (obj0) {
2855         {
2856             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
2857             if (SWIG_arg_fail(1)) SWIG_fail;
2858         }
2859     }
2860     {
2861         if (!wxPyCheckForApp()) SWIG_fail;
2862         PyThreadState* __tstate = wxPyBeginAllowThreads();
2863         result = wxPanel::GetClassDefaultAttributes((wxWindowVariant )arg1);
2864
2865         wxPyEndAllowThreads(__tstate);
2866         if (PyErr_Occurred()) SWIG_fail;
2867     }
2868     {
2869         wxVisualAttributes * resultptr;
2870         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
2871         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
2872     }
2873     return resultobj;
2874     fail:
2875     return NULL;
2876 }
2877
2878
2879 static PyObject * Panel_swigregister(PyObject *, PyObject *args) {
2880     PyObject *obj;
2881     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2882     SWIG_TypeClientData(SWIGTYPE_p_wxPanel, obj);
2883     Py_INCREF(obj);
2884     return Py_BuildValue((char *)"");
2885 }
2886 static PyObject *_wrap_new_ScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
2887     PyObject *resultobj;
2888     wxWindow *arg1 = (wxWindow *) 0 ;
2889     int arg2 = (int) (int)-1 ;
2890     wxPoint const &arg3_defvalue = wxDefaultPosition ;
2891     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
2892     wxSize const &arg4_defvalue = wxDefaultSize ;
2893     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
2894     long arg5 = (long) wxHSCROLL|wxVSCROLL ;
2895     wxString const &arg6_defvalue = wxPyPanelNameStr ;
2896     wxString *arg6 = (wxString *) &arg6_defvalue ;
2897     wxScrolledWindow *result;
2898     wxPoint temp3 ;
2899     wxSize temp4 ;
2900     bool temp6 = false ;
2901     PyObject * obj0 = 0 ;
2902     PyObject * obj1 = 0 ;
2903     PyObject * obj2 = 0 ;
2904     PyObject * obj3 = 0 ;
2905     PyObject * obj4 = 0 ;
2906     PyObject * obj5 = 0 ;
2907     char *kwnames[] = {
2908         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
2909     };
2910
2911     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_ScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2912     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
2913     if (SWIG_arg_fail(1)) SWIG_fail;
2914     if (obj1) {
2915         {
2916             arg2 = (int const)(SWIG_As_int(obj1));
2917             if (SWIG_arg_fail(2)) SWIG_fail;
2918         }
2919     }
2920     if (obj2) {
2921         {
2922             arg3 = &temp3;
2923             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
2924         }
2925     }
2926     if (obj3) {
2927         {
2928             arg4 = &temp4;
2929             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
2930         }
2931     }
2932     if (obj4) {
2933         {
2934             arg5 = (long)(SWIG_As_long(obj4));
2935             if (SWIG_arg_fail(5)) SWIG_fail;
2936         }
2937     }
2938     if (obj5) {
2939         {
2940             arg6 = wxString_in_helper(obj5);
2941             if (arg6 == NULL) SWIG_fail;
2942             temp6 = true;
2943         }
2944     }
2945     {
2946         if (!wxPyCheckForApp()) SWIG_fail;
2947         PyThreadState* __tstate = wxPyBeginAllowThreads();
2948         result = (wxScrolledWindow *)new wxScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
2949
2950         wxPyEndAllowThreads(__tstate);
2951         if (PyErr_Occurred()) SWIG_fail;
2952     }
2953     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrolledWindow, 1);
2954     {
2955         if (temp6)
2956         delete arg6;
2957     }
2958     return resultobj;
2959     fail:
2960     {
2961         if (temp6)
2962         delete arg6;
2963     }
2964     return NULL;
2965 }
2966
2967
2968 static PyObject *_wrap_new_PreScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
2969     PyObject *resultobj;
2970     wxScrolledWindow *result;
2971     char *kwnames[] = {
2972         NULL
2973     };
2974
2975     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreScrolledWindow",kwnames)) goto fail;
2976     {
2977         if (!wxPyCheckForApp()) SWIG_fail;
2978         PyThreadState* __tstate = wxPyBeginAllowThreads();
2979         result = (wxScrolledWindow *)new wxScrolledWindow();
2980
2981         wxPyEndAllowThreads(__tstate);
2982         if (PyErr_Occurred()) SWIG_fail;
2983     }
2984     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrolledWindow, 1);
2985     return resultobj;
2986     fail:
2987     return NULL;
2988 }
2989
2990
2991 static PyObject *_wrap_ScrolledWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
2992     PyObject *resultobj;
2993     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
2994     wxWindow *arg2 = (wxWindow *) 0 ;
2995     int arg3 = (int) (int)-1 ;
2996     wxPoint const &arg4_defvalue = wxDefaultPosition ;
2997     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
2998     wxSize const &arg5_defvalue = wxDefaultSize ;
2999     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
3000     long arg6 = (long) wxHSCROLL|wxVSCROLL ;
3001     wxString const &arg7_defvalue = wxPyPanelNameStr ;
3002     wxString *arg7 = (wxString *) &arg7_defvalue ;
3003     bool result;
3004     wxPoint temp4 ;
3005     wxSize temp5 ;
3006     bool temp7 = false ;
3007     PyObject * obj0 = 0 ;
3008     PyObject * obj1 = 0 ;
3009     PyObject * obj2 = 0 ;
3010     PyObject * obj3 = 0 ;
3011     PyObject * obj4 = 0 ;
3012     PyObject * obj5 = 0 ;
3013     PyObject * obj6 = 0 ;
3014     char *kwnames[] = {
3015         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
3016     };
3017
3018     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:ScrolledWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3019     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3020     if (SWIG_arg_fail(1)) SWIG_fail;
3021     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3022     if (SWIG_arg_fail(2)) SWIG_fail;
3023     if (obj2) {
3024         {
3025             arg3 = (int const)(SWIG_As_int(obj2));
3026             if (SWIG_arg_fail(3)) SWIG_fail;
3027         }
3028     }
3029     if (obj3) {
3030         {
3031             arg4 = &temp4;
3032             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
3033         }
3034     }
3035     if (obj4) {
3036         {
3037             arg5 = &temp5;
3038             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
3039         }
3040     }
3041     if (obj5) {
3042         {
3043             arg6 = (long)(SWIG_As_long(obj5));
3044             if (SWIG_arg_fail(6)) SWIG_fail;
3045         }
3046     }
3047     if (obj6) {
3048         {
3049             arg7 = wxString_in_helper(obj6);
3050             if (arg7 == NULL) SWIG_fail;
3051             temp7 = true;
3052         }
3053     }
3054     {
3055         PyThreadState* __tstate = wxPyBeginAllowThreads();
3056         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
3057
3058         wxPyEndAllowThreads(__tstate);
3059         if (PyErr_Occurred()) SWIG_fail;
3060     }
3061     {
3062         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3063     }
3064     {
3065         if (temp7)
3066         delete arg7;
3067     }
3068     return resultobj;
3069     fail:
3070     {
3071         if (temp7)
3072         delete arg7;
3073     }
3074     return NULL;
3075 }
3076
3077
3078 static PyObject *_wrap_ScrolledWindow_SetScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
3079     PyObject *resultobj;
3080     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3081     int arg2 ;
3082     int arg3 ;
3083     int arg4 ;
3084     int arg5 ;
3085     int arg6 = (int) 0 ;
3086     int arg7 = (int) 0 ;
3087     bool arg8 = (bool) false ;
3088     PyObject * obj0 = 0 ;
3089     PyObject * obj1 = 0 ;
3090     PyObject * obj2 = 0 ;
3091     PyObject * obj3 = 0 ;
3092     PyObject * obj4 = 0 ;
3093     PyObject * obj5 = 0 ;
3094     PyObject * obj6 = 0 ;
3095     PyObject * obj7 = 0 ;
3096     char *kwnames[] = {
3097         (char *) "self",(char *) "pixelsPerUnitX",(char *) "pixelsPerUnitY",(char *) "noUnitsX",(char *) "noUnitsY",(char *) "xPos",(char *) "yPos",(char *) "noRefresh", NULL
3098     };
3099
3100     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:ScrolledWindow_SetScrollbars",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
3101     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3102     if (SWIG_arg_fail(1)) SWIG_fail;
3103     {
3104         arg2 = (int)(SWIG_As_int(obj1));
3105         if (SWIG_arg_fail(2)) SWIG_fail;
3106     }
3107     {
3108         arg3 = (int)(SWIG_As_int(obj2));
3109         if (SWIG_arg_fail(3)) SWIG_fail;
3110     }
3111     {
3112         arg4 = (int)(SWIG_As_int(obj3));
3113         if (SWIG_arg_fail(4)) SWIG_fail;
3114     }
3115     {
3116         arg5 = (int)(SWIG_As_int(obj4));
3117         if (SWIG_arg_fail(5)) SWIG_fail;
3118     }
3119     if (obj5) {
3120         {
3121             arg6 = (int)(SWIG_As_int(obj5));
3122             if (SWIG_arg_fail(6)) SWIG_fail;
3123         }
3124     }
3125     if (obj6) {
3126         {
3127             arg7 = (int)(SWIG_As_int(obj6));
3128             if (SWIG_arg_fail(7)) SWIG_fail;
3129         }
3130     }
3131     if (obj7) {
3132         {
3133             arg8 = (bool)(SWIG_As_bool(obj7));
3134             if (SWIG_arg_fail(8)) SWIG_fail;
3135         }
3136     }
3137     {
3138         PyThreadState* __tstate = wxPyBeginAllowThreads();
3139         (arg1)->SetScrollbars(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
3140
3141         wxPyEndAllowThreads(__tstate);
3142         if (PyErr_Occurred()) SWIG_fail;
3143     }
3144     Py_INCREF(Py_None); resultobj = Py_None;
3145     return resultobj;
3146     fail:
3147     return NULL;
3148 }
3149
3150
3151 static PyObject *_wrap_ScrolledWindow_Scroll(PyObject *, PyObject *args, PyObject *kwargs) {
3152     PyObject *resultobj;
3153     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3154     int arg2 ;
3155     int arg3 ;
3156     PyObject * obj0 = 0 ;
3157     PyObject * obj1 = 0 ;
3158     PyObject * obj2 = 0 ;
3159     char *kwnames[] = {
3160         (char *) "self",(char *) "x",(char *) "y", NULL
3161     };
3162
3163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_Scroll",kwnames,&obj0,&obj1,&obj2)) goto fail;
3164     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3165     if (SWIG_arg_fail(1)) SWIG_fail;
3166     {
3167         arg2 = (int)(SWIG_As_int(obj1));
3168         if (SWIG_arg_fail(2)) SWIG_fail;
3169     }
3170     {
3171         arg3 = (int)(SWIG_As_int(obj2));
3172         if (SWIG_arg_fail(3)) SWIG_fail;
3173     }
3174     {
3175         PyThreadState* __tstate = wxPyBeginAllowThreads();
3176         (arg1)->Scroll(arg2,arg3);
3177
3178         wxPyEndAllowThreads(__tstate);
3179         if (PyErr_Occurred()) SWIG_fail;
3180     }
3181     Py_INCREF(Py_None); resultobj = Py_None;
3182     return resultobj;
3183     fail:
3184     return NULL;
3185 }
3186
3187
3188 static PyObject *_wrap_ScrolledWindow_GetScrollPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
3189     PyObject *resultobj;
3190     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3191     int arg2 ;
3192     int result;
3193     PyObject * obj0 = 0 ;
3194     PyObject * obj1 = 0 ;
3195     char *kwnames[] = {
3196         (char *) "self",(char *) "orient", NULL
3197     };
3198
3199     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_GetScrollPageSize",kwnames,&obj0,&obj1)) goto fail;
3200     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3201     if (SWIG_arg_fail(1)) SWIG_fail;
3202     {
3203         arg2 = (int)(SWIG_As_int(obj1));
3204         if (SWIG_arg_fail(2)) SWIG_fail;
3205     }
3206     {
3207         PyThreadState* __tstate = wxPyBeginAllowThreads();
3208         result = (int)((wxScrolledWindow const *)arg1)->GetScrollPageSize(arg2);
3209
3210         wxPyEndAllowThreads(__tstate);
3211         if (PyErr_Occurred()) SWIG_fail;
3212     }
3213     {
3214         resultobj = SWIG_From_int((int)(result));
3215     }
3216     return resultobj;
3217     fail:
3218     return NULL;
3219 }
3220
3221
3222 static PyObject *_wrap_ScrolledWindow_SetScrollPageSize(PyObject *, PyObject *args, PyObject *kwargs) {
3223     PyObject *resultobj;
3224     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3225     int arg2 ;
3226     int arg3 ;
3227     PyObject * obj0 = 0 ;
3228     PyObject * obj1 = 0 ;
3229     PyObject * obj2 = 0 ;
3230     char *kwnames[] = {
3231         (char *) "self",(char *) "orient",(char *) "pageSize", NULL
3232     };
3233
3234     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_SetScrollPageSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
3235     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3236     if (SWIG_arg_fail(1)) SWIG_fail;
3237     {
3238         arg2 = (int)(SWIG_As_int(obj1));
3239         if (SWIG_arg_fail(2)) SWIG_fail;
3240     }
3241     {
3242         arg3 = (int)(SWIG_As_int(obj2));
3243         if (SWIG_arg_fail(3)) SWIG_fail;
3244     }
3245     {
3246         PyThreadState* __tstate = wxPyBeginAllowThreads();
3247         (arg1)->SetScrollPageSize(arg2,arg3);
3248
3249         wxPyEndAllowThreads(__tstate);
3250         if (PyErr_Occurred()) SWIG_fail;
3251     }
3252     Py_INCREF(Py_None); resultobj = Py_None;
3253     return resultobj;
3254     fail:
3255     return NULL;
3256 }
3257
3258
3259 static PyObject *_wrap_ScrolledWindow_SetScrollRate(PyObject *, PyObject *args, PyObject *kwargs) {
3260     PyObject *resultobj;
3261     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3262     int arg2 ;
3263     int arg3 ;
3264     PyObject * obj0 = 0 ;
3265     PyObject * obj1 = 0 ;
3266     PyObject * obj2 = 0 ;
3267     char *kwnames[] = {
3268         (char *) "self",(char *) "xstep",(char *) "ystep", NULL
3269     };
3270
3271     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_SetScrollRate",kwnames,&obj0,&obj1,&obj2)) goto fail;
3272     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3273     if (SWIG_arg_fail(1)) SWIG_fail;
3274     {
3275         arg2 = (int)(SWIG_As_int(obj1));
3276         if (SWIG_arg_fail(2)) SWIG_fail;
3277     }
3278     {
3279         arg3 = (int)(SWIG_As_int(obj2));
3280         if (SWIG_arg_fail(3)) SWIG_fail;
3281     }
3282     {
3283         PyThreadState* __tstate = wxPyBeginAllowThreads();
3284         (arg1)->SetScrollRate(arg2,arg3);
3285
3286         wxPyEndAllowThreads(__tstate);
3287         if (PyErr_Occurred()) SWIG_fail;
3288     }
3289     Py_INCREF(Py_None); resultobj = Py_None;
3290     return resultobj;
3291     fail:
3292     return NULL;
3293 }
3294
3295
3296 static PyObject *_wrap_ScrolledWindow_GetScrollPixelsPerUnit(PyObject *, PyObject *args, PyObject *kwargs) {
3297     PyObject *resultobj;
3298     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3299     int *arg2 = (int *) 0 ;
3300     int *arg3 = (int *) 0 ;
3301     int temp2 ;
3302     int res2 = 0 ;
3303     int temp3 ;
3304     int res3 = 0 ;
3305     PyObject * obj0 = 0 ;
3306     char *kwnames[] = {
3307         (char *) "self", NULL
3308     };
3309
3310     arg2 = &temp2; res2 = SWIG_NEWOBJ;
3311     arg3 = &temp3; res3 = SWIG_NEWOBJ;
3312     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetScrollPixelsPerUnit",kwnames,&obj0)) goto fail;
3313     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3314     if (SWIG_arg_fail(1)) SWIG_fail;
3315     {
3316         PyThreadState* __tstate = wxPyBeginAllowThreads();
3317         ((wxScrolledWindow const *)arg1)->GetScrollPixelsPerUnit(arg2,arg3);
3318
3319         wxPyEndAllowThreads(__tstate);
3320         if (PyErr_Occurred()) SWIG_fail;
3321     }
3322     Py_INCREF(Py_None); resultobj = Py_None;
3323     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3324     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3325     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
3326     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
3327     return resultobj;
3328     fail:
3329     return NULL;
3330 }
3331
3332
3333 static PyObject *_wrap_ScrolledWindow_EnableScrolling(PyObject *, PyObject *args, PyObject *kwargs) {
3334     PyObject *resultobj;
3335     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3336     bool arg2 ;
3337     bool arg3 ;
3338     PyObject * obj0 = 0 ;
3339     PyObject * obj1 = 0 ;
3340     PyObject * obj2 = 0 ;
3341     char *kwnames[] = {
3342         (char *) "self",(char *) "x_scrolling",(char *) "y_scrolling", NULL
3343     };
3344
3345     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_EnableScrolling",kwnames,&obj0,&obj1,&obj2)) goto fail;
3346     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3347     if (SWIG_arg_fail(1)) SWIG_fail;
3348     {
3349         arg2 = (bool)(SWIG_As_bool(obj1));
3350         if (SWIG_arg_fail(2)) SWIG_fail;
3351     }
3352     {
3353         arg3 = (bool)(SWIG_As_bool(obj2));
3354         if (SWIG_arg_fail(3)) SWIG_fail;
3355     }
3356     {
3357         PyThreadState* __tstate = wxPyBeginAllowThreads();
3358         (arg1)->EnableScrolling(arg2,arg3);
3359
3360         wxPyEndAllowThreads(__tstate);
3361         if (PyErr_Occurred()) SWIG_fail;
3362     }
3363     Py_INCREF(Py_None); resultobj = Py_None;
3364     return resultobj;
3365     fail:
3366     return NULL;
3367 }
3368
3369
3370 static PyObject *_wrap_ScrolledWindow_GetViewStart(PyObject *, PyObject *args, PyObject *kwargs) {
3371     PyObject *resultobj;
3372     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3373     int *arg2 = (int *) 0 ;
3374     int *arg3 = (int *) 0 ;
3375     int temp2 ;
3376     int res2 = 0 ;
3377     int temp3 ;
3378     int res3 = 0 ;
3379     PyObject * obj0 = 0 ;
3380     char *kwnames[] = {
3381         (char *) "self", NULL
3382     };
3383
3384     arg2 = &temp2; res2 = SWIG_NEWOBJ;
3385     arg3 = &temp3; res3 = SWIG_NEWOBJ;
3386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetViewStart",kwnames,&obj0)) goto fail;
3387     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3388     if (SWIG_arg_fail(1)) SWIG_fail;
3389     {
3390         PyThreadState* __tstate = wxPyBeginAllowThreads();
3391         ((wxScrolledWindow const *)arg1)->GetViewStart(arg2,arg3);
3392
3393         wxPyEndAllowThreads(__tstate);
3394         if (PyErr_Occurred()) SWIG_fail;
3395     }
3396     Py_INCREF(Py_None); resultobj = Py_None;
3397     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3398     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3399     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
3400     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
3401     return resultobj;
3402     fail:
3403     return NULL;
3404 }
3405
3406
3407 static PyObject *_wrap_ScrolledWindow_SetScale(PyObject *, PyObject *args, PyObject *kwargs) {
3408     PyObject *resultobj;
3409     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3410     double arg2 ;
3411     double arg3 ;
3412     PyObject * obj0 = 0 ;
3413     PyObject * obj1 = 0 ;
3414     PyObject * obj2 = 0 ;
3415     char *kwnames[] = {
3416         (char *) "self",(char *) "xs",(char *) "ys", NULL
3417     };
3418
3419     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ScrolledWindow_SetScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
3420     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3421     if (SWIG_arg_fail(1)) SWIG_fail;
3422     {
3423         arg2 = (double)(SWIG_As_double(obj1));
3424         if (SWIG_arg_fail(2)) SWIG_fail;
3425     }
3426     {
3427         arg3 = (double)(SWIG_As_double(obj2));
3428         if (SWIG_arg_fail(3)) SWIG_fail;
3429     }
3430     {
3431         PyThreadState* __tstate = wxPyBeginAllowThreads();
3432         (arg1)->SetScale(arg2,arg3);
3433
3434         wxPyEndAllowThreads(__tstate);
3435         if (PyErr_Occurred()) SWIG_fail;
3436     }
3437     Py_INCREF(Py_None); resultobj = Py_None;
3438     return resultobj;
3439     fail:
3440     return NULL;
3441 }
3442
3443
3444 static PyObject *_wrap_ScrolledWindow_GetScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
3445     PyObject *resultobj;
3446     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3447     double result;
3448     PyObject * obj0 = 0 ;
3449     char *kwnames[] = {
3450         (char *) "self", NULL
3451     };
3452
3453     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetScaleX",kwnames,&obj0)) goto fail;
3454     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3455     if (SWIG_arg_fail(1)) SWIG_fail;
3456     {
3457         PyThreadState* __tstate = wxPyBeginAllowThreads();
3458         result = (double)((wxScrolledWindow const *)arg1)->GetScaleX();
3459
3460         wxPyEndAllowThreads(__tstate);
3461         if (PyErr_Occurred()) SWIG_fail;
3462     }
3463     {
3464         resultobj = SWIG_From_double((double)(result));
3465     }
3466     return resultobj;
3467     fail:
3468     return NULL;
3469 }
3470
3471
3472 static PyObject *_wrap_ScrolledWindow_GetScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
3473     PyObject *resultobj;
3474     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3475     double result;
3476     PyObject * obj0 = 0 ;
3477     char *kwnames[] = {
3478         (char *) "self", NULL
3479     };
3480
3481     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetScaleY",kwnames,&obj0)) goto fail;
3482     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3483     if (SWIG_arg_fail(1)) SWIG_fail;
3484     {
3485         PyThreadState* __tstate = wxPyBeginAllowThreads();
3486         result = (double)((wxScrolledWindow const *)arg1)->GetScaleY();
3487
3488         wxPyEndAllowThreads(__tstate);
3489         if (PyErr_Occurred()) SWIG_fail;
3490     }
3491     {
3492         resultobj = SWIG_From_double((double)(result));
3493     }
3494     return resultobj;
3495     fail:
3496     return NULL;
3497 }
3498
3499
3500 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(PyObject *, PyObject *args) {
3501     PyObject *resultobj;
3502     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3503     wxPoint *arg2 = 0 ;
3504     wxPoint result;
3505     wxPoint temp2 ;
3506     PyObject * obj0 = 0 ;
3507     PyObject * obj1 = 0 ;
3508
3509     if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcScrolledPosition",&obj0,&obj1)) goto fail;
3510     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3511     if (SWIG_arg_fail(1)) SWIG_fail;
3512     {
3513         arg2 = &temp2;
3514         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
3515     }
3516     {
3517         PyThreadState* __tstate = wxPyBeginAllowThreads();
3518         result = ((wxScrolledWindow const *)arg1)->CalcScrolledPosition((wxPoint const &)*arg2);
3519
3520         wxPyEndAllowThreads(__tstate);
3521         if (PyErr_Occurred()) SWIG_fail;
3522     }
3523     {
3524         wxPoint * resultptr;
3525         resultptr = new wxPoint((wxPoint &)(result));
3526         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
3527     }
3528     return resultobj;
3529     fail:
3530     return NULL;
3531 }
3532
3533
3534 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(PyObject *, PyObject *args) {
3535     PyObject *resultobj;
3536     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3537     int arg2 ;
3538     int arg3 ;
3539     int *arg4 = (int *) 0 ;
3540     int *arg5 = (int *) 0 ;
3541     int temp4 ;
3542     int res4 = 0 ;
3543     int temp5 ;
3544     int res5 = 0 ;
3545     PyObject * obj0 = 0 ;
3546     PyObject * obj1 = 0 ;
3547     PyObject * obj2 = 0 ;
3548
3549     arg4 = &temp4; res4 = SWIG_NEWOBJ;
3550     arg5 = &temp5; res5 = SWIG_NEWOBJ;
3551     if(!PyArg_ParseTuple(args,(char *)"OOO:ScrolledWindow_CalcScrolledPosition",&obj0,&obj1,&obj2)) goto fail;
3552     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3553     if (SWIG_arg_fail(1)) SWIG_fail;
3554     {
3555         arg2 = (int)(SWIG_As_int(obj1));
3556         if (SWIG_arg_fail(2)) SWIG_fail;
3557     }
3558     {
3559         arg3 = (int)(SWIG_As_int(obj2));
3560         if (SWIG_arg_fail(3)) SWIG_fail;
3561     }
3562     {
3563         PyThreadState* __tstate = wxPyBeginAllowThreads();
3564         ((wxScrolledWindow const *)arg1)->CalcScrolledPosition(arg2,arg3,arg4,arg5);
3565
3566         wxPyEndAllowThreads(__tstate);
3567         if (PyErr_Occurred()) SWIG_fail;
3568     }
3569     Py_INCREF(Py_None); resultobj = Py_None;
3570     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
3571     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
3572     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
3573     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
3574     return resultobj;
3575     fail:
3576     return NULL;
3577 }
3578
3579
3580 static PyObject *_wrap_ScrolledWindow_CalcScrolledPosition(PyObject *self, PyObject *args) {
3581     int argc;
3582     PyObject *argv[4];
3583     int ii;
3584
3585     argc = PyObject_Length(args);
3586     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3587         argv[ii] = PyTuple_GetItem(args,ii);
3588     }
3589     if (argc == 2) {
3590         int _v;
3591         {
3592             void *ptr;
3593             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3594                 _v = 0;
3595                 PyErr_Clear();
3596             } else {
3597                 _v = 1;
3598             }
3599         }
3600         if (_v) {
3601             {
3602                 _v = wxPySimple_typecheck(argv[1], wxT("wxPoint"), 2);
3603             }
3604             if (_v) {
3605                 return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_0(self,args);
3606             }
3607         }
3608     }
3609     if (argc == 3) {
3610         int _v;
3611         {
3612             void *ptr;
3613             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3614                 _v = 0;
3615                 PyErr_Clear();
3616             } else {
3617                 _v = 1;
3618             }
3619         }
3620         if (_v) {
3621             _v = SWIG_Check_int(argv[1]);
3622             if (_v) {
3623                 _v = SWIG_Check_int(argv[2]);
3624                 if (_v) {
3625                     return _wrap_ScrolledWindow_CalcScrolledPosition__SWIG_1(self,args);
3626                 }
3627             }
3628         }
3629     }
3630
3631     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'ScrolledWindow_CalcScrolledPosition'");
3632     return NULL;
3633 }
3634
3635
3636 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(PyObject *, PyObject *args) {
3637     PyObject *resultobj;
3638     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3639     wxPoint *arg2 = 0 ;
3640     wxPoint result;
3641     wxPoint temp2 ;
3642     PyObject * obj0 = 0 ;
3643     PyObject * obj1 = 0 ;
3644
3645     if(!PyArg_ParseTuple(args,(char *)"OO:ScrolledWindow_CalcUnscrolledPosition",&obj0,&obj1)) goto fail;
3646     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3647     if (SWIG_arg_fail(1)) SWIG_fail;
3648     {
3649         arg2 = &temp2;
3650         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
3651     }
3652     {
3653         PyThreadState* __tstate = wxPyBeginAllowThreads();
3654         result = ((wxScrolledWindow const *)arg1)->CalcUnscrolledPosition((wxPoint const &)*arg2);
3655
3656         wxPyEndAllowThreads(__tstate);
3657         if (PyErr_Occurred()) SWIG_fail;
3658     }
3659     {
3660         wxPoint * resultptr;
3661         resultptr = new wxPoint((wxPoint &)(result));
3662         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
3663     }
3664     return resultobj;
3665     fail:
3666     return NULL;
3667 }
3668
3669
3670 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(PyObject *, PyObject *args) {
3671     PyObject *resultobj;
3672     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3673     int arg2 ;
3674     int arg3 ;
3675     int *arg4 = (int *) 0 ;
3676     int *arg5 = (int *) 0 ;
3677     int temp4 ;
3678     int res4 = 0 ;
3679     int temp5 ;
3680     int res5 = 0 ;
3681     PyObject * obj0 = 0 ;
3682     PyObject * obj1 = 0 ;
3683     PyObject * obj2 = 0 ;
3684
3685     arg4 = &temp4; res4 = SWIG_NEWOBJ;
3686     arg5 = &temp5; res5 = SWIG_NEWOBJ;
3687     if(!PyArg_ParseTuple(args,(char *)"OOO:ScrolledWindow_CalcUnscrolledPosition",&obj0,&obj1,&obj2)) goto fail;
3688     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3689     if (SWIG_arg_fail(1)) SWIG_fail;
3690     {
3691         arg2 = (int)(SWIG_As_int(obj1));
3692         if (SWIG_arg_fail(2)) SWIG_fail;
3693     }
3694     {
3695         arg3 = (int)(SWIG_As_int(obj2));
3696         if (SWIG_arg_fail(3)) SWIG_fail;
3697     }
3698     {
3699         PyThreadState* __tstate = wxPyBeginAllowThreads();
3700         ((wxScrolledWindow const *)arg1)->CalcUnscrolledPosition(arg2,arg3,arg4,arg5);
3701
3702         wxPyEndAllowThreads(__tstate);
3703         if (PyErr_Occurred()) SWIG_fail;
3704     }
3705     Py_INCREF(Py_None); resultobj = Py_None;
3706     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
3707     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
3708     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
3709     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
3710     return resultobj;
3711     fail:
3712     return NULL;
3713 }
3714
3715
3716 static PyObject *_wrap_ScrolledWindow_CalcUnscrolledPosition(PyObject *self, PyObject *args) {
3717     int argc;
3718     PyObject *argv[4];
3719     int ii;
3720
3721     argc = PyObject_Length(args);
3722     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3723         argv[ii] = PyTuple_GetItem(args,ii);
3724     }
3725     if (argc == 2) {
3726         int _v;
3727         {
3728             void *ptr;
3729             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3730                 _v = 0;
3731                 PyErr_Clear();
3732             } else {
3733                 _v = 1;
3734             }
3735         }
3736         if (_v) {
3737             {
3738                 _v = wxPySimple_typecheck(argv[1], wxT("wxPoint"), 2);
3739             }
3740             if (_v) {
3741                 return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_0(self,args);
3742             }
3743         }
3744     }
3745     if (argc == 3) {
3746         int _v;
3747         {
3748             void *ptr;
3749             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxScrolledWindow, 0) == -1) {
3750                 _v = 0;
3751                 PyErr_Clear();
3752             } else {
3753                 _v = 1;
3754             }
3755         }
3756         if (_v) {
3757             _v = SWIG_Check_int(argv[1]);
3758             if (_v) {
3759                 _v = SWIG_Check_int(argv[2]);
3760                 if (_v) {
3761                     return _wrap_ScrolledWindow_CalcUnscrolledPosition__SWIG_1(self,args);
3762                 }
3763             }
3764         }
3765     }
3766
3767     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'ScrolledWindow_CalcUnscrolledPosition'");
3768     return NULL;
3769 }
3770
3771
3772 static PyObject *_wrap_ScrolledWindow_AdjustScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
3773     PyObject *resultobj;
3774     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3775     PyObject * obj0 = 0 ;
3776     char *kwnames[] = {
3777         (char *) "self", NULL
3778     };
3779
3780     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_AdjustScrollbars",kwnames,&obj0)) goto fail;
3781     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3782     if (SWIG_arg_fail(1)) SWIG_fail;
3783     {
3784         PyThreadState* __tstate = wxPyBeginAllowThreads();
3785         (arg1)->AdjustScrollbars();
3786
3787         wxPyEndAllowThreads(__tstate);
3788         if (PyErr_Occurred()) SWIG_fail;
3789     }
3790     Py_INCREF(Py_None); resultobj = Py_None;
3791     return resultobj;
3792     fail:
3793     return NULL;
3794 }
3795
3796
3797 static PyObject *_wrap_ScrolledWindow_CalcScrollInc(PyObject *, PyObject *args, PyObject *kwargs) {
3798     PyObject *resultobj;
3799     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3800     wxScrollWinEvent *arg2 = 0 ;
3801     int result;
3802     PyObject * obj0 = 0 ;
3803     PyObject * obj1 = 0 ;
3804     char *kwnames[] = {
3805         (char *) "self",(char *) "event", NULL
3806     };
3807
3808     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_CalcScrollInc",kwnames,&obj0,&obj1)) goto fail;
3809     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3810     if (SWIG_arg_fail(1)) SWIG_fail;
3811     {
3812         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
3813         if (SWIG_arg_fail(2)) SWIG_fail;
3814         if (arg2 == NULL) {
3815             SWIG_null_ref("wxScrollWinEvent");
3816         }
3817         if (SWIG_arg_fail(2)) SWIG_fail;
3818     }
3819     {
3820         PyThreadState* __tstate = wxPyBeginAllowThreads();
3821         result = (int)(arg1)->CalcScrollInc(*arg2);
3822
3823         wxPyEndAllowThreads(__tstate);
3824         if (PyErr_Occurred()) SWIG_fail;
3825     }
3826     {
3827         resultobj = SWIG_From_int((int)(result));
3828     }
3829     return resultobj;
3830     fail:
3831     return NULL;
3832 }
3833
3834
3835 static PyObject *_wrap_ScrolledWindow_SetTargetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
3836     PyObject *resultobj;
3837     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3838     wxWindow *arg2 = (wxWindow *) 0 ;
3839     PyObject * obj0 = 0 ;
3840     PyObject * obj1 = 0 ;
3841     char *kwnames[] = {
3842         (char *) "self",(char *) "target", NULL
3843     };
3844
3845     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_SetTargetWindow",kwnames,&obj0,&obj1)) goto fail;
3846     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3847     if (SWIG_arg_fail(1)) SWIG_fail;
3848     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3849     if (SWIG_arg_fail(2)) SWIG_fail;
3850     {
3851         PyThreadState* __tstate = wxPyBeginAllowThreads();
3852         (arg1)->SetTargetWindow(arg2);
3853
3854         wxPyEndAllowThreads(__tstate);
3855         if (PyErr_Occurred()) SWIG_fail;
3856     }
3857     Py_INCREF(Py_None); resultobj = Py_None;
3858     return resultobj;
3859     fail:
3860     return NULL;
3861 }
3862
3863
3864 static PyObject *_wrap_ScrolledWindow_GetTargetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
3865     PyObject *resultobj;
3866     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3867     wxWindow *result;
3868     PyObject * obj0 = 0 ;
3869     char *kwnames[] = {
3870         (char *) "self", NULL
3871     };
3872
3873     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetTargetWindow",kwnames,&obj0)) goto fail;
3874     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3875     if (SWIG_arg_fail(1)) SWIG_fail;
3876     {
3877         PyThreadState* __tstate = wxPyBeginAllowThreads();
3878         result = (wxWindow *)((wxScrolledWindow const *)arg1)->GetTargetWindow();
3879
3880         wxPyEndAllowThreads(__tstate);
3881         if (PyErr_Occurred()) SWIG_fail;
3882     }
3883     {
3884         resultobj = wxPyMake_wxObject(result, 0);
3885     }
3886     return resultobj;
3887     fail:
3888     return NULL;
3889 }
3890
3891
3892 static PyObject *_wrap_ScrolledWindow_SetTargetRect(PyObject *, PyObject *args, PyObject *kwargs) {
3893     PyObject *resultobj;
3894     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3895     wxRect *arg2 = 0 ;
3896     wxRect temp2 ;
3897     PyObject * obj0 = 0 ;
3898     PyObject * obj1 = 0 ;
3899     char *kwnames[] = {
3900         (char *) "self",(char *) "rect", NULL
3901     };
3902
3903     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_SetTargetRect",kwnames,&obj0,&obj1)) goto fail;
3904     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3905     if (SWIG_arg_fail(1)) SWIG_fail;
3906     {
3907         arg2 = &temp2;
3908         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
3909     }
3910     {
3911         PyThreadState* __tstate = wxPyBeginAllowThreads();
3912         (arg1)->SetTargetRect((wxRect const &)*arg2);
3913
3914         wxPyEndAllowThreads(__tstate);
3915         if (PyErr_Occurred()) SWIG_fail;
3916     }
3917     Py_INCREF(Py_None); resultobj = Py_None;
3918     return resultobj;
3919     fail:
3920     return NULL;
3921 }
3922
3923
3924 static PyObject *_wrap_ScrolledWindow_GetTargetRect(PyObject *, PyObject *args, PyObject *kwargs) {
3925     PyObject *resultobj;
3926     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3927     wxRect result;
3928     PyObject * obj0 = 0 ;
3929     char *kwnames[] = {
3930         (char *) "self", NULL
3931     };
3932
3933     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrolledWindow_GetTargetRect",kwnames,&obj0)) goto fail;
3934     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3935     if (SWIG_arg_fail(1)) SWIG_fail;
3936     {
3937         PyThreadState* __tstate = wxPyBeginAllowThreads();
3938         result = ((wxScrolledWindow const *)arg1)->GetTargetRect();
3939
3940         wxPyEndAllowThreads(__tstate);
3941         if (PyErr_Occurred()) SWIG_fail;
3942     }
3943     {
3944         wxRect * resultptr;
3945         resultptr = new wxRect((wxRect &)(result));
3946         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
3947     }
3948     return resultobj;
3949     fail:
3950     return NULL;
3951 }
3952
3953
3954 static PyObject *_wrap_ScrolledWindow_DoPrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
3955     PyObject *resultobj;
3956     wxScrolledWindow *arg1 = (wxScrolledWindow *) 0 ;
3957     wxDC *arg2 = 0 ;
3958     PyObject * obj0 = 0 ;
3959     PyObject * obj1 = 0 ;
3960     char *kwnames[] = {
3961         (char *) "self",(char *) "dc", NULL
3962     };
3963
3964     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrolledWindow_DoPrepareDC",kwnames,&obj0,&obj1)) goto fail;
3965     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
3966     if (SWIG_arg_fail(1)) SWIG_fail;
3967     {
3968         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
3969         if (SWIG_arg_fail(2)) SWIG_fail;
3970         if (arg2 == NULL) {
3971             SWIG_null_ref("wxDC");
3972         }
3973         if (SWIG_arg_fail(2)) SWIG_fail;
3974     }
3975     {
3976         PyThreadState* __tstate = wxPyBeginAllowThreads();
3977         (arg1)->DoPrepareDC(*arg2);
3978
3979         wxPyEndAllowThreads(__tstate);
3980         if (PyErr_Occurred()) SWIG_fail;
3981     }
3982     Py_INCREF(Py_None); resultobj = Py_None;
3983     return resultobj;
3984     fail:
3985     return NULL;
3986 }
3987
3988
3989 static PyObject *_wrap_ScrolledWindow_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
3990     PyObject *resultobj;
3991     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
3992     wxVisualAttributes result;
3993     PyObject * obj0 = 0 ;
3994     char *kwnames[] = {
3995         (char *) "variant", NULL
3996     };
3997
3998     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ScrolledWindow_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
3999     if (obj0) {
4000         {
4001             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
4002             if (SWIG_arg_fail(1)) SWIG_fail;
4003         }
4004     }
4005     {
4006         if (!wxPyCheckForApp()) SWIG_fail;
4007         PyThreadState* __tstate = wxPyBeginAllowThreads();
4008         result = wxScrolledWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
4009
4010         wxPyEndAllowThreads(__tstate);
4011         if (PyErr_Occurred()) SWIG_fail;
4012     }
4013     {
4014         wxVisualAttributes * resultptr;
4015         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
4016         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
4017     }
4018     return resultobj;
4019     fail:
4020     return NULL;
4021 }
4022
4023
4024 static PyObject * ScrolledWindow_swigregister(PyObject *, PyObject *args) {
4025     PyObject *obj;
4026     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4027     SWIG_TypeClientData(SWIGTYPE_p_wxScrolledWindow, obj);
4028     Py_INCREF(obj);
4029     return Py_BuildValue((char *)"");
4030 }
4031 static int _wrap_FrameNameStr_set(PyObject *) {
4032     PyErr_SetString(PyExc_TypeError,"Variable FrameNameStr is read-only.");
4033     return 1;
4034 }
4035
4036
4037 static PyObject *_wrap_FrameNameStr_get(void) {
4038     PyObject *pyobj;
4039
4040     {
4041 #if wxUSE_UNICODE
4042         pyobj = PyUnicode_FromWideChar((&wxPyFrameNameStr)->c_str(), (&wxPyFrameNameStr)->Len());
4043 #else
4044         pyobj = PyString_FromStringAndSize((&wxPyFrameNameStr)->c_str(), (&wxPyFrameNameStr)->Len());
4045 #endif
4046     }
4047     return pyobj;
4048 }
4049
4050
4051 static int _wrap_DialogNameStr_set(PyObject *) {
4052     PyErr_SetString(PyExc_TypeError,"Variable DialogNameStr is read-only.");
4053     return 1;
4054 }
4055
4056
4057 static PyObject *_wrap_DialogNameStr_get(void) {
4058     PyObject *pyobj;
4059
4060     {
4061 #if wxUSE_UNICODE
4062         pyobj = PyUnicode_FromWideChar((&wxPyDialogNameStr)->c_str(), (&wxPyDialogNameStr)->Len());
4063 #else
4064         pyobj = PyString_FromStringAndSize((&wxPyDialogNameStr)->c_str(), (&wxPyDialogNameStr)->Len());
4065 #endif
4066     }
4067     return pyobj;
4068 }
4069
4070
4071 static int _wrap_StatusLineNameStr_set(PyObject *) {
4072     PyErr_SetString(PyExc_TypeError,"Variable StatusLineNameStr is read-only.");
4073     return 1;
4074 }
4075
4076
4077 static PyObject *_wrap_StatusLineNameStr_get(void) {
4078     PyObject *pyobj;
4079
4080     {
4081 #if wxUSE_UNICODE
4082         pyobj = PyUnicode_FromWideChar((&wxPyStatusLineNameStr)->c_str(), (&wxPyStatusLineNameStr)->Len());
4083 #else
4084         pyobj = PyString_FromStringAndSize((&wxPyStatusLineNameStr)->c_str(), (&wxPyStatusLineNameStr)->Len());
4085 #endif
4086     }
4087     return pyobj;
4088 }
4089
4090
4091 static int _wrap_ToolBarNameStr_set(PyObject *) {
4092     PyErr_SetString(PyExc_TypeError,"Variable ToolBarNameStr is read-only.");
4093     return 1;
4094 }
4095
4096
4097 static PyObject *_wrap_ToolBarNameStr_get(void) {
4098     PyObject *pyobj;
4099
4100     {
4101 #if wxUSE_UNICODE
4102         pyobj = PyUnicode_FromWideChar((&wxPyToolBarNameStr)->c_str(), (&wxPyToolBarNameStr)->Len());
4103 #else
4104         pyobj = PyString_FromStringAndSize((&wxPyToolBarNameStr)->c_str(), (&wxPyToolBarNameStr)->Len());
4105 #endif
4106     }
4107     return pyobj;
4108 }
4109
4110
4111 static PyObject *_wrap_TopLevelWindow_Maximize(PyObject *, PyObject *args, PyObject *kwargs) {
4112     PyObject *resultobj;
4113     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4114     bool arg2 = (bool) true ;
4115     PyObject * obj0 = 0 ;
4116     PyObject * obj1 = 0 ;
4117     char *kwnames[] = {
4118         (char *) "self",(char *) "maximize", NULL
4119     };
4120
4121     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_Maximize",kwnames,&obj0,&obj1)) goto fail;
4122     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4123     if (SWIG_arg_fail(1)) SWIG_fail;
4124     if (obj1) {
4125         {
4126             arg2 = (bool)(SWIG_As_bool(obj1));
4127             if (SWIG_arg_fail(2)) SWIG_fail;
4128         }
4129     }
4130     {
4131         PyThreadState* __tstate = wxPyBeginAllowThreads();
4132         (arg1)->Maximize(arg2);
4133
4134         wxPyEndAllowThreads(__tstate);
4135         if (PyErr_Occurred()) SWIG_fail;
4136     }
4137     Py_INCREF(Py_None); resultobj = Py_None;
4138     return resultobj;
4139     fail:
4140     return NULL;
4141 }
4142
4143
4144 static PyObject *_wrap_TopLevelWindow_Restore(PyObject *, PyObject *args, PyObject *kwargs) {
4145     PyObject *resultobj;
4146     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4147     PyObject * obj0 = 0 ;
4148     char *kwnames[] = {
4149         (char *) "self", NULL
4150     };
4151
4152     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_Restore",kwnames,&obj0)) goto fail;
4153     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4154     if (SWIG_arg_fail(1)) SWIG_fail;
4155     {
4156         PyThreadState* __tstate = wxPyBeginAllowThreads();
4157         (arg1)->Restore();
4158
4159         wxPyEndAllowThreads(__tstate);
4160         if (PyErr_Occurred()) SWIG_fail;
4161     }
4162     Py_INCREF(Py_None); resultobj = Py_None;
4163     return resultobj;
4164     fail:
4165     return NULL;
4166 }
4167
4168
4169 static PyObject *_wrap_TopLevelWindow_Iconize(PyObject *, PyObject *args, PyObject *kwargs) {
4170     PyObject *resultobj;
4171     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4172     bool arg2 = (bool) true ;
4173     PyObject * obj0 = 0 ;
4174     PyObject * obj1 = 0 ;
4175     char *kwnames[] = {
4176         (char *) "self",(char *) "iconize", NULL
4177     };
4178
4179     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_Iconize",kwnames,&obj0,&obj1)) goto fail;
4180     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4181     if (SWIG_arg_fail(1)) SWIG_fail;
4182     if (obj1) {
4183         {
4184             arg2 = (bool)(SWIG_As_bool(obj1));
4185             if (SWIG_arg_fail(2)) SWIG_fail;
4186         }
4187     }
4188     {
4189         PyThreadState* __tstate = wxPyBeginAllowThreads();
4190         (arg1)->Iconize(arg2);
4191
4192         wxPyEndAllowThreads(__tstate);
4193         if (PyErr_Occurred()) SWIG_fail;
4194     }
4195     Py_INCREF(Py_None); resultobj = Py_None;
4196     return resultobj;
4197     fail:
4198     return NULL;
4199 }
4200
4201
4202 static PyObject *_wrap_TopLevelWindow_IsMaximized(PyObject *, PyObject *args, PyObject *kwargs) {
4203     PyObject *resultobj;
4204     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4205     bool result;
4206     PyObject * obj0 = 0 ;
4207     char *kwnames[] = {
4208         (char *) "self", NULL
4209     };
4210
4211     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsMaximized",kwnames,&obj0)) goto fail;
4212     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4213     if (SWIG_arg_fail(1)) SWIG_fail;
4214     {
4215         PyThreadState* __tstate = wxPyBeginAllowThreads();
4216         result = (bool)((wxTopLevelWindow const *)arg1)->IsMaximized();
4217
4218         wxPyEndAllowThreads(__tstate);
4219         if (PyErr_Occurred()) SWIG_fail;
4220     }
4221     {
4222         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4223     }
4224     return resultobj;
4225     fail:
4226     return NULL;
4227 }
4228
4229
4230 static PyObject *_wrap_TopLevelWindow_IsIconized(PyObject *, PyObject *args, PyObject *kwargs) {
4231     PyObject *resultobj;
4232     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4233     bool result;
4234     PyObject * obj0 = 0 ;
4235     char *kwnames[] = {
4236         (char *) "self", NULL
4237     };
4238
4239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsIconized",kwnames,&obj0)) goto fail;
4240     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4241     if (SWIG_arg_fail(1)) SWIG_fail;
4242     {
4243         PyThreadState* __tstate = wxPyBeginAllowThreads();
4244         result = (bool)((wxTopLevelWindow const *)arg1)->IsIconized();
4245
4246         wxPyEndAllowThreads(__tstate);
4247         if (PyErr_Occurred()) SWIG_fail;
4248     }
4249     {
4250         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4251     }
4252     return resultobj;
4253     fail:
4254     return NULL;
4255 }
4256
4257
4258 static PyObject *_wrap_TopLevelWindow_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4259     PyObject *resultobj;
4260     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4261     wxIcon result;
4262     PyObject * obj0 = 0 ;
4263     char *kwnames[] = {
4264         (char *) "self", NULL
4265     };
4266
4267     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_GetIcon",kwnames,&obj0)) goto fail;
4268     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4269     if (SWIG_arg_fail(1)) SWIG_fail;
4270     {
4271         PyThreadState* __tstate = wxPyBeginAllowThreads();
4272         result = ((wxTopLevelWindow const *)arg1)->GetIcon();
4273
4274         wxPyEndAllowThreads(__tstate);
4275         if (PyErr_Occurred()) SWIG_fail;
4276     }
4277     {
4278         wxIcon * resultptr;
4279         resultptr = new wxIcon((wxIcon &)(result));
4280         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
4281     }
4282     return resultobj;
4283     fail:
4284     return NULL;
4285 }
4286
4287
4288 static PyObject *_wrap_TopLevelWindow_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4289     PyObject *resultobj;
4290     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4291     wxIcon *arg2 = 0 ;
4292     PyObject * obj0 = 0 ;
4293     PyObject * obj1 = 0 ;
4294     char *kwnames[] = {
4295         (char *) "self",(char *) "icon", NULL
4296     };
4297
4298     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetIcon",kwnames,&obj0,&obj1)) goto fail;
4299     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4300     if (SWIG_arg_fail(1)) SWIG_fail;
4301     {
4302         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4303         if (SWIG_arg_fail(2)) SWIG_fail;
4304         if (arg2 == NULL) {
4305             SWIG_null_ref("wxIcon");
4306         }
4307         if (SWIG_arg_fail(2)) SWIG_fail;
4308     }
4309     {
4310         PyThreadState* __tstate = wxPyBeginAllowThreads();
4311         (arg1)->SetIcon((wxIcon const &)*arg2);
4312
4313         wxPyEndAllowThreads(__tstate);
4314         if (PyErr_Occurred()) SWIG_fail;
4315     }
4316     Py_INCREF(Py_None); resultobj = Py_None;
4317     return resultobj;
4318     fail:
4319     return NULL;
4320 }
4321
4322
4323 static PyObject *_wrap_TopLevelWindow_SetIcons(PyObject *, PyObject *args, PyObject *kwargs) {
4324     PyObject *resultobj;
4325     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4326     wxIconBundle *arg2 = 0 ;
4327     PyObject * obj0 = 0 ;
4328     PyObject * obj1 = 0 ;
4329     char *kwnames[] = {
4330         (char *) "self",(char *) "icons", NULL
4331     };
4332
4333     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetIcons",kwnames,&obj0,&obj1)) goto fail;
4334     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4335     if (SWIG_arg_fail(1)) SWIG_fail;
4336     {
4337         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
4338         if (SWIG_arg_fail(2)) SWIG_fail;
4339         if (arg2 == NULL) {
4340             SWIG_null_ref("wxIconBundle");
4341         }
4342         if (SWIG_arg_fail(2)) SWIG_fail;
4343     }
4344     {
4345         PyThreadState* __tstate = wxPyBeginAllowThreads();
4346         (arg1)->SetIcons((wxIconBundle const &)*arg2);
4347
4348         wxPyEndAllowThreads(__tstate);
4349         if (PyErr_Occurred()) SWIG_fail;
4350     }
4351     Py_INCREF(Py_None); resultobj = Py_None;
4352     return resultobj;
4353     fail:
4354     return NULL;
4355 }
4356
4357
4358 static PyObject *_wrap_TopLevelWindow_ShowFullScreen(PyObject *, PyObject *args, PyObject *kwargs) {
4359     PyObject *resultobj;
4360     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4361     bool arg2 ;
4362     long arg3 = (long) wxFULLSCREEN_ALL ;
4363     bool result;
4364     PyObject * obj0 = 0 ;
4365     PyObject * obj1 = 0 ;
4366     PyObject * obj2 = 0 ;
4367     char *kwnames[] = {
4368         (char *) "self",(char *) "show",(char *) "style", NULL
4369     };
4370
4371     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TopLevelWindow_ShowFullScreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
4372     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4373     if (SWIG_arg_fail(1)) SWIG_fail;
4374     {
4375         arg2 = (bool)(SWIG_As_bool(obj1));
4376         if (SWIG_arg_fail(2)) SWIG_fail;
4377     }
4378     if (obj2) {
4379         {
4380             arg3 = (long)(SWIG_As_long(obj2));
4381             if (SWIG_arg_fail(3)) SWIG_fail;
4382         }
4383     }
4384     {
4385         PyThreadState* __tstate = wxPyBeginAllowThreads();
4386         result = (bool)(arg1)->ShowFullScreen(arg2,arg3);
4387
4388         wxPyEndAllowThreads(__tstate);
4389         if (PyErr_Occurred()) SWIG_fail;
4390     }
4391     {
4392         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4393     }
4394     return resultobj;
4395     fail:
4396     return NULL;
4397 }
4398
4399
4400 static PyObject *_wrap_TopLevelWindow_IsFullScreen(PyObject *, PyObject *args, PyObject *kwargs) {
4401     PyObject *resultobj;
4402     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4403     bool result;
4404     PyObject * obj0 = 0 ;
4405     char *kwnames[] = {
4406         (char *) "self", NULL
4407     };
4408
4409     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsFullScreen",kwnames,&obj0)) goto fail;
4410     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4411     if (SWIG_arg_fail(1)) SWIG_fail;
4412     {
4413         PyThreadState* __tstate = wxPyBeginAllowThreads();
4414         result = (bool)((wxTopLevelWindow const *)arg1)->IsFullScreen();
4415
4416         wxPyEndAllowThreads(__tstate);
4417         if (PyErr_Occurred()) SWIG_fail;
4418     }
4419     {
4420         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4421     }
4422     return resultobj;
4423     fail:
4424     return NULL;
4425 }
4426
4427
4428 static PyObject *_wrap_TopLevelWindow_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
4429     PyObject *resultobj;
4430     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4431     wxString *arg2 = 0 ;
4432     bool temp2 = false ;
4433     PyObject * obj0 = 0 ;
4434     PyObject * obj1 = 0 ;
4435     char *kwnames[] = {
4436         (char *) "self",(char *) "title", NULL
4437     };
4438
4439     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetTitle",kwnames,&obj0,&obj1)) goto fail;
4440     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4441     if (SWIG_arg_fail(1)) SWIG_fail;
4442     {
4443         arg2 = wxString_in_helper(obj1);
4444         if (arg2 == NULL) SWIG_fail;
4445         temp2 = true;
4446     }
4447     {
4448         PyThreadState* __tstate = wxPyBeginAllowThreads();
4449         (arg1)->SetTitle((wxString const &)*arg2);
4450
4451         wxPyEndAllowThreads(__tstate);
4452         if (PyErr_Occurred()) SWIG_fail;
4453     }
4454     Py_INCREF(Py_None); resultobj = Py_None;
4455     {
4456         if (temp2)
4457         delete arg2;
4458     }
4459     return resultobj;
4460     fail:
4461     {
4462         if (temp2)
4463         delete arg2;
4464     }
4465     return NULL;
4466 }
4467
4468
4469 static PyObject *_wrap_TopLevelWindow_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
4470     PyObject *resultobj;
4471     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4472     wxString result;
4473     PyObject * obj0 = 0 ;
4474     char *kwnames[] = {
4475         (char *) "self", NULL
4476     };
4477
4478     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_GetTitle",kwnames,&obj0)) goto fail;
4479     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4480     if (SWIG_arg_fail(1)) SWIG_fail;
4481     {
4482         PyThreadState* __tstate = wxPyBeginAllowThreads();
4483         result = ((wxTopLevelWindow const *)arg1)->GetTitle();
4484
4485         wxPyEndAllowThreads(__tstate);
4486         if (PyErr_Occurred()) SWIG_fail;
4487     }
4488     {
4489 #if wxUSE_UNICODE
4490         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4491 #else
4492         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4493 #endif
4494     }
4495     return resultobj;
4496     fail:
4497     return NULL;
4498 }
4499
4500
4501 static PyObject *_wrap_TopLevelWindow_SetShape(PyObject *, PyObject *args, PyObject *kwargs) {
4502     PyObject *resultobj;
4503     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4504     wxRegion *arg2 = 0 ;
4505     bool result;
4506     PyObject * obj0 = 0 ;
4507     PyObject * obj1 = 0 ;
4508     char *kwnames[] = {
4509         (char *) "self",(char *) "region", NULL
4510     };
4511
4512     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_SetShape",kwnames,&obj0,&obj1)) goto fail;
4513     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4514     if (SWIG_arg_fail(1)) SWIG_fail;
4515     {
4516         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
4517         if (SWIG_arg_fail(2)) SWIG_fail;
4518         if (arg2 == NULL) {
4519             SWIG_null_ref("wxRegion");
4520         }
4521         if (SWIG_arg_fail(2)) SWIG_fail;
4522     }
4523     {
4524         PyThreadState* __tstate = wxPyBeginAllowThreads();
4525         result = (bool)(arg1)->SetShape((wxRegion const &)*arg2);
4526
4527         wxPyEndAllowThreads(__tstate);
4528         if (PyErr_Occurred()) SWIG_fail;
4529     }
4530     {
4531         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4532     }
4533     return resultobj;
4534     fail:
4535     return NULL;
4536 }
4537
4538
4539 static PyObject *_wrap_TopLevelWindow_RequestUserAttention(PyObject *, PyObject *args, PyObject *kwargs) {
4540     PyObject *resultobj;
4541     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4542     int arg2 = (int) wxUSER_ATTENTION_INFO ;
4543     PyObject * obj0 = 0 ;
4544     PyObject * obj1 = 0 ;
4545     char *kwnames[] = {
4546         (char *) "self",(char *) "flags", NULL
4547     };
4548
4549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_RequestUserAttention",kwnames,&obj0,&obj1)) goto fail;
4550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4551     if (SWIG_arg_fail(1)) SWIG_fail;
4552     if (obj1) {
4553         {
4554             arg2 = (int)(SWIG_As_int(obj1));
4555             if (SWIG_arg_fail(2)) SWIG_fail;
4556         }
4557     }
4558     {
4559         PyThreadState* __tstate = wxPyBeginAllowThreads();
4560         (arg1)->RequestUserAttention(arg2);
4561
4562         wxPyEndAllowThreads(__tstate);
4563         if (PyErr_Occurred()) SWIG_fail;
4564     }
4565     Py_INCREF(Py_None); resultobj = Py_None;
4566     return resultobj;
4567     fail:
4568     return NULL;
4569 }
4570
4571
4572 static PyObject *_wrap_TopLevelWindow_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
4573     PyObject *resultobj;
4574     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4575     bool result;
4576     PyObject * obj0 = 0 ;
4577     char *kwnames[] = {
4578         (char *) "self", NULL
4579     };
4580
4581     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_IsActive",kwnames,&obj0)) goto fail;
4582     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4583     if (SWIG_arg_fail(1)) SWIG_fail;
4584     {
4585         PyThreadState* __tstate = wxPyBeginAllowThreads();
4586         result = (bool)(arg1)->IsActive();
4587
4588         wxPyEndAllowThreads(__tstate);
4589         if (PyErr_Occurred()) SWIG_fail;
4590     }
4591     {
4592         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4593     }
4594     return resultobj;
4595     fail:
4596     return NULL;
4597 }
4598
4599
4600 static PyObject *_wrap_TopLevelWindow_MacSetMetalAppearance(PyObject *, PyObject *args, PyObject *kwargs) {
4601     PyObject *resultobj;
4602     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4603     bool arg2 ;
4604     PyObject * obj0 = 0 ;
4605     PyObject * obj1 = 0 ;
4606     char *kwnames[] = {
4607         (char *) "self",(char *) "on", NULL
4608     };
4609
4610     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_MacSetMetalAppearance",kwnames,&obj0,&obj1)) goto fail;
4611     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4612     if (SWIG_arg_fail(1)) SWIG_fail;
4613     {
4614         arg2 = (bool)(SWIG_As_bool(obj1));
4615         if (SWIG_arg_fail(2)) SWIG_fail;
4616     }
4617     {
4618         PyThreadState* __tstate = wxPyBeginAllowThreads();
4619         (arg1)->MacSetMetalAppearance(arg2);
4620
4621         wxPyEndAllowThreads(__tstate);
4622         if (PyErr_Occurred()) SWIG_fail;
4623     }
4624     Py_INCREF(Py_None); resultobj = Py_None;
4625     return resultobj;
4626     fail:
4627     return NULL;
4628 }
4629
4630
4631 static PyObject *_wrap_TopLevelWindow_MacGetMetalAppearance(PyObject *, PyObject *args, PyObject *kwargs) {
4632     PyObject *resultobj;
4633     wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
4634     bool result;
4635     PyObject * obj0 = 0 ;
4636     char *kwnames[] = {
4637         (char *) "self", NULL
4638     };
4639
4640     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TopLevelWindow_MacGetMetalAppearance",kwnames,&obj0)) goto fail;
4641     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTopLevelWindow, SWIG_POINTER_EXCEPTION | 0);
4642     if (SWIG_arg_fail(1)) SWIG_fail;
4643     {
4644         PyThreadState* __tstate = wxPyBeginAllowThreads();
4645         result = (bool)((wxTopLevelWindow const *)arg1)->MacGetMetalAppearance();
4646
4647         wxPyEndAllowThreads(__tstate);
4648         if (PyErr_Occurred()) SWIG_fail;
4649     }
4650     {
4651         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4652     }
4653     return resultobj;
4654     fail:
4655     return NULL;
4656 }
4657
4658
4659 static PyObject * TopLevelWindow_swigregister(PyObject *, PyObject *args) {
4660     PyObject *obj;
4661     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4662     SWIG_TypeClientData(SWIGTYPE_p_wxTopLevelWindow, obj);
4663     Py_INCREF(obj);
4664     return Py_BuildValue((char *)"");
4665 }
4666 static PyObject *_wrap_new_Frame(PyObject *, PyObject *args, PyObject *kwargs) {
4667     PyObject *resultobj;
4668     wxWindow *arg1 = (wxWindow *) 0 ;
4669     int arg2 = (int) (int)-1 ;
4670     wxString const &arg3_defvalue = wxPyEmptyString ;
4671     wxString *arg3 = (wxString *) &arg3_defvalue ;
4672     wxPoint const &arg4_defvalue = wxDefaultPosition ;
4673     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4674     wxSize const &arg5_defvalue = wxDefaultSize ;
4675     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
4676     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
4677     wxString const &arg7_defvalue = wxPyFrameNameStr ;
4678     wxString *arg7 = (wxString *) &arg7_defvalue ;
4679     wxFrame *result;
4680     bool temp3 = false ;
4681     wxPoint temp4 ;
4682     wxSize temp5 ;
4683     bool temp7 = false ;
4684     PyObject * obj0 = 0 ;
4685     PyObject * obj1 = 0 ;
4686     PyObject * obj2 = 0 ;
4687     PyObject * obj3 = 0 ;
4688     PyObject * obj4 = 0 ;
4689     PyObject * obj5 = 0 ;
4690     PyObject * obj6 = 0 ;
4691     char *kwnames[] = {
4692         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
4693     };
4694
4695     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Frame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4696     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4697     if (SWIG_arg_fail(1)) SWIG_fail;
4698     if (obj1) {
4699         {
4700             arg2 = (int const)(SWIG_As_int(obj1));
4701             if (SWIG_arg_fail(2)) SWIG_fail;
4702         }
4703     }
4704     if (obj2) {
4705         {
4706             arg3 = wxString_in_helper(obj2);
4707             if (arg3 == NULL) SWIG_fail;
4708             temp3 = true;
4709         }
4710     }
4711     if (obj3) {
4712         {
4713             arg4 = &temp4;
4714             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4715         }
4716     }
4717     if (obj4) {
4718         {
4719             arg5 = &temp5;
4720             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
4721         }
4722     }
4723     if (obj5) {
4724         {
4725             arg6 = (long)(SWIG_As_long(obj5));
4726             if (SWIG_arg_fail(6)) SWIG_fail;
4727         }
4728     }
4729     if (obj6) {
4730         {
4731             arg7 = wxString_in_helper(obj6);
4732             if (arg7 == NULL) SWIG_fail;
4733             temp7 = true;
4734         }
4735     }
4736     {
4737         if (!wxPyCheckForApp()) SWIG_fail;
4738         PyThreadState* __tstate = wxPyBeginAllowThreads();
4739         result = (wxFrame *)new wxFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
4740
4741         wxPyEndAllowThreads(__tstate);
4742         if (PyErr_Occurred()) SWIG_fail;
4743     }
4744     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFrame, 1);
4745     {
4746         if (temp3)
4747         delete arg3;
4748     }
4749     {
4750         if (temp7)
4751         delete arg7;
4752     }
4753     return resultobj;
4754     fail:
4755     {
4756         if (temp3)
4757         delete arg3;
4758     }
4759     {
4760         if (temp7)
4761         delete arg7;
4762     }
4763     return NULL;
4764 }
4765
4766
4767 static PyObject *_wrap_new_PreFrame(PyObject *, PyObject *args, PyObject *kwargs) {
4768     PyObject *resultobj;
4769     wxFrame *result;
4770     char *kwnames[] = {
4771         NULL
4772     };
4773
4774     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreFrame",kwnames)) goto fail;
4775     {
4776         if (!wxPyCheckForApp()) SWIG_fail;
4777         PyThreadState* __tstate = wxPyBeginAllowThreads();
4778         result = (wxFrame *)new wxFrame();
4779
4780         wxPyEndAllowThreads(__tstate);
4781         if (PyErr_Occurred()) SWIG_fail;
4782     }
4783     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFrame, 1);
4784     return resultobj;
4785     fail:
4786     return NULL;
4787 }
4788
4789
4790 static PyObject *_wrap_Frame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
4791     PyObject *resultobj;
4792     wxFrame *arg1 = (wxFrame *) 0 ;
4793     wxWindow *arg2 = (wxWindow *) 0 ;
4794     int arg3 = (int) (int)-1 ;
4795     wxString const &arg4_defvalue = wxPyEmptyString ;
4796     wxString *arg4 = (wxString *) &arg4_defvalue ;
4797     wxPoint const &arg5_defvalue = wxDefaultPosition ;
4798     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
4799     wxSize const &arg6_defvalue = wxDefaultSize ;
4800     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
4801     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
4802     wxString const &arg8_defvalue = wxPyFrameNameStr ;
4803     wxString *arg8 = (wxString *) &arg8_defvalue ;
4804     bool result;
4805     bool temp4 = false ;
4806     wxPoint temp5 ;
4807     wxSize temp6 ;
4808     bool temp8 = false ;
4809     PyObject * obj0 = 0 ;
4810     PyObject * obj1 = 0 ;
4811     PyObject * obj2 = 0 ;
4812     PyObject * obj3 = 0 ;
4813     PyObject * obj4 = 0 ;
4814     PyObject * obj5 = 0 ;
4815     PyObject * obj6 = 0 ;
4816     PyObject * obj7 = 0 ;
4817     char *kwnames[] = {
4818         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
4819     };
4820
4821     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Frame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4822     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4823     if (SWIG_arg_fail(1)) SWIG_fail;
4824     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4825     if (SWIG_arg_fail(2)) SWIG_fail;
4826     if (obj2) {
4827         {
4828             arg3 = (int const)(SWIG_As_int(obj2));
4829             if (SWIG_arg_fail(3)) SWIG_fail;
4830         }
4831     }
4832     if (obj3) {
4833         {
4834             arg4 = wxString_in_helper(obj3);
4835             if (arg4 == NULL) SWIG_fail;
4836             temp4 = true;
4837         }
4838     }
4839     if (obj4) {
4840         {
4841             arg5 = &temp5;
4842             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
4843         }
4844     }
4845     if (obj5) {
4846         {
4847             arg6 = &temp6;
4848             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
4849         }
4850     }
4851     if (obj6) {
4852         {
4853             arg7 = (long)(SWIG_As_long(obj6));
4854             if (SWIG_arg_fail(7)) SWIG_fail;
4855         }
4856     }
4857     if (obj7) {
4858         {
4859             arg8 = wxString_in_helper(obj7);
4860             if (arg8 == NULL) SWIG_fail;
4861             temp8 = true;
4862         }
4863     }
4864     {
4865         PyThreadState* __tstate = wxPyBeginAllowThreads();
4866         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
4867
4868         wxPyEndAllowThreads(__tstate);
4869         if (PyErr_Occurred()) SWIG_fail;
4870     }
4871     {
4872         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4873     }
4874     {
4875         if (temp4)
4876         delete arg4;
4877     }
4878     {
4879         if (temp8)
4880         delete arg8;
4881     }
4882     return resultobj;
4883     fail:
4884     {
4885         if (temp4)
4886         delete arg4;
4887     }
4888     {
4889         if (temp8)
4890         delete arg8;
4891     }
4892     return NULL;
4893 }
4894
4895
4896 static PyObject *_wrap_Frame_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
4897     PyObject *resultobj;
4898     wxFrame *arg1 = (wxFrame *) 0 ;
4899     wxPoint result;
4900     PyObject * obj0 = 0 ;
4901     char *kwnames[] = {
4902         (char *) "self", NULL
4903     };
4904
4905     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
4906     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4907     if (SWIG_arg_fail(1)) SWIG_fail;
4908     {
4909         PyThreadState* __tstate = wxPyBeginAllowThreads();
4910         result = ((wxFrame const *)arg1)->GetClientAreaOrigin();
4911
4912         wxPyEndAllowThreads(__tstate);
4913         if (PyErr_Occurred()) SWIG_fail;
4914     }
4915     {
4916         wxPoint * resultptr;
4917         resultptr = new wxPoint((wxPoint &)(result));
4918         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4919     }
4920     return resultobj;
4921     fail:
4922     return NULL;
4923 }
4924
4925
4926 static PyObject *_wrap_Frame_SendSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
4927     PyObject *resultobj;
4928     wxFrame *arg1 = (wxFrame *) 0 ;
4929     PyObject * obj0 = 0 ;
4930     char *kwnames[] = {
4931         (char *) "self", NULL
4932     };
4933
4934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_SendSizeEvent",kwnames,&obj0)) goto fail;
4935     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4936     if (SWIG_arg_fail(1)) SWIG_fail;
4937     {
4938         PyThreadState* __tstate = wxPyBeginAllowThreads();
4939         (arg1)->SendSizeEvent();
4940
4941         wxPyEndAllowThreads(__tstate);
4942         if (PyErr_Occurred()) SWIG_fail;
4943     }
4944     Py_INCREF(Py_None); resultobj = Py_None;
4945     return resultobj;
4946     fail:
4947     return NULL;
4948 }
4949
4950
4951 static PyObject *_wrap_Frame_SetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
4952     PyObject *resultobj;
4953     wxFrame *arg1 = (wxFrame *) 0 ;
4954     wxMenuBar *arg2 = (wxMenuBar *) 0 ;
4955     PyObject * obj0 = 0 ;
4956     PyObject * obj1 = 0 ;
4957     char *kwnames[] = {
4958         (char *) "self",(char *) "menubar", NULL
4959     };
4960
4961     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetMenuBar",kwnames,&obj0,&obj1)) goto fail;
4962     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4963     if (SWIG_arg_fail(1)) SWIG_fail;
4964     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
4965     if (SWIG_arg_fail(2)) SWIG_fail;
4966     {
4967         PyThreadState* __tstate = wxPyBeginAllowThreads();
4968         (arg1)->SetMenuBar(arg2);
4969
4970         wxPyEndAllowThreads(__tstate);
4971         if (PyErr_Occurred()) SWIG_fail;
4972     }
4973     Py_INCREF(Py_None); resultobj = Py_None;
4974     return resultobj;
4975     fail:
4976     return NULL;
4977 }
4978
4979
4980 static PyObject *_wrap_Frame_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
4981     PyObject *resultobj;
4982     wxFrame *arg1 = (wxFrame *) 0 ;
4983     wxMenuBar *result;
4984     PyObject * obj0 = 0 ;
4985     char *kwnames[] = {
4986         (char *) "self", NULL
4987     };
4988
4989     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetMenuBar",kwnames,&obj0)) goto fail;
4990     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
4991     if (SWIG_arg_fail(1)) SWIG_fail;
4992     {
4993         PyThreadState* __tstate = wxPyBeginAllowThreads();
4994         result = (wxMenuBar *)((wxFrame const *)arg1)->GetMenuBar();
4995
4996         wxPyEndAllowThreads(__tstate);
4997         if (PyErr_Occurred()) SWIG_fail;
4998     }
4999     {
5000         resultobj = wxPyMake_wxObject(result, 0);
5001     }
5002     return resultobj;
5003     fail:
5004     return NULL;
5005 }
5006
5007
5008 static PyObject *_wrap_Frame_ProcessCommand(PyObject *, PyObject *args, PyObject *kwargs) {
5009     PyObject *resultobj;
5010     wxFrame *arg1 = (wxFrame *) 0 ;
5011     int arg2 ;
5012     bool result;
5013     PyObject * obj0 = 0 ;
5014     PyObject * obj1 = 0 ;
5015     char *kwnames[] = {
5016         (char *) "self",(char *) "winid", NULL
5017     };
5018
5019     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_ProcessCommand",kwnames,&obj0,&obj1)) goto fail;
5020     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5021     if (SWIG_arg_fail(1)) SWIG_fail;
5022     {
5023         arg2 = (int)(SWIG_As_int(obj1));
5024         if (SWIG_arg_fail(2)) SWIG_fail;
5025     }
5026     {
5027         PyThreadState* __tstate = wxPyBeginAllowThreads();
5028         result = (bool)(arg1)->ProcessCommand(arg2);
5029
5030         wxPyEndAllowThreads(__tstate);
5031         if (PyErr_Occurred()) SWIG_fail;
5032     }
5033     {
5034         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5035     }
5036     return resultobj;
5037     fail:
5038     return NULL;
5039 }
5040
5041
5042 static PyObject *_wrap_Frame_CreateStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5043     PyObject *resultobj;
5044     wxFrame *arg1 = (wxFrame *) 0 ;
5045     int arg2 = (int) 1 ;
5046     long arg3 = (long) wxDEFAULT_STATUSBAR_STYLE ;
5047     int arg4 = (int) 0 ;
5048     wxString const &arg5_defvalue = wxPyStatusLineNameStr ;
5049     wxString *arg5 = (wxString *) &arg5_defvalue ;
5050     wxStatusBar *result;
5051     bool temp5 = false ;
5052     PyObject * obj0 = 0 ;
5053     PyObject * obj1 = 0 ;
5054     PyObject * obj2 = 0 ;
5055     PyObject * obj3 = 0 ;
5056     PyObject * obj4 = 0 ;
5057     char *kwnames[] = {
5058         (char *) "self",(char *) "number",(char *) "style",(char *) "winid",(char *) "name", NULL
5059     };
5060
5061     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Frame_CreateStatusBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5062     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5063     if (SWIG_arg_fail(1)) SWIG_fail;
5064     if (obj1) {
5065         {
5066             arg2 = (int)(SWIG_As_int(obj1));
5067             if (SWIG_arg_fail(2)) SWIG_fail;
5068         }
5069     }
5070     if (obj2) {
5071         {
5072             arg3 = (long)(SWIG_As_long(obj2));
5073             if (SWIG_arg_fail(3)) SWIG_fail;
5074         }
5075     }
5076     if (obj3) {
5077         {
5078             arg4 = (int)(SWIG_As_int(obj3));
5079             if (SWIG_arg_fail(4)) SWIG_fail;
5080         }
5081     }
5082     if (obj4) {
5083         {
5084             arg5 = wxString_in_helper(obj4);
5085             if (arg5 == NULL) SWIG_fail;
5086             temp5 = true;
5087         }
5088     }
5089     {
5090         PyThreadState* __tstate = wxPyBeginAllowThreads();
5091         result = (wxStatusBar *)(arg1)->CreateStatusBar(arg2,arg3,arg4,(wxString const &)*arg5);
5092
5093         wxPyEndAllowThreads(__tstate);
5094         if (PyErr_Occurred()) SWIG_fail;
5095     }
5096     {
5097         resultobj = wxPyMake_wxObject(result, 0);
5098     }
5099     {
5100         if (temp5)
5101         delete arg5;
5102     }
5103     return resultobj;
5104     fail:
5105     {
5106         if (temp5)
5107         delete arg5;
5108     }
5109     return NULL;
5110 }
5111
5112
5113 static PyObject *_wrap_Frame_GetStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5114     PyObject *resultobj;
5115     wxFrame *arg1 = (wxFrame *) 0 ;
5116     wxStatusBar *result;
5117     PyObject * obj0 = 0 ;
5118     char *kwnames[] = {
5119         (char *) "self", NULL
5120     };
5121
5122     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetStatusBar",kwnames,&obj0)) goto fail;
5123     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5124     if (SWIG_arg_fail(1)) SWIG_fail;
5125     {
5126         PyThreadState* __tstate = wxPyBeginAllowThreads();
5127         result = (wxStatusBar *)((wxFrame const *)arg1)->GetStatusBar();
5128
5129         wxPyEndAllowThreads(__tstate);
5130         if (PyErr_Occurred()) SWIG_fail;
5131     }
5132     {
5133         resultobj = wxPyMake_wxObject(result, 0);
5134     }
5135     return resultobj;
5136     fail:
5137     return NULL;
5138 }
5139
5140
5141 static PyObject *_wrap_Frame_SetStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
5142     PyObject *resultobj;
5143     wxFrame *arg1 = (wxFrame *) 0 ;
5144     wxStatusBar *arg2 = (wxStatusBar *) 0 ;
5145     PyObject * obj0 = 0 ;
5146     PyObject * obj1 = 0 ;
5147     char *kwnames[] = {
5148         (char *) "self",(char *) "statBar", NULL
5149     };
5150
5151     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusBar",kwnames,&obj0,&obj1)) goto fail;
5152     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5153     if (SWIG_arg_fail(1)) SWIG_fail;
5154     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
5155     if (SWIG_arg_fail(2)) SWIG_fail;
5156     {
5157         PyThreadState* __tstate = wxPyBeginAllowThreads();
5158         (arg1)->SetStatusBar(arg2);
5159
5160         wxPyEndAllowThreads(__tstate);
5161         if (PyErr_Occurred()) SWIG_fail;
5162     }
5163     Py_INCREF(Py_None); resultobj = Py_None;
5164     return resultobj;
5165     fail:
5166     return NULL;
5167 }
5168
5169
5170 static PyObject *_wrap_Frame_SetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5171     PyObject *resultobj;
5172     wxFrame *arg1 = (wxFrame *) 0 ;
5173     wxString *arg2 = 0 ;
5174     int arg3 = (int) 0 ;
5175     bool temp2 = false ;
5176     PyObject * obj0 = 0 ;
5177     PyObject * obj1 = 0 ;
5178     PyObject * obj2 = 0 ;
5179     char *kwnames[] = {
5180         (char *) "self",(char *) "text",(char *) "number", NULL
5181     };
5182
5183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Frame_SetStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
5184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5185     if (SWIG_arg_fail(1)) SWIG_fail;
5186     {
5187         arg2 = wxString_in_helper(obj1);
5188         if (arg2 == NULL) SWIG_fail;
5189         temp2 = true;
5190     }
5191     if (obj2) {
5192         {
5193             arg3 = (int)(SWIG_As_int(obj2));
5194             if (SWIG_arg_fail(3)) SWIG_fail;
5195         }
5196     }
5197     {
5198         PyThreadState* __tstate = wxPyBeginAllowThreads();
5199         (arg1)->SetStatusText((wxString const &)*arg2,arg3);
5200
5201         wxPyEndAllowThreads(__tstate);
5202         if (PyErr_Occurred()) SWIG_fail;
5203     }
5204     Py_INCREF(Py_None); resultobj = Py_None;
5205     {
5206         if (temp2)
5207         delete arg2;
5208     }
5209     return resultobj;
5210     fail:
5211     {
5212         if (temp2)
5213         delete arg2;
5214     }
5215     return NULL;
5216 }
5217
5218
5219 static PyObject *_wrap_Frame_SetStatusWidths(PyObject *, PyObject *args, PyObject *kwargs) {
5220     PyObject *resultobj;
5221     wxFrame *arg1 = (wxFrame *) 0 ;
5222     int arg2 ;
5223     int *arg3 = (int *) 0 ;
5224     PyObject * obj0 = 0 ;
5225     PyObject * obj1 = 0 ;
5226     char *kwnames[] = {
5227         (char *) "self",(char *) "widths", NULL
5228     };
5229
5230     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusWidths",kwnames,&obj0,&obj1)) goto fail;
5231     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5232     if (SWIG_arg_fail(1)) SWIG_fail;
5233     {
5234         arg2 = PyList_Size(obj1);
5235         arg3 =  int_LIST_helper(obj1);
5236         if (arg3 == NULL) SWIG_fail;
5237     }
5238     {
5239         PyThreadState* __tstate = wxPyBeginAllowThreads();
5240         (arg1)->SetStatusWidths(arg2,(int const *)arg3);
5241
5242         wxPyEndAllowThreads(__tstate);
5243         if (PyErr_Occurred()) SWIG_fail;
5244     }
5245     Py_INCREF(Py_None); resultobj = Py_None;
5246     {
5247         if (arg3) delete [] arg3;
5248     }
5249     return resultobj;
5250     fail:
5251     {
5252         if (arg3) delete [] arg3;
5253     }
5254     return NULL;
5255 }
5256
5257
5258 static PyObject *_wrap_Frame_PushStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5259     PyObject *resultobj;
5260     wxFrame *arg1 = (wxFrame *) 0 ;
5261     wxString *arg2 = 0 ;
5262     int arg3 = (int) 0 ;
5263     bool temp2 = false ;
5264     PyObject * obj0 = 0 ;
5265     PyObject * obj1 = 0 ;
5266     PyObject * obj2 = 0 ;
5267     char *kwnames[] = {
5268         (char *) "self",(char *) "text",(char *) "number", NULL
5269     };
5270
5271     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Frame_PushStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
5272     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5273     if (SWIG_arg_fail(1)) SWIG_fail;
5274     {
5275         arg2 = wxString_in_helper(obj1);
5276         if (arg2 == NULL) SWIG_fail;
5277         temp2 = true;
5278     }
5279     if (obj2) {
5280         {
5281             arg3 = (int)(SWIG_As_int(obj2));
5282             if (SWIG_arg_fail(3)) SWIG_fail;
5283         }
5284     }
5285     {
5286         PyThreadState* __tstate = wxPyBeginAllowThreads();
5287         (arg1)->PushStatusText((wxString const &)*arg2,arg3);
5288
5289         wxPyEndAllowThreads(__tstate);
5290         if (PyErr_Occurred()) SWIG_fail;
5291     }
5292     Py_INCREF(Py_None); resultobj = Py_None;
5293     {
5294         if (temp2)
5295         delete arg2;
5296     }
5297     return resultobj;
5298     fail:
5299     {
5300         if (temp2)
5301         delete arg2;
5302     }
5303     return NULL;
5304 }
5305
5306
5307 static PyObject *_wrap_Frame_PopStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
5308     PyObject *resultobj;
5309     wxFrame *arg1 = (wxFrame *) 0 ;
5310     int arg2 = (int) 0 ;
5311     PyObject * obj0 = 0 ;
5312     PyObject * obj1 = 0 ;
5313     char *kwnames[] = {
5314         (char *) "self",(char *) "number", NULL
5315     };
5316
5317     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Frame_PopStatusText",kwnames,&obj0,&obj1)) goto fail;
5318     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5319     if (SWIG_arg_fail(1)) SWIG_fail;
5320     if (obj1) {
5321         {
5322             arg2 = (int)(SWIG_As_int(obj1));
5323             if (SWIG_arg_fail(2)) SWIG_fail;
5324         }
5325     }
5326     {
5327         PyThreadState* __tstate = wxPyBeginAllowThreads();
5328         (arg1)->PopStatusText(arg2);
5329
5330         wxPyEndAllowThreads(__tstate);
5331         if (PyErr_Occurred()) SWIG_fail;
5332     }
5333     Py_INCREF(Py_None); resultobj = Py_None;
5334     return resultobj;
5335     fail:
5336     return NULL;
5337 }
5338
5339
5340 static PyObject *_wrap_Frame_SetStatusBarPane(PyObject *, PyObject *args, PyObject *kwargs) {
5341     PyObject *resultobj;
5342     wxFrame *arg1 = (wxFrame *) 0 ;
5343     int arg2 ;
5344     PyObject * obj0 = 0 ;
5345     PyObject * obj1 = 0 ;
5346     char *kwnames[] = {
5347         (char *) "self",(char *) "n", NULL
5348     };
5349
5350     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetStatusBarPane",kwnames,&obj0,&obj1)) goto fail;
5351     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5352     if (SWIG_arg_fail(1)) SWIG_fail;
5353     {
5354         arg2 = (int)(SWIG_As_int(obj1));
5355         if (SWIG_arg_fail(2)) SWIG_fail;
5356     }
5357     {
5358         PyThreadState* __tstate = wxPyBeginAllowThreads();
5359         (arg1)->SetStatusBarPane(arg2);
5360
5361         wxPyEndAllowThreads(__tstate);
5362         if (PyErr_Occurred()) SWIG_fail;
5363     }
5364     Py_INCREF(Py_None); resultobj = Py_None;
5365     return resultobj;
5366     fail:
5367     return NULL;
5368 }
5369
5370
5371 static PyObject *_wrap_Frame_GetStatusBarPane(PyObject *, PyObject *args, PyObject *kwargs) {
5372     PyObject *resultobj;
5373     wxFrame *arg1 = (wxFrame *) 0 ;
5374     int result;
5375     PyObject * obj0 = 0 ;
5376     char *kwnames[] = {
5377         (char *) "self", NULL
5378     };
5379
5380     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetStatusBarPane",kwnames,&obj0)) goto fail;
5381     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5382     if (SWIG_arg_fail(1)) SWIG_fail;
5383     {
5384         PyThreadState* __tstate = wxPyBeginAllowThreads();
5385         result = (int)((wxFrame const *)arg1)->GetStatusBarPane();
5386
5387         wxPyEndAllowThreads(__tstate);
5388         if (PyErr_Occurred()) SWIG_fail;
5389     }
5390     {
5391         resultobj = SWIG_From_int((int)(result));
5392     }
5393     return resultobj;
5394     fail:
5395     return NULL;
5396 }
5397
5398
5399 static PyObject *_wrap_Frame_CreateToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5400     PyObject *resultobj;
5401     wxFrame *arg1 = (wxFrame *) 0 ;
5402     long arg2 = (long) -1 ;
5403     int arg3 = (int) -1 ;
5404     wxString const &arg4_defvalue = wxPyToolBarNameStr ;
5405     wxString *arg4 = (wxString *) &arg4_defvalue ;
5406     wxToolBar *result;
5407     bool temp4 = false ;
5408     PyObject * obj0 = 0 ;
5409     PyObject * obj1 = 0 ;
5410     PyObject * obj2 = 0 ;
5411     PyObject * obj3 = 0 ;
5412     char *kwnames[] = {
5413         (char *) "self",(char *) "style",(char *) "winid",(char *) "name", NULL
5414     };
5415
5416     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Frame_CreateToolBar",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5417     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5418     if (SWIG_arg_fail(1)) SWIG_fail;
5419     if (obj1) {
5420         {
5421             arg2 = (long)(SWIG_As_long(obj1));
5422             if (SWIG_arg_fail(2)) SWIG_fail;
5423         }
5424     }
5425     if (obj2) {
5426         {
5427             arg3 = (int)(SWIG_As_int(obj2));
5428             if (SWIG_arg_fail(3)) SWIG_fail;
5429         }
5430     }
5431     if (obj3) {
5432         {
5433             arg4 = wxString_in_helper(obj3);
5434             if (arg4 == NULL) SWIG_fail;
5435             temp4 = true;
5436         }
5437     }
5438     {
5439         PyThreadState* __tstate = wxPyBeginAllowThreads();
5440         result = (wxToolBar *)(arg1)->CreateToolBar(arg2,arg3,(wxString const &)*arg4);
5441
5442         wxPyEndAllowThreads(__tstate);
5443         if (PyErr_Occurred()) SWIG_fail;
5444     }
5445     {
5446         resultobj = wxPyMake_wxObject(result, 0);
5447     }
5448     {
5449         if (temp4)
5450         delete arg4;
5451     }
5452     return resultobj;
5453     fail:
5454     {
5455         if (temp4)
5456         delete arg4;
5457     }
5458     return NULL;
5459 }
5460
5461
5462 static PyObject *_wrap_Frame_GetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5463     PyObject *resultobj;
5464     wxFrame *arg1 = (wxFrame *) 0 ;
5465     wxToolBar *result;
5466     PyObject * obj0 = 0 ;
5467     char *kwnames[] = {
5468         (char *) "self", NULL
5469     };
5470
5471     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Frame_GetToolBar",kwnames,&obj0)) goto fail;
5472     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5473     if (SWIG_arg_fail(1)) SWIG_fail;
5474     {
5475         PyThreadState* __tstate = wxPyBeginAllowThreads();
5476         result = (wxToolBar *)((wxFrame const *)arg1)->GetToolBar();
5477
5478         wxPyEndAllowThreads(__tstate);
5479         if (PyErr_Occurred()) SWIG_fail;
5480     }
5481     {
5482         resultobj = wxPyMake_wxObject(result, 0);
5483     }
5484     return resultobj;
5485     fail:
5486     return NULL;
5487 }
5488
5489
5490 static PyObject *_wrap_Frame_SetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
5491     PyObject *resultobj;
5492     wxFrame *arg1 = (wxFrame *) 0 ;
5493     wxToolBar *arg2 = (wxToolBar *) 0 ;
5494     PyObject * obj0 = 0 ;
5495     PyObject * obj1 = 0 ;
5496     char *kwnames[] = {
5497         (char *) "self",(char *) "toolbar", NULL
5498     };
5499
5500     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Frame_SetToolBar",kwnames,&obj0,&obj1)) goto fail;
5501     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5502     if (SWIG_arg_fail(1)) SWIG_fail;
5503     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolBar, SWIG_POINTER_EXCEPTION | 0);
5504     if (SWIG_arg_fail(2)) SWIG_fail;
5505     {
5506         PyThreadState* __tstate = wxPyBeginAllowThreads();
5507         (arg1)->SetToolBar(arg2);
5508
5509         wxPyEndAllowThreads(__tstate);
5510         if (PyErr_Occurred()) SWIG_fail;
5511     }
5512     Py_INCREF(Py_None); resultobj = Py_None;
5513     return resultobj;
5514     fail:
5515     return NULL;
5516 }
5517
5518
5519 static PyObject *_wrap_Frame_DoGiveHelp(PyObject *, PyObject *args, PyObject *kwargs) {
5520     PyObject *resultobj;
5521     wxFrame *arg1 = (wxFrame *) 0 ;
5522     wxString *arg2 = 0 ;
5523     bool arg3 ;
5524     bool temp2 = false ;
5525     PyObject * obj0 = 0 ;
5526     PyObject * obj1 = 0 ;
5527     PyObject * obj2 = 0 ;
5528     char *kwnames[] = {
5529         (char *) "self",(char *) "text",(char *) "show", NULL
5530     };
5531
5532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Frame_DoGiveHelp",kwnames,&obj0,&obj1,&obj2)) goto fail;
5533     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5534     if (SWIG_arg_fail(1)) SWIG_fail;
5535     {
5536         arg2 = wxString_in_helper(obj1);
5537         if (arg2 == NULL) SWIG_fail;
5538         temp2 = true;
5539     }
5540     {
5541         arg3 = (bool)(SWIG_As_bool(obj2));
5542         if (SWIG_arg_fail(3)) SWIG_fail;
5543     }
5544     {
5545         PyThreadState* __tstate = wxPyBeginAllowThreads();
5546         (arg1)->DoGiveHelp((wxString const &)*arg2,arg3);
5547
5548         wxPyEndAllowThreads(__tstate);
5549         if (PyErr_Occurred()) SWIG_fail;
5550     }
5551     Py_INCREF(Py_None); resultobj = Py_None;
5552     {
5553         if (temp2)
5554         delete arg2;
5555     }
5556     return resultobj;
5557     fail:
5558     {
5559         if (temp2)
5560         delete arg2;
5561     }
5562     return NULL;
5563 }
5564
5565
5566 static PyObject *_wrap_Frame_DoMenuUpdates(PyObject *, PyObject *args, PyObject *kwargs) {
5567     PyObject *resultobj;
5568     wxFrame *arg1 = (wxFrame *) 0 ;
5569     wxMenu *arg2 = (wxMenu *) NULL ;
5570     PyObject * obj0 = 0 ;
5571     PyObject * obj1 = 0 ;
5572     char *kwnames[] = {
5573         (char *) "self",(char *) "menu", NULL
5574     };
5575
5576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Frame_DoMenuUpdates",kwnames,&obj0,&obj1)) goto fail;
5577     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
5578     if (SWIG_arg_fail(1)) SWIG_fail;
5579     if (obj1) {
5580         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
5581         if (SWIG_arg_fail(2)) SWIG_fail;
5582     }
5583     {
5584         PyThreadState* __tstate = wxPyBeginAllowThreads();
5585         (arg1)->DoMenuUpdates(arg2);
5586
5587         wxPyEndAllowThreads(__tstate);
5588         if (PyErr_Occurred()) SWIG_fail;
5589     }
5590     Py_INCREF(Py_None); resultobj = Py_None;
5591     return resultobj;
5592     fail:
5593     return NULL;
5594 }
5595
5596
5597 static PyObject *_wrap_Frame_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
5598     PyObject *resultobj;
5599     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
5600     wxVisualAttributes result;
5601     PyObject * obj0 = 0 ;
5602     char *kwnames[] = {
5603         (char *) "variant", NULL
5604     };
5605
5606     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Frame_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
5607     if (obj0) {
5608         {
5609             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
5610             if (SWIG_arg_fail(1)) SWIG_fail;
5611         }
5612     }
5613     {
5614         if (!wxPyCheckForApp()) SWIG_fail;
5615         PyThreadState* __tstate = wxPyBeginAllowThreads();
5616         result = wxFrame::GetClassDefaultAttributes((wxWindowVariant )arg1);
5617
5618         wxPyEndAllowThreads(__tstate);
5619         if (PyErr_Occurred()) SWIG_fail;
5620     }
5621     {
5622         wxVisualAttributes * resultptr;
5623         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
5624         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
5625     }
5626     return resultobj;
5627     fail:
5628     return NULL;
5629 }
5630
5631
5632 static PyObject * Frame_swigregister(PyObject *, PyObject *args) {
5633     PyObject *obj;
5634     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5635     SWIG_TypeClientData(SWIGTYPE_p_wxFrame, obj);
5636     Py_INCREF(obj);
5637     return Py_BuildValue((char *)"");
5638 }
5639 static PyObject *_wrap_new_Dialog(PyObject *, PyObject *args, PyObject *kwargs) {
5640     PyObject *resultobj;
5641     wxWindow *arg1 = (wxWindow *) 0 ;
5642     int arg2 = (int) (int)-1 ;
5643     wxString const &arg3_defvalue = wxPyEmptyString ;
5644     wxString *arg3 = (wxString *) &arg3_defvalue ;
5645     wxPoint const &arg4_defvalue = wxDefaultPosition ;
5646     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5647     wxSize const &arg5_defvalue = wxDefaultSize ;
5648     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
5649     long arg6 = (long) wxDEFAULT_DIALOG_STYLE ;
5650     wxString const &arg7_defvalue = wxPyDialogNameStr ;
5651     wxString *arg7 = (wxString *) &arg7_defvalue ;
5652     wxDialog *result;
5653     bool temp3 = false ;
5654     wxPoint temp4 ;
5655     wxSize temp5 ;
5656     bool temp7 = false ;
5657     PyObject * obj0 = 0 ;
5658     PyObject * obj1 = 0 ;
5659     PyObject * obj2 = 0 ;
5660     PyObject * obj3 = 0 ;
5661     PyObject * obj4 = 0 ;
5662     PyObject * obj5 = 0 ;
5663     PyObject * obj6 = 0 ;
5664     char *kwnames[] = {
5665         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
5666     };
5667
5668     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Dialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5669     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5670     if (SWIG_arg_fail(1)) SWIG_fail;
5671     if (obj1) {
5672         {
5673             arg2 = (int const)(SWIG_As_int(obj1));
5674             if (SWIG_arg_fail(2)) SWIG_fail;
5675         }
5676     }
5677     if (obj2) {
5678         {
5679             arg3 = wxString_in_helper(obj2);
5680             if (arg3 == NULL) SWIG_fail;
5681             temp3 = true;
5682         }
5683     }
5684     if (obj3) {
5685         {
5686             arg4 = &temp4;
5687             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5688         }
5689     }
5690     if (obj4) {
5691         {
5692             arg5 = &temp5;
5693             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
5694         }
5695     }
5696     if (obj5) {
5697         {
5698             arg6 = (long)(SWIG_As_long(obj5));
5699             if (SWIG_arg_fail(6)) SWIG_fail;
5700         }
5701     }
5702     if (obj6) {
5703         {
5704             arg7 = wxString_in_helper(obj6);
5705             if (arg7 == NULL) SWIG_fail;
5706             temp7 = true;
5707         }
5708     }
5709     {
5710         if (!wxPyCheckForApp()) SWIG_fail;
5711         PyThreadState* __tstate = wxPyBeginAllowThreads();
5712         result = (wxDialog *)new wxDialog(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
5713
5714         wxPyEndAllowThreads(__tstate);
5715         if (PyErr_Occurred()) SWIG_fail;
5716     }
5717     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDialog, 1);
5718     {
5719         if (temp3)
5720         delete arg3;
5721     }
5722     {
5723         if (temp7)
5724         delete arg7;
5725     }
5726     return resultobj;
5727     fail:
5728     {
5729         if (temp3)
5730         delete arg3;
5731     }
5732     {
5733         if (temp7)
5734         delete arg7;
5735     }
5736     return NULL;
5737 }
5738
5739
5740 static PyObject *_wrap_new_PreDialog(PyObject *, PyObject *args, PyObject *kwargs) {
5741     PyObject *resultobj;
5742     wxDialog *result;
5743     char *kwnames[] = {
5744         NULL
5745     };
5746
5747     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreDialog",kwnames)) goto fail;
5748     {
5749         if (!wxPyCheckForApp()) SWIG_fail;
5750         PyThreadState* __tstate = wxPyBeginAllowThreads();
5751         result = (wxDialog *)new wxDialog();
5752
5753         wxPyEndAllowThreads(__tstate);
5754         if (PyErr_Occurred()) SWIG_fail;
5755     }
5756     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDialog, 1);
5757     return resultobj;
5758     fail:
5759     return NULL;
5760 }
5761
5762
5763 static PyObject *_wrap_Dialog_Create(PyObject *, PyObject *args, PyObject *kwargs) {
5764     PyObject *resultobj;
5765     wxDialog *arg1 = (wxDialog *) 0 ;
5766     wxWindow *arg2 = (wxWindow *) 0 ;
5767     int arg3 = (int) (int)-1 ;
5768     wxString const &arg4_defvalue = wxPyEmptyString ;
5769     wxString *arg4 = (wxString *) &arg4_defvalue ;
5770     wxPoint const &arg5_defvalue = wxDefaultPosition ;
5771     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
5772     wxSize const &arg6_defvalue = wxDefaultSize ;
5773     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
5774     long arg7 = (long) wxDEFAULT_DIALOG_STYLE ;
5775     wxString const &arg8_defvalue = wxPyDialogNameStr ;
5776     wxString *arg8 = (wxString *) &arg8_defvalue ;
5777     bool result;
5778     bool temp4 = false ;
5779     wxPoint temp5 ;
5780     wxSize temp6 ;
5781     bool temp8 = false ;
5782     PyObject * obj0 = 0 ;
5783     PyObject * obj1 = 0 ;
5784     PyObject * obj2 = 0 ;
5785     PyObject * obj3 = 0 ;
5786     PyObject * obj4 = 0 ;
5787     PyObject * obj5 = 0 ;
5788     PyObject * obj6 = 0 ;
5789     PyObject * obj7 = 0 ;
5790     char *kwnames[] = {
5791         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
5792     };
5793
5794     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Dialog_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5795     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5796     if (SWIG_arg_fail(1)) SWIG_fail;
5797     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5798     if (SWIG_arg_fail(2)) SWIG_fail;
5799     if (obj2) {
5800         {
5801             arg3 = (int const)(SWIG_As_int(obj2));
5802             if (SWIG_arg_fail(3)) SWIG_fail;
5803         }
5804     }
5805     if (obj3) {
5806         {
5807             arg4 = wxString_in_helper(obj3);
5808             if (arg4 == NULL) SWIG_fail;
5809             temp4 = true;
5810         }
5811     }
5812     if (obj4) {
5813         {
5814             arg5 = &temp5;
5815             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
5816         }
5817     }
5818     if (obj5) {
5819         {
5820             arg6 = &temp6;
5821             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
5822         }
5823     }
5824     if (obj6) {
5825         {
5826             arg7 = (long)(SWIG_As_long(obj6));
5827             if (SWIG_arg_fail(7)) SWIG_fail;
5828         }
5829     }
5830     if (obj7) {
5831         {
5832             arg8 = wxString_in_helper(obj7);
5833             if (arg8 == NULL) SWIG_fail;
5834             temp8 = true;
5835         }
5836     }
5837     {
5838         PyThreadState* __tstate = wxPyBeginAllowThreads();
5839         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
5840
5841         wxPyEndAllowThreads(__tstate);
5842         if (PyErr_Occurred()) SWIG_fail;
5843     }
5844     {
5845         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5846     }
5847     {
5848         if (temp4)
5849         delete arg4;
5850     }
5851     {
5852         if (temp8)
5853         delete arg8;
5854     }
5855     return resultobj;
5856     fail:
5857     {
5858         if (temp4)
5859         delete arg4;
5860     }
5861     {
5862         if (temp8)
5863         delete arg8;
5864     }
5865     return NULL;
5866 }
5867
5868
5869 static PyObject *_wrap_Dialog_SetReturnCode(PyObject *, PyObject *args, PyObject *kwargs) {
5870     PyObject *resultobj;
5871     wxDialog *arg1 = (wxDialog *) 0 ;
5872     int arg2 ;
5873     PyObject * obj0 = 0 ;
5874     PyObject * obj1 = 0 ;
5875     char *kwnames[] = {
5876         (char *) "self",(char *) "returnCode", NULL
5877     };
5878
5879     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_SetReturnCode",kwnames,&obj0,&obj1)) goto fail;
5880     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5881     if (SWIG_arg_fail(1)) SWIG_fail;
5882     {
5883         arg2 = (int)(SWIG_As_int(obj1));
5884         if (SWIG_arg_fail(2)) SWIG_fail;
5885     }
5886     {
5887         PyThreadState* __tstate = wxPyBeginAllowThreads();
5888         (arg1)->SetReturnCode(arg2);
5889
5890         wxPyEndAllowThreads(__tstate);
5891         if (PyErr_Occurred()) SWIG_fail;
5892     }
5893     Py_INCREF(Py_None); resultobj = Py_None;
5894     return resultobj;
5895     fail:
5896     return NULL;
5897 }
5898
5899
5900 static PyObject *_wrap_Dialog_GetReturnCode(PyObject *, PyObject *args, PyObject *kwargs) {
5901     PyObject *resultobj;
5902     wxDialog *arg1 = (wxDialog *) 0 ;
5903     int result;
5904     PyObject * obj0 = 0 ;
5905     char *kwnames[] = {
5906         (char *) "self", NULL
5907     };
5908
5909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_GetReturnCode",kwnames,&obj0)) goto fail;
5910     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5911     if (SWIG_arg_fail(1)) SWIG_fail;
5912     {
5913         PyThreadState* __tstate = wxPyBeginAllowThreads();
5914         result = (int)((wxDialog const *)arg1)->GetReturnCode();
5915
5916         wxPyEndAllowThreads(__tstate);
5917         if (PyErr_Occurred()) SWIG_fail;
5918     }
5919     {
5920         resultobj = SWIG_From_int((int)(result));
5921     }
5922     return resultobj;
5923     fail:
5924     return NULL;
5925 }
5926
5927
5928 static PyObject *_wrap_Dialog_CreateTextSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5929     PyObject *resultobj;
5930     wxDialog *arg1 = (wxDialog *) 0 ;
5931     wxString *arg2 = 0 ;
5932     wxSizer *result;
5933     bool temp2 = false ;
5934     PyObject * obj0 = 0 ;
5935     PyObject * obj1 = 0 ;
5936     char *kwnames[] = {
5937         (char *) "self",(char *) "message", NULL
5938     };
5939
5940     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateTextSizer",kwnames,&obj0,&obj1)) goto fail;
5941     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5942     if (SWIG_arg_fail(1)) SWIG_fail;
5943     {
5944         arg2 = wxString_in_helper(obj1);
5945         if (arg2 == NULL) SWIG_fail;
5946         temp2 = true;
5947     }
5948     {
5949         PyThreadState* __tstate = wxPyBeginAllowThreads();
5950         result = (wxSizer *)(arg1)->CreateTextSizer((wxString const &)*arg2);
5951
5952         wxPyEndAllowThreads(__tstate);
5953         if (PyErr_Occurred()) SWIG_fail;
5954     }
5955     {
5956         resultobj = wxPyMake_wxObject(result, 0);
5957     }
5958     {
5959         if (temp2)
5960         delete arg2;
5961     }
5962     return resultobj;
5963     fail:
5964     {
5965         if (temp2)
5966         delete arg2;
5967     }
5968     return NULL;
5969 }
5970
5971
5972 static PyObject *_wrap_Dialog_CreateButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
5973     PyObject *resultobj;
5974     wxDialog *arg1 = (wxDialog *) 0 ;
5975     long arg2 ;
5976     wxSizer *result;
5977     PyObject * obj0 = 0 ;
5978     PyObject * obj1 = 0 ;
5979     char *kwnames[] = {
5980         (char *) "self",(char *) "flags", NULL
5981     };
5982
5983     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateButtonSizer",kwnames,&obj0,&obj1)) goto fail;
5984     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
5985     if (SWIG_arg_fail(1)) SWIG_fail;
5986     {
5987         arg2 = (long)(SWIG_As_long(obj1));
5988         if (SWIG_arg_fail(2)) SWIG_fail;
5989     }
5990     {
5991         PyThreadState* __tstate = wxPyBeginAllowThreads();
5992         result = (wxSizer *)(arg1)->CreateButtonSizer(arg2);
5993
5994         wxPyEndAllowThreads(__tstate);
5995         if (PyErr_Occurred()) SWIG_fail;
5996     }
5997     {
5998         resultobj = wxPyMake_wxObject(result, 0);
5999     }
6000     return resultobj;
6001     fail:
6002     return NULL;
6003 }
6004
6005
6006 static PyObject *_wrap_Dialog_CreateStdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
6007     PyObject *resultobj;
6008     wxDialog *arg1 = (wxDialog *) 0 ;
6009     long arg2 ;
6010     wxStdDialogButtonSizer *result;
6011     PyObject * obj0 = 0 ;
6012     PyObject * obj1 = 0 ;
6013     char *kwnames[] = {
6014         (char *) "self",(char *) "flags", NULL
6015     };
6016
6017     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_CreateStdDialogButtonSizer",kwnames,&obj0,&obj1)) goto fail;
6018     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6019     if (SWIG_arg_fail(1)) SWIG_fail;
6020     {
6021         arg2 = (long)(SWIG_As_long(obj1));
6022         if (SWIG_arg_fail(2)) SWIG_fail;
6023     }
6024     {
6025         PyThreadState* __tstate = wxPyBeginAllowThreads();
6026         result = (wxStdDialogButtonSizer *)(arg1)->CreateStdDialogButtonSizer(arg2);
6027
6028         wxPyEndAllowThreads(__tstate);
6029         if (PyErr_Occurred()) SWIG_fail;
6030     }
6031     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 0);
6032     return resultobj;
6033     fail:
6034     return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_Dialog_IsModal(PyObject *, PyObject *args, PyObject *kwargs) {
6039     PyObject *resultobj;
6040     wxDialog *arg1 = (wxDialog *) 0 ;
6041     bool result;
6042     PyObject * obj0 = 0 ;
6043     char *kwnames[] = {
6044         (char *) "self", NULL
6045     };
6046
6047     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_IsModal",kwnames,&obj0)) goto fail;
6048     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6049     if (SWIG_arg_fail(1)) SWIG_fail;
6050     {
6051         PyThreadState* __tstate = wxPyBeginAllowThreads();
6052         result = (bool)((wxDialog const *)arg1)->IsModal();
6053
6054         wxPyEndAllowThreads(__tstate);
6055         if (PyErr_Occurred()) SWIG_fail;
6056     }
6057     {
6058         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6059     }
6060     return resultobj;
6061     fail:
6062     return NULL;
6063 }
6064
6065
6066 static PyObject *_wrap_Dialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
6067     PyObject *resultobj;
6068     wxDialog *arg1 = (wxDialog *) 0 ;
6069     int result;
6070     PyObject * obj0 = 0 ;
6071     char *kwnames[] = {
6072         (char *) "self", NULL
6073     };
6074
6075     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Dialog_ShowModal",kwnames,&obj0)) goto fail;
6076     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6077     if (SWIG_arg_fail(1)) SWIG_fail;
6078     {
6079         PyThreadState* __tstate = wxPyBeginAllowThreads();
6080         result = (int)(arg1)->ShowModal();
6081
6082         wxPyEndAllowThreads(__tstate);
6083         if (PyErr_Occurred()) SWIG_fail;
6084     }
6085     {
6086         resultobj = SWIG_From_int((int)(result));
6087     }
6088     return resultobj;
6089     fail:
6090     return NULL;
6091 }
6092
6093
6094 static PyObject *_wrap_Dialog_EndModal(PyObject *, PyObject *args, PyObject *kwargs) {
6095     PyObject *resultobj;
6096     wxDialog *arg1 = (wxDialog *) 0 ;
6097     int arg2 ;
6098     PyObject * obj0 = 0 ;
6099     PyObject * obj1 = 0 ;
6100     char *kwnames[] = {
6101         (char *) "self",(char *) "retCode", NULL
6102     };
6103
6104     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dialog_EndModal",kwnames,&obj0,&obj1)) goto fail;
6105     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDialog, SWIG_POINTER_EXCEPTION | 0);
6106     if (SWIG_arg_fail(1)) SWIG_fail;
6107     {
6108         arg2 = (int)(SWIG_As_int(obj1));
6109         if (SWIG_arg_fail(2)) SWIG_fail;
6110     }
6111     {
6112         PyThreadState* __tstate = wxPyBeginAllowThreads();
6113         (arg1)->EndModal(arg2);
6114
6115         wxPyEndAllowThreads(__tstate);
6116         if (PyErr_Occurred()) SWIG_fail;
6117     }
6118     Py_INCREF(Py_None); resultobj = Py_None;
6119     return resultobj;
6120     fail:
6121     return NULL;
6122 }
6123
6124
6125 static PyObject *_wrap_Dialog_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
6126     PyObject *resultobj;
6127     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
6128     wxVisualAttributes result;
6129     PyObject * obj0 = 0 ;
6130     char *kwnames[] = {
6131         (char *) "variant", NULL
6132     };
6133
6134     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Dialog_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
6135     if (obj0) {
6136         {
6137             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
6138             if (SWIG_arg_fail(1)) SWIG_fail;
6139         }
6140     }
6141     {
6142         if (!wxPyCheckForApp()) SWIG_fail;
6143         PyThreadState* __tstate = wxPyBeginAllowThreads();
6144         result = wxDialog::GetClassDefaultAttributes((wxWindowVariant )arg1);
6145
6146         wxPyEndAllowThreads(__tstate);
6147         if (PyErr_Occurred()) SWIG_fail;
6148     }
6149     {
6150         wxVisualAttributes * resultptr;
6151         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
6152         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
6153     }
6154     return resultobj;
6155     fail:
6156     return NULL;
6157 }
6158
6159
6160 static PyObject * Dialog_swigregister(PyObject *, PyObject *args) {
6161     PyObject *obj;
6162     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6163     SWIG_TypeClientData(SWIGTYPE_p_wxDialog, obj);
6164     Py_INCREF(obj);
6165     return Py_BuildValue((char *)"");
6166 }
6167 static PyObject *_wrap_new_MiniFrame(PyObject *, PyObject *args, PyObject *kwargs) {
6168     PyObject *resultobj;
6169     wxWindow *arg1 = (wxWindow *) 0 ;
6170     int arg2 = (int) (int)-1 ;
6171     wxString const &arg3_defvalue = wxPyEmptyString ;
6172     wxString *arg3 = (wxString *) &arg3_defvalue ;
6173     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6174     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6175     wxSize const &arg5_defvalue = wxDefaultSize ;
6176     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6177     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
6178     wxString const &arg7_defvalue = wxPyFrameNameStr ;
6179     wxString *arg7 = (wxString *) &arg7_defvalue ;
6180     wxMiniFrame *result;
6181     bool temp3 = false ;
6182     wxPoint temp4 ;
6183     wxSize temp5 ;
6184     bool temp7 = false ;
6185     PyObject * obj0 = 0 ;
6186     PyObject * obj1 = 0 ;
6187     PyObject * obj2 = 0 ;
6188     PyObject * obj3 = 0 ;
6189     PyObject * obj4 = 0 ;
6190     PyObject * obj5 = 0 ;
6191     PyObject * obj6 = 0 ;
6192     char *kwnames[] = {
6193         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6194     };
6195
6196     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MiniFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
6197     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6198     if (SWIG_arg_fail(1)) SWIG_fail;
6199     if (obj1) {
6200         {
6201             arg2 = (int const)(SWIG_As_int(obj1));
6202             if (SWIG_arg_fail(2)) SWIG_fail;
6203         }
6204     }
6205     if (obj2) {
6206         {
6207             arg3 = wxString_in_helper(obj2);
6208             if (arg3 == NULL) SWIG_fail;
6209             temp3 = true;
6210         }
6211     }
6212     if (obj3) {
6213         {
6214             arg4 = &temp4;
6215             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6216         }
6217     }
6218     if (obj4) {
6219         {
6220             arg5 = &temp5;
6221             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6222         }
6223     }
6224     if (obj5) {
6225         {
6226             arg6 = (long)(SWIG_As_long(obj5));
6227             if (SWIG_arg_fail(6)) SWIG_fail;
6228         }
6229     }
6230     if (obj6) {
6231         {
6232             arg7 = wxString_in_helper(obj6);
6233             if (arg7 == NULL) SWIG_fail;
6234             temp7 = true;
6235         }
6236     }
6237     {
6238         if (!wxPyCheckForApp()) SWIG_fail;
6239         PyThreadState* __tstate = wxPyBeginAllowThreads();
6240         result = (wxMiniFrame *)new wxMiniFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
6241
6242         wxPyEndAllowThreads(__tstate);
6243         if (PyErr_Occurred()) SWIG_fail;
6244     }
6245     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMiniFrame, 1);
6246     {
6247         if (temp3)
6248         delete arg3;
6249     }
6250     {
6251         if (temp7)
6252         delete arg7;
6253     }
6254     return resultobj;
6255     fail:
6256     {
6257         if (temp3)
6258         delete arg3;
6259     }
6260     {
6261         if (temp7)
6262         delete arg7;
6263     }
6264     return NULL;
6265 }
6266
6267
6268 static PyObject *_wrap_new_PreMiniFrame(PyObject *, PyObject *args, PyObject *kwargs) {
6269     PyObject *resultobj;
6270     wxMiniFrame *result;
6271     char *kwnames[] = {
6272         NULL
6273     };
6274
6275     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMiniFrame",kwnames)) goto fail;
6276     {
6277         if (!wxPyCheckForApp()) SWIG_fail;
6278         PyThreadState* __tstate = wxPyBeginAllowThreads();
6279         result = (wxMiniFrame *)new wxMiniFrame();
6280
6281         wxPyEndAllowThreads(__tstate);
6282         if (PyErr_Occurred()) SWIG_fail;
6283     }
6284     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMiniFrame, 1);
6285     return resultobj;
6286     fail:
6287     return NULL;
6288 }
6289
6290
6291 static PyObject *_wrap_MiniFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6292     PyObject *resultobj;
6293     wxMiniFrame *arg1 = (wxMiniFrame *) 0 ;
6294     wxWindow *arg2 = (wxWindow *) 0 ;
6295     int arg3 = (int) (int)-1 ;
6296     wxString const &arg4_defvalue = wxPyEmptyString ;
6297     wxString *arg4 = (wxString *) &arg4_defvalue ;
6298     wxPoint const &arg5_defvalue = wxDefaultPosition ;
6299     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
6300     wxSize const &arg6_defvalue = wxDefaultSize ;
6301     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
6302     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
6303     wxString const &arg8_defvalue = wxPyFrameNameStr ;
6304     wxString *arg8 = (wxString *) &arg8_defvalue ;
6305     bool result;
6306     bool temp4 = false ;
6307     wxPoint temp5 ;
6308     wxSize temp6 ;
6309     bool temp8 = false ;
6310     PyObject * obj0 = 0 ;
6311     PyObject * obj1 = 0 ;
6312     PyObject * obj2 = 0 ;
6313     PyObject * obj3 = 0 ;
6314     PyObject * obj4 = 0 ;
6315     PyObject * obj5 = 0 ;
6316     PyObject * obj6 = 0 ;
6317     PyObject * obj7 = 0 ;
6318     char *kwnames[] = {
6319         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
6320     };
6321
6322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MiniFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6323     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMiniFrame, SWIG_POINTER_EXCEPTION | 0);
6324     if (SWIG_arg_fail(1)) SWIG_fail;
6325     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6326     if (SWIG_arg_fail(2)) SWIG_fail;
6327     if (obj2) {
6328         {
6329             arg3 = (int const)(SWIG_As_int(obj2));
6330             if (SWIG_arg_fail(3)) SWIG_fail;
6331         }
6332     }
6333     if (obj3) {
6334         {
6335             arg4 = wxString_in_helper(obj3);
6336             if (arg4 == NULL) SWIG_fail;
6337             temp4 = true;
6338         }
6339     }
6340     if (obj4) {
6341         {
6342             arg5 = &temp5;
6343             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
6344         }
6345     }
6346     if (obj5) {
6347         {
6348             arg6 = &temp6;
6349             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
6350         }
6351     }
6352     if (obj6) {
6353         {
6354             arg7 = (long)(SWIG_As_long(obj6));
6355             if (SWIG_arg_fail(7)) SWIG_fail;
6356         }
6357     }
6358     if (obj7) {
6359         {
6360             arg8 = wxString_in_helper(obj7);
6361             if (arg8 == NULL) SWIG_fail;
6362             temp8 = true;
6363         }
6364     }
6365     {
6366         PyThreadState* __tstate = wxPyBeginAllowThreads();
6367         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
6368
6369         wxPyEndAllowThreads(__tstate);
6370         if (PyErr_Occurred()) SWIG_fail;
6371     }
6372     {
6373         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6374     }
6375     {
6376         if (temp4)
6377         delete arg4;
6378     }
6379     {
6380         if (temp8)
6381         delete arg8;
6382     }
6383     return resultobj;
6384     fail:
6385     {
6386         if (temp4)
6387         delete arg4;
6388     }
6389     {
6390         if (temp8)
6391         delete arg8;
6392     }
6393     return NULL;
6394 }
6395
6396
6397 static PyObject * MiniFrame_swigregister(PyObject *, PyObject *args) {
6398     PyObject *obj;
6399     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6400     SWIG_TypeClientData(SWIGTYPE_p_wxMiniFrame, obj);
6401     Py_INCREF(obj);
6402     return Py_BuildValue((char *)"");
6403 }
6404 static PyObject *_wrap_new_SplashScreenWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6405     PyObject *resultobj;
6406     wxBitmap *arg1 = 0 ;
6407     wxWindow *arg2 = (wxWindow *) 0 ;
6408     int arg3 ;
6409     wxPoint const &arg4_defvalue = wxDefaultPosition ;
6410     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
6411     wxSize const &arg5_defvalue = wxDefaultSize ;
6412     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
6413     long arg6 = (long) wxNO_BORDER ;
6414     wxSplashScreenWindow *result;
6415     wxPoint temp4 ;
6416     wxSize temp5 ;
6417     PyObject * obj0 = 0 ;
6418     PyObject * obj1 = 0 ;
6419     PyObject * obj2 = 0 ;
6420     PyObject * obj3 = 0 ;
6421     PyObject * obj4 = 0 ;
6422     PyObject * obj5 = 0 ;
6423     char *kwnames[] = {
6424         (char *) "bitmap",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
6425     };
6426
6427     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:new_SplashScreenWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
6428     {
6429         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6430         if (SWIG_arg_fail(1)) SWIG_fail;
6431         if (arg1 == NULL) {
6432             SWIG_null_ref("wxBitmap");
6433         }
6434         if (SWIG_arg_fail(1)) SWIG_fail;
6435     }
6436     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6437     if (SWIG_arg_fail(2)) SWIG_fail;
6438     {
6439         arg3 = (int)(SWIG_As_int(obj2));
6440         if (SWIG_arg_fail(3)) SWIG_fail;
6441     }
6442     if (obj3) {
6443         {
6444             arg4 = &temp4;
6445             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6446         }
6447     }
6448     if (obj4) {
6449         {
6450             arg5 = &temp5;
6451             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
6452         }
6453     }
6454     if (obj5) {
6455         {
6456             arg6 = (long)(SWIG_As_long(obj5));
6457             if (SWIG_arg_fail(6)) SWIG_fail;
6458         }
6459     }
6460     {
6461         if (!wxPyCheckForApp()) SWIG_fail;
6462         PyThreadState* __tstate = wxPyBeginAllowThreads();
6463         result = (wxSplashScreenWindow *)new wxSplashScreenWindow((wxBitmap const &)*arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6);
6464
6465         wxPyEndAllowThreads(__tstate);
6466         if (PyErr_Occurred()) SWIG_fail;
6467     }
6468     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreenWindow, 1);
6469     return resultobj;
6470     fail:
6471     return NULL;
6472 }
6473
6474
6475 static PyObject *_wrap_SplashScreenWindow_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6476     PyObject *resultobj;
6477     wxSplashScreenWindow *arg1 = (wxSplashScreenWindow *) 0 ;
6478     wxBitmap *arg2 = 0 ;
6479     PyObject * obj0 = 0 ;
6480     PyObject * obj1 = 0 ;
6481     char *kwnames[] = {
6482         (char *) "self",(char *) "bitmap", NULL
6483     };
6484
6485     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplashScreenWindow_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
6486     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreenWindow, SWIG_POINTER_EXCEPTION | 0);
6487     if (SWIG_arg_fail(1)) SWIG_fail;
6488     {
6489         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6490         if (SWIG_arg_fail(2)) SWIG_fail;
6491         if (arg2 == NULL) {
6492             SWIG_null_ref("wxBitmap");
6493         }
6494         if (SWIG_arg_fail(2)) SWIG_fail;
6495     }
6496     {
6497         PyThreadState* __tstate = wxPyBeginAllowThreads();
6498         (arg1)->SetBitmap((wxBitmap const &)*arg2);
6499
6500         wxPyEndAllowThreads(__tstate);
6501         if (PyErr_Occurred()) SWIG_fail;
6502     }
6503     Py_INCREF(Py_None); resultobj = Py_None;
6504     return resultobj;
6505     fail:
6506     return NULL;
6507 }
6508
6509
6510 static PyObject *_wrap_SplashScreenWindow_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6511     PyObject *resultobj;
6512     wxSplashScreenWindow *arg1 = (wxSplashScreenWindow *) 0 ;
6513     wxBitmap *result;
6514     PyObject * obj0 = 0 ;
6515     char *kwnames[] = {
6516         (char *) "self", NULL
6517     };
6518
6519     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreenWindow_GetBitmap",kwnames,&obj0)) goto fail;
6520     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreenWindow, SWIG_POINTER_EXCEPTION | 0);
6521     if (SWIG_arg_fail(1)) SWIG_fail;
6522     {
6523         PyThreadState* __tstate = wxPyBeginAllowThreads();
6524         {
6525             wxBitmap &_result_ref = (arg1)->GetBitmap();
6526             result = (wxBitmap *) &_result_ref;
6527         }
6528
6529         wxPyEndAllowThreads(__tstate);
6530         if (PyErr_Occurred()) SWIG_fail;
6531     }
6532     {
6533         wxBitmap* resultptr = new wxBitmap(*result);
6534         resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
6535     }
6536     return resultobj;
6537     fail:
6538     return NULL;
6539 }
6540
6541
6542 static PyObject * SplashScreenWindow_swigregister(PyObject *, PyObject *args) {
6543     PyObject *obj;
6544     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6545     SWIG_TypeClientData(SWIGTYPE_p_wxSplashScreenWindow, obj);
6546     Py_INCREF(obj);
6547     return Py_BuildValue((char *)"");
6548 }
6549 static PyObject *_wrap_new_SplashScreen(PyObject *, PyObject *args, PyObject *kwargs) {
6550     PyObject *resultobj;
6551     wxBitmap *arg1 = 0 ;
6552     long arg2 ;
6553     int arg3 ;
6554     wxWindow *arg4 = (wxWindow *) 0 ;
6555     int arg5 = (int) -1 ;
6556     wxPoint const &arg6_defvalue = wxDefaultPosition ;
6557     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
6558     wxSize const &arg7_defvalue = wxDefaultSize ;
6559     wxSize *arg7 = (wxSize *) &arg7_defvalue ;
6560     long arg8 = (long) wxSIMPLE_BORDER|wxFRAME_NO_TASKBAR|wxSTAY_ON_TOP ;
6561     wxSplashScreen *result;
6562     wxPoint temp6 ;
6563     wxSize temp7 ;
6564     PyObject * obj0 = 0 ;
6565     PyObject * obj1 = 0 ;
6566     PyObject * obj2 = 0 ;
6567     PyObject * obj3 = 0 ;
6568     PyObject * obj4 = 0 ;
6569     PyObject * obj5 = 0 ;
6570     PyObject * obj6 = 0 ;
6571     PyObject * obj7 = 0 ;
6572     char *kwnames[] = {
6573         (char *) "bitmap",(char *) "splashStyle",(char *) "milliseconds",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL
6574     };
6575
6576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:new_SplashScreen",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
6577     {
6578         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6579         if (SWIG_arg_fail(1)) SWIG_fail;
6580         if (arg1 == NULL) {
6581             SWIG_null_ref("wxBitmap");
6582         }
6583         if (SWIG_arg_fail(1)) SWIG_fail;
6584     }
6585     {
6586         arg2 = (long)(SWIG_As_long(obj1));
6587         if (SWIG_arg_fail(2)) SWIG_fail;
6588     }
6589     {
6590         arg3 = (int)(SWIG_As_int(obj2));
6591         if (SWIG_arg_fail(3)) SWIG_fail;
6592     }
6593     SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6594     if (SWIG_arg_fail(4)) SWIG_fail;
6595     if (obj4) {
6596         {
6597             arg5 = (int)(SWIG_As_int(obj4));
6598             if (SWIG_arg_fail(5)) SWIG_fail;
6599         }
6600     }
6601     if (obj5) {
6602         {
6603             arg6 = &temp6;
6604             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
6605         }
6606     }
6607     if (obj6) {
6608         {
6609             arg7 = &temp7;
6610             if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
6611         }
6612     }
6613     if (obj7) {
6614         {
6615             arg8 = (long)(SWIG_As_long(obj7));
6616             if (SWIG_arg_fail(8)) SWIG_fail;
6617         }
6618     }
6619     {
6620         if (!wxPyCheckForApp()) SWIG_fail;
6621         PyThreadState* __tstate = wxPyBeginAllowThreads();
6622         result = (wxSplashScreen *)new wxSplashScreen((wxBitmap const &)*arg1,arg2,arg3,arg4,arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8);
6623
6624         wxPyEndAllowThreads(__tstate);
6625         if (PyErr_Occurred()) SWIG_fail;
6626     }
6627     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreen, 1);
6628     return resultobj;
6629     fail:
6630     return NULL;
6631 }
6632
6633
6634 static PyObject *_wrap_SplashScreen_GetSplashStyle(PyObject *, PyObject *args, PyObject *kwargs) {
6635     PyObject *resultobj;
6636     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6637     long result;
6638     PyObject * obj0 = 0 ;
6639     char *kwnames[] = {
6640         (char *) "self", NULL
6641     };
6642
6643     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetSplashStyle",kwnames,&obj0)) goto fail;
6644     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6645     if (SWIG_arg_fail(1)) SWIG_fail;
6646     {
6647         PyThreadState* __tstate = wxPyBeginAllowThreads();
6648         result = (long)((wxSplashScreen const *)arg1)->GetSplashStyle();
6649
6650         wxPyEndAllowThreads(__tstate);
6651         if (PyErr_Occurred()) SWIG_fail;
6652     }
6653     {
6654         resultobj = SWIG_From_long((long)(result));
6655     }
6656     return resultobj;
6657     fail:
6658     return NULL;
6659 }
6660
6661
6662 static PyObject *_wrap_SplashScreen_GetSplashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6663     PyObject *resultobj;
6664     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6665     wxSplashScreenWindow *result;
6666     PyObject * obj0 = 0 ;
6667     char *kwnames[] = {
6668         (char *) "self", NULL
6669     };
6670
6671     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetSplashWindow",kwnames,&obj0)) goto fail;
6672     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6673     if (SWIG_arg_fail(1)) SWIG_fail;
6674     {
6675         PyThreadState* __tstate = wxPyBeginAllowThreads();
6676         result = (wxSplashScreenWindow *)((wxSplashScreen const *)arg1)->GetSplashWindow();
6677
6678         wxPyEndAllowThreads(__tstate);
6679         if (PyErr_Occurred()) SWIG_fail;
6680     }
6681     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplashScreenWindow, 0);
6682     return resultobj;
6683     fail:
6684     return NULL;
6685 }
6686
6687
6688 static PyObject *_wrap_SplashScreen_GetTimeout(PyObject *, PyObject *args, PyObject *kwargs) {
6689     PyObject *resultobj;
6690     wxSplashScreen *arg1 = (wxSplashScreen *) 0 ;
6691     int result;
6692     PyObject * obj0 = 0 ;
6693     char *kwnames[] = {
6694         (char *) "self", NULL
6695     };
6696
6697     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplashScreen_GetTimeout",kwnames,&obj0)) goto fail;
6698     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplashScreen, SWIG_POINTER_EXCEPTION | 0);
6699     if (SWIG_arg_fail(1)) SWIG_fail;
6700     {
6701         PyThreadState* __tstate = wxPyBeginAllowThreads();
6702         result = (int)((wxSplashScreen const *)arg1)->GetTimeout();
6703
6704         wxPyEndAllowThreads(__tstate);
6705         if (PyErr_Occurred()) SWIG_fail;
6706     }
6707     {
6708         resultobj = SWIG_From_int((int)(result));
6709     }
6710     return resultobj;
6711     fail:
6712     return NULL;
6713 }
6714
6715
6716 static PyObject * SplashScreen_swigregister(PyObject *, PyObject *args) {
6717     PyObject *obj;
6718     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6719     SWIG_TypeClientData(SWIGTYPE_p_wxSplashScreen, obj);
6720     Py_INCREF(obj);
6721     return Py_BuildValue((char *)"");
6722 }
6723 static PyObject *_wrap_new_StatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
6724     PyObject *resultobj;
6725     wxWindow *arg1 = (wxWindow *) 0 ;
6726     int arg2 = (int) -1 ;
6727     long arg3 = (long) wxDEFAULT_STATUSBAR_STYLE ;
6728     wxString const &arg4_defvalue = wxPyStatusLineNameStr ;
6729     wxString *arg4 = (wxString *) &arg4_defvalue ;
6730     wxStatusBar *result;
6731     bool temp4 = false ;
6732     PyObject * obj0 = 0 ;
6733     PyObject * obj1 = 0 ;
6734     PyObject * obj2 = 0 ;
6735     PyObject * obj3 = 0 ;
6736     char *kwnames[] = {
6737         (char *) "parent",(char *) "id",(char *) "style",(char *) "name", NULL
6738     };
6739
6740     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_StatusBar",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6741     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6742     if (SWIG_arg_fail(1)) SWIG_fail;
6743     if (obj1) {
6744         {
6745             arg2 = (int)(SWIG_As_int(obj1));
6746             if (SWIG_arg_fail(2)) SWIG_fail;
6747         }
6748     }
6749     if (obj2) {
6750         {
6751             arg3 = (long)(SWIG_As_long(obj2));
6752             if (SWIG_arg_fail(3)) SWIG_fail;
6753         }
6754     }
6755     if (obj3) {
6756         {
6757             arg4 = wxString_in_helper(obj3);
6758             if (arg4 == NULL) SWIG_fail;
6759             temp4 = true;
6760         }
6761     }
6762     {
6763         if (!wxPyCheckForApp()) SWIG_fail;
6764         PyThreadState* __tstate = wxPyBeginAllowThreads();
6765         result = (wxStatusBar *)new wxStatusBar(arg1,arg2,arg3,(wxString const &)*arg4);
6766
6767         wxPyEndAllowThreads(__tstate);
6768         if (PyErr_Occurred()) SWIG_fail;
6769     }
6770     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStatusBar, 1);
6771     {
6772         if (temp4)
6773         delete arg4;
6774     }
6775     return resultobj;
6776     fail:
6777     {
6778         if (temp4)
6779         delete arg4;
6780     }
6781     return NULL;
6782 }
6783
6784
6785 static PyObject *_wrap_new_PreStatusBar(PyObject *, PyObject *args, PyObject *kwargs) {
6786     PyObject *resultobj;
6787     wxStatusBar *result;
6788     char *kwnames[] = {
6789         NULL
6790     };
6791
6792     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreStatusBar",kwnames)) goto fail;
6793     {
6794         if (!wxPyCheckForApp()) SWIG_fail;
6795         PyThreadState* __tstate = wxPyBeginAllowThreads();
6796         result = (wxStatusBar *)new wxStatusBar();
6797
6798         wxPyEndAllowThreads(__tstate);
6799         if (PyErr_Occurred()) SWIG_fail;
6800     }
6801     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStatusBar, 1);
6802     return resultobj;
6803     fail:
6804     return NULL;
6805 }
6806
6807
6808 static PyObject *_wrap_StatusBar_Create(PyObject *, PyObject *args, PyObject *kwargs) {
6809     PyObject *resultobj;
6810     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6811     wxWindow *arg2 = (wxWindow *) 0 ;
6812     int arg3 = (int) -1 ;
6813     long arg4 = (long) wxST_SIZEGRIP ;
6814     wxString const &arg5_defvalue = wxPyStatusLineNameStr ;
6815     wxString *arg5 = (wxString *) &arg5_defvalue ;
6816     bool result;
6817     bool temp5 = false ;
6818     PyObject * obj0 = 0 ;
6819     PyObject * obj1 = 0 ;
6820     PyObject * obj2 = 0 ;
6821     PyObject * obj3 = 0 ;
6822     PyObject * obj4 = 0 ;
6823     char *kwnames[] = {
6824         (char *) "self",(char *) "parent",(char *) "id",(char *) "style",(char *) "name", NULL
6825     };
6826
6827     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:StatusBar_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6828     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6829     if (SWIG_arg_fail(1)) SWIG_fail;
6830     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6831     if (SWIG_arg_fail(2)) SWIG_fail;
6832     if (obj2) {
6833         {
6834             arg3 = (int)(SWIG_As_int(obj2));
6835             if (SWIG_arg_fail(3)) SWIG_fail;
6836         }
6837     }
6838     if (obj3) {
6839         {
6840             arg4 = (long)(SWIG_As_long(obj3));
6841             if (SWIG_arg_fail(4)) SWIG_fail;
6842         }
6843     }
6844     if (obj4) {
6845         {
6846             arg5 = wxString_in_helper(obj4);
6847             if (arg5 == NULL) SWIG_fail;
6848             temp5 = true;
6849         }
6850     }
6851     {
6852         PyThreadState* __tstate = wxPyBeginAllowThreads();
6853         result = (bool)(arg1)->Create(arg2,arg3,arg4,(wxString const &)*arg5);
6854
6855         wxPyEndAllowThreads(__tstate);
6856         if (PyErr_Occurred()) SWIG_fail;
6857     }
6858     {
6859         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6860     }
6861     {
6862         if (temp5)
6863         delete arg5;
6864     }
6865     return resultobj;
6866     fail:
6867     {
6868         if (temp5)
6869         delete arg5;
6870     }
6871     return NULL;
6872 }
6873
6874
6875 static PyObject *_wrap_StatusBar_SetFieldsCount(PyObject *, PyObject *args, PyObject *kwargs) {
6876     PyObject *resultobj;
6877     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6878     int arg2 = (int) 1 ;
6879     PyObject * obj0 = 0 ;
6880     PyObject * obj1 = 0 ;
6881     char *kwnames[] = {
6882         (char *) "self",(char *) "number", NULL
6883     };
6884
6885     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_SetFieldsCount",kwnames,&obj0,&obj1)) goto fail;
6886     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6887     if (SWIG_arg_fail(1)) SWIG_fail;
6888     if (obj1) {
6889         {
6890             arg2 = (int)(SWIG_As_int(obj1));
6891             if (SWIG_arg_fail(2)) SWIG_fail;
6892         }
6893     }
6894     {
6895         PyThreadState* __tstate = wxPyBeginAllowThreads();
6896         (arg1)->SetFieldsCount(arg2);
6897
6898         wxPyEndAllowThreads(__tstate);
6899         if (PyErr_Occurred()) SWIG_fail;
6900     }
6901     Py_INCREF(Py_None); resultobj = Py_None;
6902     return resultobj;
6903     fail:
6904     return NULL;
6905 }
6906
6907
6908 static PyObject *_wrap_StatusBar_GetFieldsCount(PyObject *, PyObject *args, PyObject *kwargs) {
6909     PyObject *resultobj;
6910     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6911     int result;
6912     PyObject * obj0 = 0 ;
6913     char *kwnames[] = {
6914         (char *) "self", NULL
6915     };
6916
6917     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetFieldsCount",kwnames,&obj0)) goto fail;
6918     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6919     if (SWIG_arg_fail(1)) SWIG_fail;
6920     {
6921         PyThreadState* __tstate = wxPyBeginAllowThreads();
6922         result = (int)((wxStatusBar const *)arg1)->GetFieldsCount();
6923
6924         wxPyEndAllowThreads(__tstate);
6925         if (PyErr_Occurred()) SWIG_fail;
6926     }
6927     {
6928         resultobj = SWIG_From_int((int)(result));
6929     }
6930     return resultobj;
6931     fail:
6932     return NULL;
6933 }
6934
6935
6936 static PyObject *_wrap_StatusBar_SetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
6937     PyObject *resultobj;
6938     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6939     wxString *arg2 = 0 ;
6940     int arg3 = (int) 0 ;
6941     bool temp2 = false ;
6942     PyObject * obj0 = 0 ;
6943     PyObject * obj1 = 0 ;
6944     PyObject * obj2 = 0 ;
6945     char *kwnames[] = {
6946         (char *) "self",(char *) "text",(char *) "number", NULL
6947     };
6948
6949     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StatusBar_SetStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
6950     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6951     if (SWIG_arg_fail(1)) SWIG_fail;
6952     {
6953         arg2 = wxString_in_helper(obj1);
6954         if (arg2 == NULL) SWIG_fail;
6955         temp2 = true;
6956     }
6957     if (obj2) {
6958         {
6959             arg3 = (int)(SWIG_As_int(obj2));
6960             if (SWIG_arg_fail(3)) SWIG_fail;
6961         }
6962     }
6963     {
6964         PyThreadState* __tstate = wxPyBeginAllowThreads();
6965         (arg1)->SetStatusText((wxString const &)*arg2,arg3);
6966
6967         wxPyEndAllowThreads(__tstate);
6968         if (PyErr_Occurred()) SWIG_fail;
6969     }
6970     Py_INCREF(Py_None); resultobj = Py_None;
6971     {
6972         if (temp2)
6973         delete arg2;
6974     }
6975     return resultobj;
6976     fail:
6977     {
6978         if (temp2)
6979         delete arg2;
6980     }
6981     return NULL;
6982 }
6983
6984
6985 static PyObject *_wrap_StatusBar_GetStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
6986     PyObject *resultobj;
6987     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
6988     int arg2 = (int) 0 ;
6989     wxString result;
6990     PyObject * obj0 = 0 ;
6991     PyObject * obj1 = 0 ;
6992     char *kwnames[] = {
6993         (char *) "self",(char *) "number", NULL
6994     };
6995
6996     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_GetStatusText",kwnames,&obj0,&obj1)) goto fail;
6997     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
6998     if (SWIG_arg_fail(1)) SWIG_fail;
6999     if (obj1) {
7000         {
7001             arg2 = (int)(SWIG_As_int(obj1));
7002             if (SWIG_arg_fail(2)) SWIG_fail;
7003         }
7004     }
7005     {
7006         PyThreadState* __tstate = wxPyBeginAllowThreads();
7007         result = ((wxStatusBar const *)arg1)->GetStatusText(arg2);
7008
7009         wxPyEndAllowThreads(__tstate);
7010         if (PyErr_Occurred()) SWIG_fail;
7011     }
7012     {
7013 #if wxUSE_UNICODE
7014         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7015 #else
7016         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7017 #endif
7018     }
7019     return resultobj;
7020     fail:
7021     return NULL;
7022 }
7023
7024
7025 static PyObject *_wrap_StatusBar_PushStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
7026     PyObject *resultobj;
7027     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7028     wxString *arg2 = 0 ;
7029     int arg3 = (int) 0 ;
7030     bool temp2 = false ;
7031     PyObject * obj0 = 0 ;
7032     PyObject * obj1 = 0 ;
7033     PyObject * obj2 = 0 ;
7034     char *kwnames[] = {
7035         (char *) "self",(char *) "text",(char *) "number", NULL
7036     };
7037
7038     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StatusBar_PushStatusText",kwnames,&obj0,&obj1,&obj2)) goto fail;
7039     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7040     if (SWIG_arg_fail(1)) SWIG_fail;
7041     {
7042         arg2 = wxString_in_helper(obj1);
7043         if (arg2 == NULL) SWIG_fail;
7044         temp2 = true;
7045     }
7046     if (obj2) {
7047         {
7048             arg3 = (int)(SWIG_As_int(obj2));
7049             if (SWIG_arg_fail(3)) SWIG_fail;
7050         }
7051     }
7052     {
7053         PyThreadState* __tstate = wxPyBeginAllowThreads();
7054         (arg1)->PushStatusText((wxString const &)*arg2,arg3);
7055
7056         wxPyEndAllowThreads(__tstate);
7057         if (PyErr_Occurred()) SWIG_fail;
7058     }
7059     Py_INCREF(Py_None); resultobj = Py_None;
7060     {
7061         if (temp2)
7062         delete arg2;
7063     }
7064     return resultobj;
7065     fail:
7066     {
7067         if (temp2)
7068         delete arg2;
7069     }
7070     return NULL;
7071 }
7072
7073
7074 static PyObject *_wrap_StatusBar_PopStatusText(PyObject *, PyObject *args, PyObject *kwargs) {
7075     PyObject *resultobj;
7076     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7077     int arg2 = (int) 0 ;
7078     PyObject * obj0 = 0 ;
7079     PyObject * obj1 = 0 ;
7080     char *kwnames[] = {
7081         (char *) "self",(char *) "number", NULL
7082     };
7083
7084     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StatusBar_PopStatusText",kwnames,&obj0,&obj1)) goto fail;
7085     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7086     if (SWIG_arg_fail(1)) SWIG_fail;
7087     if (obj1) {
7088         {
7089             arg2 = (int)(SWIG_As_int(obj1));
7090             if (SWIG_arg_fail(2)) SWIG_fail;
7091         }
7092     }
7093     {
7094         PyThreadState* __tstate = wxPyBeginAllowThreads();
7095         (arg1)->PopStatusText(arg2);
7096
7097         wxPyEndAllowThreads(__tstate);
7098         if (PyErr_Occurred()) SWIG_fail;
7099     }
7100     Py_INCREF(Py_None); resultobj = Py_None;
7101     return resultobj;
7102     fail:
7103     return NULL;
7104 }
7105
7106
7107 static PyObject *_wrap_StatusBar_SetStatusWidths(PyObject *, PyObject *args, PyObject *kwargs) {
7108     PyObject *resultobj;
7109     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7110     int arg2 ;
7111     int *arg3 = (int *) 0 ;
7112     PyObject * obj0 = 0 ;
7113     PyObject * obj1 = 0 ;
7114     char *kwnames[] = {
7115         (char *) "self",(char *) "widths", NULL
7116     };
7117
7118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetStatusWidths",kwnames,&obj0,&obj1)) goto fail;
7119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7120     if (SWIG_arg_fail(1)) SWIG_fail;
7121     {
7122         arg2 = PyList_Size(obj1);
7123         arg3 =  int_LIST_helper(obj1);
7124         if (arg3 == NULL) SWIG_fail;
7125     }
7126     {
7127         PyThreadState* __tstate = wxPyBeginAllowThreads();
7128         (arg1)->SetStatusWidths(arg2,(int const *)arg3);
7129
7130         wxPyEndAllowThreads(__tstate);
7131         if (PyErr_Occurred()) SWIG_fail;
7132     }
7133     Py_INCREF(Py_None); resultobj = Py_None;
7134     {
7135         if (arg3) delete [] arg3;
7136     }
7137     return resultobj;
7138     fail:
7139     {
7140         if (arg3) delete [] arg3;
7141     }
7142     return NULL;
7143 }
7144
7145
7146 static PyObject *_wrap_StatusBar_SetStatusStyles(PyObject *, PyObject *args, PyObject *kwargs) {
7147     PyObject *resultobj;
7148     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7149     int arg2 ;
7150     int *arg3 = (int *) 0 ;
7151     PyObject * obj0 = 0 ;
7152     PyObject * obj1 = 0 ;
7153     char *kwnames[] = {
7154         (char *) "self",(char *) "styles", NULL
7155     };
7156
7157     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetStatusStyles",kwnames,&obj0,&obj1)) goto fail;
7158     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7159     if (SWIG_arg_fail(1)) SWIG_fail;
7160     {
7161         arg2 = PyList_Size(obj1);
7162         arg3 =  int_LIST_helper(obj1);
7163         if (arg3 == NULL) SWIG_fail;
7164     }
7165     {
7166         PyThreadState* __tstate = wxPyBeginAllowThreads();
7167         (arg1)->SetStatusStyles(arg2,(int const *)arg3);
7168
7169         wxPyEndAllowThreads(__tstate);
7170         if (PyErr_Occurred()) SWIG_fail;
7171     }
7172     Py_INCREF(Py_None); resultobj = Py_None;
7173     {
7174         if (arg3) delete [] arg3;
7175     }
7176     return resultobj;
7177     fail:
7178     {
7179         if (arg3) delete [] arg3;
7180     }
7181     return NULL;
7182 }
7183
7184
7185 static PyObject *_wrap_StatusBar_GetFieldRect(PyObject *, PyObject *args, PyObject *kwargs) {
7186     PyObject *resultobj;
7187     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7188     int arg2 ;
7189     wxRect result;
7190     PyObject * obj0 = 0 ;
7191     PyObject * obj1 = 0 ;
7192     char *kwnames[] = {
7193         (char *) "self",(char *) "i", NULL
7194     };
7195
7196     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_GetFieldRect",kwnames,&obj0,&obj1)) goto fail;
7197     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7198     if (SWIG_arg_fail(1)) SWIG_fail;
7199     {
7200         arg2 = (int)(SWIG_As_int(obj1));
7201         if (SWIG_arg_fail(2)) SWIG_fail;
7202     }
7203     {
7204         PyThreadState* __tstate = wxPyBeginAllowThreads();
7205         result = wxStatusBar_GetFieldRect(arg1,arg2);
7206
7207         wxPyEndAllowThreads(__tstate);
7208         if (PyErr_Occurred()) SWIG_fail;
7209     }
7210     {
7211         wxRect * resultptr;
7212         resultptr = new wxRect((wxRect &)(result));
7213         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7214     }
7215     return resultobj;
7216     fail:
7217     return NULL;
7218 }
7219
7220
7221 static PyObject *_wrap_StatusBar_SetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7222     PyObject *resultobj;
7223     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7224     int arg2 ;
7225     PyObject * obj0 = 0 ;
7226     PyObject * obj1 = 0 ;
7227     char *kwnames[] = {
7228         (char *) "self",(char *) "height", NULL
7229     };
7230
7231     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StatusBar_SetMinHeight",kwnames,&obj0,&obj1)) goto fail;
7232     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7233     if (SWIG_arg_fail(1)) SWIG_fail;
7234     {
7235         arg2 = (int)(SWIG_As_int(obj1));
7236         if (SWIG_arg_fail(2)) SWIG_fail;
7237     }
7238     {
7239         PyThreadState* __tstate = wxPyBeginAllowThreads();
7240         (arg1)->SetMinHeight(arg2);
7241
7242         wxPyEndAllowThreads(__tstate);
7243         if (PyErr_Occurred()) SWIG_fail;
7244     }
7245     Py_INCREF(Py_None); resultobj = Py_None;
7246     return resultobj;
7247     fail:
7248     return NULL;
7249 }
7250
7251
7252 static PyObject *_wrap_StatusBar_GetBorderX(PyObject *, PyObject *args, PyObject *kwargs) {
7253     PyObject *resultobj;
7254     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7255     int result;
7256     PyObject * obj0 = 0 ;
7257     char *kwnames[] = {
7258         (char *) "self", NULL
7259     };
7260
7261     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetBorderX",kwnames,&obj0)) goto fail;
7262     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7263     if (SWIG_arg_fail(1)) SWIG_fail;
7264     {
7265         PyThreadState* __tstate = wxPyBeginAllowThreads();
7266         result = (int)((wxStatusBar const *)arg1)->GetBorderX();
7267
7268         wxPyEndAllowThreads(__tstate);
7269         if (PyErr_Occurred()) SWIG_fail;
7270     }
7271     {
7272         resultobj = SWIG_From_int((int)(result));
7273     }
7274     return resultobj;
7275     fail:
7276     return NULL;
7277 }
7278
7279
7280 static PyObject *_wrap_StatusBar_GetBorderY(PyObject *, PyObject *args, PyObject *kwargs) {
7281     PyObject *resultobj;
7282     wxStatusBar *arg1 = (wxStatusBar *) 0 ;
7283     int result;
7284     PyObject * obj0 = 0 ;
7285     char *kwnames[] = {
7286         (char *) "self", NULL
7287     };
7288
7289     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StatusBar_GetBorderY",kwnames,&obj0)) goto fail;
7290     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStatusBar, SWIG_POINTER_EXCEPTION | 0);
7291     if (SWIG_arg_fail(1)) SWIG_fail;
7292     {
7293         PyThreadState* __tstate = wxPyBeginAllowThreads();
7294         result = (int)((wxStatusBar const *)arg1)->GetBorderY();
7295
7296         wxPyEndAllowThreads(__tstate);
7297         if (PyErr_Occurred()) SWIG_fail;
7298     }
7299     {
7300         resultobj = SWIG_From_int((int)(result));
7301     }
7302     return resultobj;
7303     fail:
7304     return NULL;
7305 }
7306
7307
7308 static PyObject *_wrap_StatusBar_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
7309     PyObject *resultobj;
7310     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
7311     wxVisualAttributes result;
7312     PyObject * obj0 = 0 ;
7313     char *kwnames[] = {
7314         (char *) "variant", NULL
7315     };
7316
7317     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StatusBar_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
7318     if (obj0) {
7319         {
7320             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
7321             if (SWIG_arg_fail(1)) SWIG_fail;
7322         }
7323     }
7324     {
7325         if (!wxPyCheckForApp()) SWIG_fail;
7326         PyThreadState* __tstate = wxPyBeginAllowThreads();
7327         result = wxStatusBar::GetClassDefaultAttributes((wxWindowVariant )arg1);
7328
7329         wxPyEndAllowThreads(__tstate);
7330         if (PyErr_Occurred()) SWIG_fail;
7331     }
7332     {
7333         wxVisualAttributes * resultptr;
7334         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
7335         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
7336     }
7337     return resultobj;
7338     fail:
7339     return NULL;
7340 }
7341
7342
7343 static PyObject * StatusBar_swigregister(PyObject *, PyObject *args) {
7344     PyObject *obj;
7345     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7346     SWIG_TypeClientData(SWIGTYPE_p_wxStatusBar, obj);
7347     Py_INCREF(obj);
7348     return Py_BuildValue((char *)"");
7349 }
7350 static int _wrap_SplitterNameStr_set(PyObject *) {
7351     PyErr_SetString(PyExc_TypeError,"Variable SplitterNameStr is read-only.");
7352     return 1;
7353 }
7354
7355
7356 static PyObject *_wrap_SplitterNameStr_get(void) {
7357     PyObject *pyobj;
7358
7359     {
7360 #if wxUSE_UNICODE
7361         pyobj = PyUnicode_FromWideChar((&wxPySplitterNameStr)->c_str(), (&wxPySplitterNameStr)->Len());
7362 #else
7363         pyobj = PyString_FromStringAndSize((&wxPySplitterNameStr)->c_str(), (&wxPySplitterNameStr)->Len());
7364 #endif
7365     }
7366     return pyobj;
7367 }
7368
7369
7370 static PyObject *_wrap_new_SplitterWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7371     PyObject *resultobj;
7372     wxWindow *arg1 = (wxWindow *) 0 ;
7373     int arg2 = (int) -1 ;
7374     wxPoint const &arg3_defvalue = wxDefaultPosition ;
7375     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
7376     wxSize const &arg4_defvalue = wxDefaultSize ;
7377     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
7378     long arg5 = (long) wxSP_3D ;
7379     wxString const &arg6_defvalue = wxPySplitterNameStr ;
7380     wxString *arg6 = (wxString *) &arg6_defvalue ;
7381     wxSplitterWindow *result;
7382     wxPoint temp3 ;
7383     wxSize temp4 ;
7384     bool temp6 = false ;
7385     PyObject * obj0 = 0 ;
7386     PyObject * obj1 = 0 ;
7387     PyObject * obj2 = 0 ;
7388     PyObject * obj3 = 0 ;
7389     PyObject * obj4 = 0 ;
7390     PyObject * obj5 = 0 ;
7391     char *kwnames[] = {
7392         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
7393     };
7394
7395     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SplitterWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
7396     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7397     if (SWIG_arg_fail(1)) SWIG_fail;
7398     if (obj1) {
7399         {
7400             arg2 = (int)(SWIG_As_int(obj1));
7401             if (SWIG_arg_fail(2)) SWIG_fail;
7402         }
7403     }
7404     if (obj2) {
7405         {
7406             arg3 = &temp3;
7407             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
7408         }
7409     }
7410     if (obj3) {
7411         {
7412             arg4 = &temp4;
7413             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
7414         }
7415     }
7416     if (obj4) {
7417         {
7418             arg5 = (long)(SWIG_As_long(obj4));
7419             if (SWIG_arg_fail(5)) SWIG_fail;
7420         }
7421     }
7422     if (obj5) {
7423         {
7424             arg6 = wxString_in_helper(obj5);
7425             if (arg6 == NULL) SWIG_fail;
7426             temp6 = true;
7427         }
7428     }
7429     {
7430         if (!wxPyCheckForApp()) SWIG_fail;
7431         PyThreadState* __tstate = wxPyBeginAllowThreads();
7432         result = (wxSplitterWindow *)new wxSplitterWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
7433
7434         wxPyEndAllowThreads(__tstate);
7435         if (PyErr_Occurred()) SWIG_fail;
7436     }
7437     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterWindow, 1);
7438     {
7439         if (temp6)
7440         delete arg6;
7441     }
7442     return resultobj;
7443     fail:
7444     {
7445         if (temp6)
7446         delete arg6;
7447     }
7448     return NULL;
7449 }
7450
7451
7452 static PyObject *_wrap_new_PreSplitterWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7453     PyObject *resultobj;
7454     wxSplitterWindow *result;
7455     char *kwnames[] = {
7456         NULL
7457     };
7458
7459     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSplitterWindow",kwnames)) goto fail;
7460     {
7461         if (!wxPyCheckForApp()) SWIG_fail;
7462         PyThreadState* __tstate = wxPyBeginAllowThreads();
7463         result = (wxSplitterWindow *)new wxSplitterWindow();
7464
7465         wxPyEndAllowThreads(__tstate);
7466         if (PyErr_Occurred()) SWIG_fail;
7467     }
7468     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterWindow, 1);
7469     return resultobj;
7470     fail:
7471     return NULL;
7472 }
7473
7474
7475 static PyObject *_wrap_SplitterWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7476     PyObject *resultobj;
7477     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7478     wxWindow *arg2 = (wxWindow *) 0 ;
7479     int arg3 = (int) -1 ;
7480     wxPoint const &arg4_defvalue = wxDefaultPosition ;
7481     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
7482     wxSize const &arg5_defvalue = wxDefaultSize ;
7483     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
7484     long arg6 = (long) wxSP_3D ;
7485     wxString const &arg7_defvalue = wxPySplitterNameStr ;
7486     wxString *arg7 = (wxString *) &arg7_defvalue ;
7487     bool result;
7488     wxPoint temp4 ;
7489     wxSize temp5 ;
7490     bool temp7 = false ;
7491     PyObject * obj0 = 0 ;
7492     PyObject * obj1 = 0 ;
7493     PyObject * obj2 = 0 ;
7494     PyObject * obj3 = 0 ;
7495     PyObject * obj4 = 0 ;
7496     PyObject * obj5 = 0 ;
7497     PyObject * obj6 = 0 ;
7498     char *kwnames[] = {
7499         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
7500     };
7501
7502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SplitterWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
7503     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7504     if (SWIG_arg_fail(1)) SWIG_fail;
7505     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7506     if (SWIG_arg_fail(2)) SWIG_fail;
7507     if (obj2) {
7508         {
7509             arg3 = (int)(SWIG_As_int(obj2));
7510             if (SWIG_arg_fail(3)) SWIG_fail;
7511         }
7512     }
7513     if (obj3) {
7514         {
7515             arg4 = &temp4;
7516             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
7517         }
7518     }
7519     if (obj4) {
7520         {
7521             arg5 = &temp5;
7522             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
7523         }
7524     }
7525     if (obj5) {
7526         {
7527             arg6 = (long)(SWIG_As_long(obj5));
7528             if (SWIG_arg_fail(6)) SWIG_fail;
7529         }
7530     }
7531     if (obj6) {
7532         {
7533             arg7 = wxString_in_helper(obj6);
7534             if (arg7 == NULL) SWIG_fail;
7535             temp7 = true;
7536         }
7537     }
7538     {
7539         PyThreadState* __tstate = wxPyBeginAllowThreads();
7540         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
7541
7542         wxPyEndAllowThreads(__tstate);
7543         if (PyErr_Occurred()) SWIG_fail;
7544     }
7545     {
7546         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7547     }
7548     {
7549         if (temp7)
7550         delete arg7;
7551     }
7552     return resultobj;
7553     fail:
7554     {
7555         if (temp7)
7556         delete arg7;
7557     }
7558     return NULL;
7559 }
7560
7561
7562 static PyObject *_wrap_SplitterWindow_GetWindow1(PyObject *, PyObject *args, PyObject *kwargs) {
7563     PyObject *resultobj;
7564     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7565     wxWindow *result;
7566     PyObject * obj0 = 0 ;
7567     char *kwnames[] = {
7568         (char *) "self", NULL
7569     };
7570
7571     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetWindow1",kwnames,&obj0)) goto fail;
7572     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7573     if (SWIG_arg_fail(1)) SWIG_fail;
7574     {
7575         PyThreadState* __tstate = wxPyBeginAllowThreads();
7576         result = (wxWindow *)((wxSplitterWindow const *)arg1)->GetWindow1();
7577
7578         wxPyEndAllowThreads(__tstate);
7579         if (PyErr_Occurred()) SWIG_fail;
7580     }
7581     {
7582         resultobj = wxPyMake_wxObject(result, 0);
7583     }
7584     return resultobj;
7585     fail:
7586     return NULL;
7587 }
7588
7589
7590 static PyObject *_wrap_SplitterWindow_GetWindow2(PyObject *, PyObject *args, PyObject *kwargs) {
7591     PyObject *resultobj;
7592     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7593     wxWindow *result;
7594     PyObject * obj0 = 0 ;
7595     char *kwnames[] = {
7596         (char *) "self", NULL
7597     };
7598
7599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetWindow2",kwnames,&obj0)) goto fail;
7600     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7601     if (SWIG_arg_fail(1)) SWIG_fail;
7602     {
7603         PyThreadState* __tstate = wxPyBeginAllowThreads();
7604         result = (wxWindow *)((wxSplitterWindow const *)arg1)->GetWindow2();
7605
7606         wxPyEndAllowThreads(__tstate);
7607         if (PyErr_Occurred()) SWIG_fail;
7608     }
7609     {
7610         resultobj = wxPyMake_wxObject(result, 0);
7611     }
7612     return resultobj;
7613     fail:
7614     return NULL;
7615 }
7616
7617
7618 static PyObject *_wrap_SplitterWindow_SetSplitMode(PyObject *, PyObject *args, PyObject *kwargs) {
7619     PyObject *resultobj;
7620     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7621     int arg2 ;
7622     PyObject * obj0 = 0 ;
7623     PyObject * obj1 = 0 ;
7624     char *kwnames[] = {
7625         (char *) "self",(char *) "mode", NULL
7626     };
7627
7628     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSplitMode",kwnames,&obj0,&obj1)) goto fail;
7629     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7630     if (SWIG_arg_fail(1)) SWIG_fail;
7631     {
7632         arg2 = (int)(SWIG_As_int(obj1));
7633         if (SWIG_arg_fail(2)) SWIG_fail;
7634     }
7635     {
7636         PyThreadState* __tstate = wxPyBeginAllowThreads();
7637         (arg1)->SetSplitMode(arg2);
7638
7639         wxPyEndAllowThreads(__tstate);
7640         if (PyErr_Occurred()) SWIG_fail;
7641     }
7642     Py_INCREF(Py_None); resultobj = Py_None;
7643     return resultobj;
7644     fail:
7645     return NULL;
7646 }
7647
7648
7649 static PyObject *_wrap_SplitterWindow_GetSplitMode(PyObject *, PyObject *args, PyObject *kwargs) {
7650     PyObject *resultobj;
7651     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7652     wxSplitMode result;
7653     PyObject * obj0 = 0 ;
7654     char *kwnames[] = {
7655         (char *) "self", NULL
7656     };
7657
7658     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSplitMode",kwnames,&obj0)) goto fail;
7659     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7660     if (SWIG_arg_fail(1)) SWIG_fail;
7661     {
7662         PyThreadState* __tstate = wxPyBeginAllowThreads();
7663         result = (wxSplitMode)((wxSplitterWindow const *)arg1)->GetSplitMode();
7664
7665         wxPyEndAllowThreads(__tstate);
7666         if (PyErr_Occurred()) SWIG_fail;
7667     }
7668     resultobj = SWIG_From_int((result));
7669     return resultobj;
7670     fail:
7671     return NULL;
7672 }
7673
7674
7675 static PyObject *_wrap_SplitterWindow_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
7676     PyObject *resultobj;
7677     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7678     wxWindow *arg2 = (wxWindow *) 0 ;
7679     PyObject * obj0 = 0 ;
7680     PyObject * obj1 = 0 ;
7681     char *kwnames[] = {
7682         (char *) "self",(char *) "window", NULL
7683     };
7684
7685     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_Initialize",kwnames,&obj0,&obj1)) goto fail;
7686     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7687     if (SWIG_arg_fail(1)) SWIG_fail;
7688     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7689     if (SWIG_arg_fail(2)) SWIG_fail;
7690     {
7691         PyThreadState* __tstate = wxPyBeginAllowThreads();
7692         (arg1)->Initialize(arg2);
7693
7694         wxPyEndAllowThreads(__tstate);
7695         if (PyErr_Occurred()) SWIG_fail;
7696     }
7697     Py_INCREF(Py_None); resultobj = Py_None;
7698     return resultobj;
7699     fail:
7700     return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_SplitterWindow_SplitVertically(PyObject *, PyObject *args, PyObject *kwargs) {
7705     PyObject *resultobj;
7706     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7707     wxWindow *arg2 = (wxWindow *) 0 ;
7708     wxWindow *arg3 = (wxWindow *) 0 ;
7709     int arg4 = (int) 0 ;
7710     bool result;
7711     PyObject * obj0 = 0 ;
7712     PyObject * obj1 = 0 ;
7713     PyObject * obj2 = 0 ;
7714     PyObject * obj3 = 0 ;
7715     char *kwnames[] = {
7716         (char *) "self",(char *) "window1",(char *) "window2",(char *) "sashPosition", NULL
7717     };
7718
7719     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SplitVertically",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7720     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7721     if (SWIG_arg_fail(1)) SWIG_fail;
7722     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7723     if (SWIG_arg_fail(2)) SWIG_fail;
7724     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7725     if (SWIG_arg_fail(3)) SWIG_fail;
7726     if (obj3) {
7727         {
7728             arg4 = (int)(SWIG_As_int(obj3));
7729             if (SWIG_arg_fail(4)) SWIG_fail;
7730         }
7731     }
7732     {
7733         PyThreadState* __tstate = wxPyBeginAllowThreads();
7734         result = (bool)(arg1)->SplitVertically(arg2,arg3,arg4);
7735
7736         wxPyEndAllowThreads(__tstate);
7737         if (PyErr_Occurred()) SWIG_fail;
7738     }
7739     {
7740         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7741     }
7742     return resultobj;
7743     fail:
7744     return NULL;
7745 }
7746
7747
7748 static PyObject *_wrap_SplitterWindow_SplitHorizontally(PyObject *, PyObject *args, PyObject *kwargs) {
7749     PyObject *resultobj;
7750     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7751     wxWindow *arg2 = (wxWindow *) 0 ;
7752     wxWindow *arg3 = (wxWindow *) 0 ;
7753     int arg4 = (int) 0 ;
7754     bool result;
7755     PyObject * obj0 = 0 ;
7756     PyObject * obj1 = 0 ;
7757     PyObject * obj2 = 0 ;
7758     PyObject * obj3 = 0 ;
7759     char *kwnames[] = {
7760         (char *) "self",(char *) "window1",(char *) "window2",(char *) "sashPosition", NULL
7761     };
7762
7763     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SplitHorizontally",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7764     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7765     if (SWIG_arg_fail(1)) SWIG_fail;
7766     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7767     if (SWIG_arg_fail(2)) SWIG_fail;
7768     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7769     if (SWIG_arg_fail(3)) SWIG_fail;
7770     if (obj3) {
7771         {
7772             arg4 = (int)(SWIG_As_int(obj3));
7773             if (SWIG_arg_fail(4)) SWIG_fail;
7774         }
7775     }
7776     {
7777         PyThreadState* __tstate = wxPyBeginAllowThreads();
7778         result = (bool)(arg1)->SplitHorizontally(arg2,arg3,arg4);
7779
7780         wxPyEndAllowThreads(__tstate);
7781         if (PyErr_Occurred()) SWIG_fail;
7782     }
7783     {
7784         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7785     }
7786     return resultobj;
7787     fail:
7788     return NULL;
7789 }
7790
7791
7792 static PyObject *_wrap_SplitterWindow_Unsplit(PyObject *, PyObject *args, PyObject *kwargs) {
7793     PyObject *resultobj;
7794     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7795     wxWindow *arg2 = (wxWindow *) NULL ;
7796     bool result;
7797     PyObject * obj0 = 0 ;
7798     PyObject * obj1 = 0 ;
7799     char *kwnames[] = {
7800         (char *) "self",(char *) "toRemove", NULL
7801     };
7802
7803     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SplitterWindow_Unsplit",kwnames,&obj0,&obj1)) goto fail;
7804     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7805     if (SWIG_arg_fail(1)) SWIG_fail;
7806     if (obj1) {
7807         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7808         if (SWIG_arg_fail(2)) SWIG_fail;
7809     }
7810     {
7811         PyThreadState* __tstate = wxPyBeginAllowThreads();
7812         result = (bool)(arg1)->Unsplit(arg2);
7813
7814         wxPyEndAllowThreads(__tstate);
7815         if (PyErr_Occurred()) SWIG_fail;
7816     }
7817     {
7818         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7819     }
7820     return resultobj;
7821     fail:
7822     return NULL;
7823 }
7824
7825
7826 static PyObject *_wrap_SplitterWindow_ReplaceWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7827     PyObject *resultobj;
7828     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7829     wxWindow *arg2 = (wxWindow *) 0 ;
7830     wxWindow *arg3 = (wxWindow *) 0 ;
7831     bool result;
7832     PyObject * obj0 = 0 ;
7833     PyObject * obj1 = 0 ;
7834     PyObject * obj2 = 0 ;
7835     char *kwnames[] = {
7836         (char *) "self",(char *) "winOld",(char *) "winNew", NULL
7837     };
7838
7839     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SplitterWindow_ReplaceWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
7840     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7841     if (SWIG_arg_fail(1)) SWIG_fail;
7842     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7843     if (SWIG_arg_fail(2)) SWIG_fail;
7844     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7845     if (SWIG_arg_fail(3)) SWIG_fail;
7846     {
7847         PyThreadState* __tstate = wxPyBeginAllowThreads();
7848         result = (bool)(arg1)->ReplaceWindow(arg2,arg3);
7849
7850         wxPyEndAllowThreads(__tstate);
7851         if (PyErr_Occurred()) SWIG_fail;
7852     }
7853     {
7854         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7855     }
7856     return resultobj;
7857     fail:
7858     return NULL;
7859 }
7860
7861
7862 static PyObject *_wrap_SplitterWindow_UpdateSize(PyObject *, PyObject *args, PyObject *kwargs) {
7863     PyObject *resultobj;
7864     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7865     PyObject * obj0 = 0 ;
7866     char *kwnames[] = {
7867         (char *) "self", NULL
7868     };
7869
7870     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_UpdateSize",kwnames,&obj0)) goto fail;
7871     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7872     if (SWIG_arg_fail(1)) SWIG_fail;
7873     {
7874         PyThreadState* __tstate = wxPyBeginAllowThreads();
7875         (arg1)->UpdateSize();
7876
7877         wxPyEndAllowThreads(__tstate);
7878         if (PyErr_Occurred()) SWIG_fail;
7879     }
7880     Py_INCREF(Py_None); resultobj = Py_None;
7881     return resultobj;
7882     fail:
7883     return NULL;
7884 }
7885
7886
7887 static PyObject *_wrap_SplitterWindow_IsSplit(PyObject *, PyObject *args, PyObject *kwargs) {
7888     PyObject *resultobj;
7889     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7890     bool result;
7891     PyObject * obj0 = 0 ;
7892     char *kwnames[] = {
7893         (char *) "self", NULL
7894     };
7895
7896     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_IsSplit",kwnames,&obj0)) goto fail;
7897     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7898     if (SWIG_arg_fail(1)) SWIG_fail;
7899     {
7900         PyThreadState* __tstate = wxPyBeginAllowThreads();
7901         result = (bool)((wxSplitterWindow const *)arg1)->IsSplit();
7902
7903         wxPyEndAllowThreads(__tstate);
7904         if (PyErr_Occurred()) SWIG_fail;
7905     }
7906     {
7907         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7908     }
7909     return resultobj;
7910     fail:
7911     return NULL;
7912 }
7913
7914
7915 static PyObject *_wrap_SplitterWindow_SetSashSize(PyObject *, PyObject *args, PyObject *kwargs) {
7916     PyObject *resultobj;
7917     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7918     int arg2 ;
7919     PyObject * obj0 = 0 ;
7920     PyObject * obj1 = 0 ;
7921     char *kwnames[] = {
7922         (char *) "self",(char *) "width", NULL
7923     };
7924
7925     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSashSize",kwnames,&obj0,&obj1)) goto fail;
7926     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7927     if (SWIG_arg_fail(1)) SWIG_fail;
7928     {
7929         arg2 = (int)(SWIG_As_int(obj1));
7930         if (SWIG_arg_fail(2)) SWIG_fail;
7931     }
7932     {
7933         PyThreadState* __tstate = wxPyBeginAllowThreads();
7934         (arg1)->SetSashSize(arg2);
7935
7936         wxPyEndAllowThreads(__tstate);
7937         if (PyErr_Occurred()) SWIG_fail;
7938     }
7939     Py_INCREF(Py_None); resultobj = Py_None;
7940     return resultobj;
7941     fail:
7942     return NULL;
7943 }
7944
7945
7946 static PyObject *_wrap_SplitterWindow_SetBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
7947     PyObject *resultobj;
7948     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7949     int arg2 ;
7950     PyObject * obj0 = 0 ;
7951     PyObject * obj1 = 0 ;
7952     char *kwnames[] = {
7953         (char *) "self",(char *) "width", NULL
7954     };
7955
7956     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetBorderSize",kwnames,&obj0,&obj1)) goto fail;
7957     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7958     if (SWIG_arg_fail(1)) SWIG_fail;
7959     {
7960         arg2 = (int)(SWIG_As_int(obj1));
7961         if (SWIG_arg_fail(2)) SWIG_fail;
7962     }
7963     {
7964         PyThreadState* __tstate = wxPyBeginAllowThreads();
7965         (arg1)->SetBorderSize(arg2);
7966
7967         wxPyEndAllowThreads(__tstate);
7968         if (PyErr_Occurred()) SWIG_fail;
7969     }
7970     Py_INCREF(Py_None); resultobj = Py_None;
7971     return resultobj;
7972     fail:
7973     return NULL;
7974 }
7975
7976
7977 static PyObject *_wrap_SplitterWindow_GetSashSize(PyObject *, PyObject *args, PyObject *kwargs) {
7978     PyObject *resultobj;
7979     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
7980     int result;
7981     PyObject * obj0 = 0 ;
7982     char *kwnames[] = {
7983         (char *) "self", NULL
7984     };
7985
7986     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashSize",kwnames,&obj0)) goto fail;
7987     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
7988     if (SWIG_arg_fail(1)) SWIG_fail;
7989     {
7990         PyThreadState* __tstate = wxPyBeginAllowThreads();
7991         result = (int)((wxSplitterWindow const *)arg1)->GetSashSize();
7992
7993         wxPyEndAllowThreads(__tstate);
7994         if (PyErr_Occurred()) SWIG_fail;
7995     }
7996     {
7997         resultobj = SWIG_From_int((int)(result));
7998     }
7999     return resultobj;
8000     fail:
8001     return NULL;
8002 }
8003
8004
8005 static PyObject *_wrap_SplitterWindow_GetBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
8006     PyObject *resultobj;
8007     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8008     int result;
8009     PyObject * obj0 = 0 ;
8010     char *kwnames[] = {
8011         (char *) "self", NULL
8012     };
8013
8014     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetBorderSize",kwnames,&obj0)) goto fail;
8015     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8016     if (SWIG_arg_fail(1)) SWIG_fail;
8017     {
8018         PyThreadState* __tstate = wxPyBeginAllowThreads();
8019         result = (int)((wxSplitterWindow const *)arg1)->GetBorderSize();
8020
8021         wxPyEndAllowThreads(__tstate);
8022         if (PyErr_Occurred()) SWIG_fail;
8023     }
8024     {
8025         resultobj = SWIG_From_int((int)(result));
8026     }
8027     return resultobj;
8028     fail:
8029     return NULL;
8030 }
8031
8032
8033 static PyObject *_wrap_SplitterWindow_SetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8034     PyObject *resultobj;
8035     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8036     int arg2 ;
8037     bool arg3 = (bool) true ;
8038     PyObject * obj0 = 0 ;
8039     PyObject * obj1 = 0 ;
8040     PyObject * obj2 = 0 ;
8041     char *kwnames[] = {
8042         (char *) "self",(char *) "position",(char *) "redraw", NULL
8043     };
8044
8045     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SplitterWindow_SetSashPosition",kwnames,&obj0,&obj1,&obj2)) goto fail;
8046     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8047     if (SWIG_arg_fail(1)) SWIG_fail;
8048     {
8049         arg2 = (int)(SWIG_As_int(obj1));
8050         if (SWIG_arg_fail(2)) SWIG_fail;
8051     }
8052     if (obj2) {
8053         {
8054             arg3 = (bool)(SWIG_As_bool(obj2));
8055             if (SWIG_arg_fail(3)) SWIG_fail;
8056         }
8057     }
8058     {
8059         PyThreadState* __tstate = wxPyBeginAllowThreads();
8060         (arg1)->SetSashPosition(arg2,arg3);
8061
8062         wxPyEndAllowThreads(__tstate);
8063         if (PyErr_Occurred()) SWIG_fail;
8064     }
8065     Py_INCREF(Py_None); resultobj = Py_None;
8066     return resultobj;
8067     fail:
8068     return NULL;
8069 }
8070
8071
8072 static PyObject *_wrap_SplitterWindow_GetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8073     PyObject *resultobj;
8074     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8075     int result;
8076     PyObject * obj0 = 0 ;
8077     char *kwnames[] = {
8078         (char *) "self", NULL
8079     };
8080
8081     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashPosition",kwnames,&obj0)) goto fail;
8082     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8083     if (SWIG_arg_fail(1)) SWIG_fail;
8084     {
8085         PyThreadState* __tstate = wxPyBeginAllowThreads();
8086         result = (int)((wxSplitterWindow const *)arg1)->GetSashPosition();
8087
8088         wxPyEndAllowThreads(__tstate);
8089         if (PyErr_Occurred()) SWIG_fail;
8090     }
8091     {
8092         resultobj = SWIG_From_int((int)(result));
8093     }
8094     return resultobj;
8095     fail:
8096     return NULL;
8097 }
8098
8099
8100 static PyObject *_wrap_SplitterWindow_SetSashGravity(PyObject *, PyObject *args, PyObject *kwargs) {
8101     PyObject *resultobj;
8102     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8103     double arg2 ;
8104     PyObject * obj0 = 0 ;
8105     PyObject * obj1 = 0 ;
8106     char *kwnames[] = {
8107         (char *) "self",(char *) "gravity", NULL
8108     };
8109
8110     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetSashGravity",kwnames,&obj0,&obj1)) goto fail;
8111     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8112     if (SWIG_arg_fail(1)) SWIG_fail;
8113     {
8114         arg2 = (double)(SWIG_As_double(obj1));
8115         if (SWIG_arg_fail(2)) SWIG_fail;
8116     }
8117     {
8118         PyThreadState* __tstate = wxPyBeginAllowThreads();
8119         (arg1)->SetSashGravity(arg2);
8120
8121         wxPyEndAllowThreads(__tstate);
8122         if (PyErr_Occurred()) SWIG_fail;
8123     }
8124     Py_INCREF(Py_None); resultobj = Py_None;
8125     return resultobj;
8126     fail:
8127     return NULL;
8128 }
8129
8130
8131 static PyObject *_wrap_SplitterWindow_GetSashGravity(PyObject *, PyObject *args, PyObject *kwargs) {
8132     PyObject *resultobj;
8133     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8134     double result;
8135     PyObject * obj0 = 0 ;
8136     char *kwnames[] = {
8137         (char *) "self", NULL
8138     };
8139
8140     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetSashGravity",kwnames,&obj0)) goto fail;
8141     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8142     if (SWIG_arg_fail(1)) SWIG_fail;
8143     {
8144         PyThreadState* __tstate = wxPyBeginAllowThreads();
8145         result = (double)((wxSplitterWindow const *)arg1)->GetSashGravity();
8146
8147         wxPyEndAllowThreads(__tstate);
8148         if (PyErr_Occurred()) SWIG_fail;
8149     }
8150     {
8151         resultobj = SWIG_From_double((double)(result));
8152     }
8153     return resultobj;
8154     fail:
8155     return NULL;
8156 }
8157
8158
8159 static PyObject *_wrap_SplitterWindow_SetMinimumPaneSize(PyObject *, PyObject *args, PyObject *kwargs) {
8160     PyObject *resultobj;
8161     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8162     int arg2 ;
8163     PyObject * obj0 = 0 ;
8164     PyObject * obj1 = 0 ;
8165     char *kwnames[] = {
8166         (char *) "self",(char *) "min", NULL
8167     };
8168
8169     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetMinimumPaneSize",kwnames,&obj0,&obj1)) goto fail;
8170     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8171     if (SWIG_arg_fail(1)) SWIG_fail;
8172     {
8173         arg2 = (int)(SWIG_As_int(obj1));
8174         if (SWIG_arg_fail(2)) SWIG_fail;
8175     }
8176     {
8177         PyThreadState* __tstate = wxPyBeginAllowThreads();
8178         (arg1)->SetMinimumPaneSize(arg2);
8179
8180         wxPyEndAllowThreads(__tstate);
8181         if (PyErr_Occurred()) SWIG_fail;
8182     }
8183     Py_INCREF(Py_None); resultobj = Py_None;
8184     return resultobj;
8185     fail:
8186     return NULL;
8187 }
8188
8189
8190 static PyObject *_wrap_SplitterWindow_GetMinimumPaneSize(PyObject *, PyObject *args, PyObject *kwargs) {
8191     PyObject *resultobj;
8192     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8193     int result;
8194     PyObject * obj0 = 0 ;
8195     char *kwnames[] = {
8196         (char *) "self", NULL
8197     };
8198
8199     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetMinimumPaneSize",kwnames,&obj0)) goto fail;
8200     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8201     if (SWIG_arg_fail(1)) SWIG_fail;
8202     {
8203         PyThreadState* __tstate = wxPyBeginAllowThreads();
8204         result = (int)((wxSplitterWindow const *)arg1)->GetMinimumPaneSize();
8205
8206         wxPyEndAllowThreads(__tstate);
8207         if (PyErr_Occurred()) SWIG_fail;
8208     }
8209     {
8210         resultobj = SWIG_From_int((int)(result));
8211     }
8212     return resultobj;
8213     fail:
8214     return NULL;
8215 }
8216
8217
8218 static PyObject *_wrap_SplitterWindow_SashHitTest(PyObject *, PyObject *args, PyObject *kwargs) {
8219     PyObject *resultobj;
8220     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8221     int arg2 ;
8222     int arg3 ;
8223     int arg4 = (int) 5 ;
8224     bool result;
8225     PyObject * obj0 = 0 ;
8226     PyObject * obj1 = 0 ;
8227     PyObject * obj2 = 0 ;
8228     PyObject * obj3 = 0 ;
8229     char *kwnames[] = {
8230         (char *) "self",(char *) "x",(char *) "y",(char *) "tolerance", NULL
8231     };
8232
8233     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SplitterWindow_SashHitTest",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8234     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8235     if (SWIG_arg_fail(1)) SWIG_fail;
8236     {
8237         arg2 = (int)(SWIG_As_int(obj1));
8238         if (SWIG_arg_fail(2)) SWIG_fail;
8239     }
8240     {
8241         arg3 = (int)(SWIG_As_int(obj2));
8242         if (SWIG_arg_fail(3)) SWIG_fail;
8243     }
8244     if (obj3) {
8245         {
8246             arg4 = (int)(SWIG_As_int(obj3));
8247             if (SWIG_arg_fail(4)) SWIG_fail;
8248         }
8249     }
8250     {
8251         PyThreadState* __tstate = wxPyBeginAllowThreads();
8252         result = (bool)(arg1)->SashHitTest(arg2,arg3,arg4);
8253
8254         wxPyEndAllowThreads(__tstate);
8255         if (PyErr_Occurred()) SWIG_fail;
8256     }
8257     {
8258         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8259     }
8260     return resultobj;
8261     fail:
8262     return NULL;
8263 }
8264
8265
8266 static PyObject *_wrap_SplitterWindow_SizeWindows(PyObject *, PyObject *args, PyObject *kwargs) {
8267     PyObject *resultobj;
8268     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8269     PyObject * obj0 = 0 ;
8270     char *kwnames[] = {
8271         (char *) "self", NULL
8272     };
8273
8274     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_SizeWindows",kwnames,&obj0)) goto fail;
8275     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8276     if (SWIG_arg_fail(1)) SWIG_fail;
8277     {
8278         PyThreadState* __tstate = wxPyBeginAllowThreads();
8279         (arg1)->SizeWindows();
8280
8281         wxPyEndAllowThreads(__tstate);
8282         if (PyErr_Occurred()) SWIG_fail;
8283     }
8284     Py_INCREF(Py_None); resultobj = Py_None;
8285     return resultobj;
8286     fail:
8287     return NULL;
8288 }
8289
8290
8291 static PyObject *_wrap_SplitterWindow_SetNeedUpdating(PyObject *, PyObject *args, PyObject *kwargs) {
8292     PyObject *resultobj;
8293     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8294     bool arg2 ;
8295     PyObject * obj0 = 0 ;
8296     PyObject * obj1 = 0 ;
8297     char *kwnames[] = {
8298         (char *) "self",(char *) "needUpdating", NULL
8299     };
8300
8301     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterWindow_SetNeedUpdating",kwnames,&obj0,&obj1)) goto fail;
8302     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8303     if (SWIG_arg_fail(1)) SWIG_fail;
8304     {
8305         arg2 = (bool)(SWIG_As_bool(obj1));
8306         if (SWIG_arg_fail(2)) SWIG_fail;
8307     }
8308     {
8309         PyThreadState* __tstate = wxPyBeginAllowThreads();
8310         (arg1)->SetNeedUpdating(arg2);
8311
8312         wxPyEndAllowThreads(__tstate);
8313         if (PyErr_Occurred()) SWIG_fail;
8314     }
8315     Py_INCREF(Py_None); resultobj = Py_None;
8316     return resultobj;
8317     fail:
8318     return NULL;
8319 }
8320
8321
8322 static PyObject *_wrap_SplitterWindow_GetNeedUpdating(PyObject *, PyObject *args, PyObject *kwargs) {
8323     PyObject *resultobj;
8324     wxSplitterWindow *arg1 = (wxSplitterWindow *) 0 ;
8325     bool result;
8326     PyObject * obj0 = 0 ;
8327     char *kwnames[] = {
8328         (char *) "self", NULL
8329     };
8330
8331     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterWindow_GetNeedUpdating",kwnames,&obj0)) goto fail;
8332     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8333     if (SWIG_arg_fail(1)) SWIG_fail;
8334     {
8335         PyThreadState* __tstate = wxPyBeginAllowThreads();
8336         result = (bool)((wxSplitterWindow const *)arg1)->GetNeedUpdating();
8337
8338         wxPyEndAllowThreads(__tstate);
8339         if (PyErr_Occurred()) SWIG_fail;
8340     }
8341     {
8342         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8343     }
8344     return resultobj;
8345     fail:
8346     return NULL;
8347 }
8348
8349
8350 static PyObject *_wrap_SplitterWindow_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8351     PyObject *resultobj;
8352     wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
8353     wxVisualAttributes result;
8354     PyObject * obj0 = 0 ;
8355     char *kwnames[] = {
8356         (char *) "variant", NULL
8357     };
8358
8359     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SplitterWindow_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
8360     if (obj0) {
8361         {
8362             arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
8363             if (SWIG_arg_fail(1)) SWIG_fail;
8364         }
8365     }
8366     {
8367         if (!wxPyCheckForApp()) SWIG_fail;
8368         PyThreadState* __tstate = wxPyBeginAllowThreads();
8369         result = wxSplitterWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
8370
8371         wxPyEndAllowThreads(__tstate);
8372         if (PyErr_Occurred()) SWIG_fail;
8373     }
8374     {
8375         wxVisualAttributes * resultptr;
8376         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
8377         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
8378     }
8379     return resultobj;
8380     fail:
8381     return NULL;
8382 }
8383
8384
8385 static PyObject * SplitterWindow_swigregister(PyObject *, PyObject *args) {
8386     PyObject *obj;
8387     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8388     SWIG_TypeClientData(SWIGTYPE_p_wxSplitterWindow, obj);
8389     Py_INCREF(obj);
8390     return Py_BuildValue((char *)"");
8391 }
8392 static PyObject *_wrap_new_SplitterEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8393     PyObject *resultobj;
8394     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
8395     wxSplitterWindow *arg2 = (wxSplitterWindow *) (wxSplitterWindow *) NULL ;
8396     wxSplitterEvent *result;
8397     PyObject * obj0 = 0 ;
8398     PyObject * obj1 = 0 ;
8399     char *kwnames[] = {
8400         (char *) "type",(char *) "splitter", NULL
8401     };
8402
8403     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SplitterEvent",kwnames,&obj0,&obj1)) goto fail;
8404     if (obj0) {
8405         {
8406             arg1 = (wxEventType)(SWIG_As_int(obj0));
8407             if (SWIG_arg_fail(1)) SWIG_fail;
8408         }
8409     }
8410     if (obj1) {
8411         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSplitterWindow, SWIG_POINTER_EXCEPTION | 0);
8412         if (SWIG_arg_fail(2)) SWIG_fail;
8413     }
8414     {
8415         PyThreadState* __tstate = wxPyBeginAllowThreads();
8416         result = (wxSplitterEvent *)new wxSplitterEvent(arg1,arg2);
8417
8418         wxPyEndAllowThreads(__tstate);
8419         if (PyErr_Occurred()) SWIG_fail;
8420     }
8421     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterEvent, 1);
8422     return resultobj;
8423     fail:
8424     return NULL;
8425 }
8426
8427
8428 static PyObject *_wrap_SplitterEvent_SetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8429     PyObject *resultobj;
8430     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8431     int arg2 ;
8432     PyObject * obj0 = 0 ;
8433     PyObject * obj1 = 0 ;
8434     char *kwnames[] = {
8435         (char *) "self",(char *) "pos", NULL
8436     };
8437
8438     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SplitterEvent_SetSashPosition",kwnames,&obj0,&obj1)) goto fail;
8439     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8440     if (SWIG_arg_fail(1)) SWIG_fail;
8441     {
8442         arg2 = (int)(SWIG_As_int(obj1));
8443         if (SWIG_arg_fail(2)) SWIG_fail;
8444     }
8445     {
8446         PyThreadState* __tstate = wxPyBeginAllowThreads();
8447         (arg1)->SetSashPosition(arg2);
8448
8449         wxPyEndAllowThreads(__tstate);
8450         if (PyErr_Occurred()) SWIG_fail;
8451     }
8452     Py_INCREF(Py_None); resultobj = Py_None;
8453     return resultobj;
8454     fail:
8455     return NULL;
8456 }
8457
8458
8459 static PyObject *_wrap_SplitterEvent_GetSashPosition(PyObject *, PyObject *args, PyObject *kwargs) {
8460     PyObject *resultobj;
8461     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8462     int result;
8463     PyObject * obj0 = 0 ;
8464     char *kwnames[] = {
8465         (char *) "self", NULL
8466     };
8467
8468     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetSashPosition",kwnames,&obj0)) goto fail;
8469     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8470     if (SWIG_arg_fail(1)) SWIG_fail;
8471     {
8472         PyThreadState* __tstate = wxPyBeginAllowThreads();
8473         result = (int)((wxSplitterEvent const *)arg1)->GetSashPosition();
8474
8475         wxPyEndAllowThreads(__tstate);
8476         if (PyErr_Occurred()) SWIG_fail;
8477     }
8478     {
8479         resultobj = SWIG_From_int((int)(result));
8480     }
8481     return resultobj;
8482     fail:
8483     return NULL;
8484 }
8485
8486
8487 static PyObject *_wrap_SplitterEvent_GetWindowBeingRemoved(PyObject *, PyObject *args, PyObject *kwargs) {
8488     PyObject *resultobj;
8489     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8490     wxWindow *result;
8491     PyObject * obj0 = 0 ;
8492     char *kwnames[] = {
8493         (char *) "self", NULL
8494     };
8495
8496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetWindowBeingRemoved",kwnames,&obj0)) goto fail;
8497     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8498     if (SWIG_arg_fail(1)) SWIG_fail;
8499     {
8500         PyThreadState* __tstate = wxPyBeginAllowThreads();
8501         result = (wxWindow *)((wxSplitterEvent const *)arg1)->GetWindowBeingRemoved();
8502
8503         wxPyEndAllowThreads(__tstate);
8504         if (PyErr_Occurred()) SWIG_fail;
8505     }
8506     {
8507         resultobj = wxPyMake_wxObject(result, 0);
8508     }
8509     return resultobj;
8510     fail:
8511     return NULL;
8512 }
8513
8514
8515 static PyObject *_wrap_SplitterEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
8516     PyObject *resultobj;
8517     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8518     int result;
8519     PyObject * obj0 = 0 ;
8520     char *kwnames[] = {
8521         (char *) "self", NULL
8522     };
8523
8524     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetX",kwnames,&obj0)) goto fail;
8525     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8526     if (SWIG_arg_fail(1)) SWIG_fail;
8527     {
8528         PyThreadState* __tstate = wxPyBeginAllowThreads();
8529         result = (int)((wxSplitterEvent const *)arg1)->GetX();
8530
8531         wxPyEndAllowThreads(__tstate);
8532         if (PyErr_Occurred()) SWIG_fail;
8533     }
8534     {
8535         resultobj = SWIG_From_int((int)(result));
8536     }
8537     return resultobj;
8538     fail:
8539     return NULL;
8540 }
8541
8542
8543 static PyObject *_wrap_SplitterEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
8544     PyObject *resultobj;
8545     wxSplitterEvent *arg1 = (wxSplitterEvent *) 0 ;
8546     int result;
8547     PyObject * obj0 = 0 ;
8548     char *kwnames[] = {
8549         (char *) "self", NULL
8550     };
8551
8552     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterEvent_GetY",kwnames,&obj0)) goto fail;
8553     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterEvent, SWIG_POINTER_EXCEPTION | 0);
8554     if (SWIG_arg_fail(1)) SWIG_fail;
8555     {
8556         PyThreadState* __tstate = wxPyBeginAllowThreads();
8557         result = (int)((wxSplitterEvent const *)arg1)->GetY();
8558
8559         wxPyEndAllowThreads(__tstate);
8560         if (PyErr_Occurred()) SWIG_fail;
8561     }
8562     {
8563         resultobj = SWIG_From_int((int)(result));
8564     }
8565     return resultobj;
8566     fail:
8567     return NULL;
8568 }
8569
8570
8571 static PyObject * SplitterEvent_swigregister(PyObject *, PyObject *args) {
8572     PyObject *obj;
8573     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8574     SWIG_TypeClientData(SWIGTYPE_p_wxSplitterEvent, obj);
8575     Py_INCREF(obj);
8576     return Py_BuildValue((char *)"");
8577 }
8578 static int _wrap_SashNameStr_set(PyObject *) {
8579     PyErr_SetString(PyExc_TypeError,"Variable SashNameStr is read-only.");
8580     return 1;
8581 }
8582
8583
8584 static PyObject *_wrap_SashNameStr_get(void) {
8585     PyObject *pyobj;
8586
8587     {
8588 #if wxUSE_UNICODE
8589         pyobj = PyUnicode_FromWideChar((&wxPySashNameStr)->c_str(), (&wxPySashNameStr)->Len());
8590 #else
8591         pyobj = PyString_FromStringAndSize((&wxPySashNameStr)->c_str(), (&wxPySashNameStr)->Len());
8592 #endif
8593     }
8594     return pyobj;
8595 }
8596
8597
8598 static int _wrap_SashLayoutNameStr_set(PyObject *) {
8599     PyErr_SetString(PyExc_TypeError,"Variable SashLayoutNameStr is read-only.");
8600     return 1;
8601 }
8602
8603
8604 static PyObject *_wrap_SashLayoutNameStr_get(void) {
8605     PyObject *pyobj;
8606
8607     {
8608 #if wxUSE_UNICODE
8609         pyobj = PyUnicode_FromWideChar((&wxPySashLayoutNameStr)->c_str(), (&wxPySashLayoutNameStr)->Len());
8610 #else
8611         pyobj = PyString_FromStringAndSize((&wxPySashLayoutNameStr)->c_str(), (&wxPySashLayoutNameStr)->Len());
8612 #endif
8613     }
8614     return pyobj;
8615 }
8616
8617
8618 static PyObject *_wrap_new_SashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
8619     PyObject *resultobj;
8620     wxWindow *arg1 = (wxWindow *) 0 ;
8621     int arg2 = (int) -1 ;
8622     wxPoint const &arg3_defvalue = wxDefaultPosition ;
8623     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
8624     wxSize const &arg4_defvalue = wxDefaultSize ;
8625     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
8626     long arg5 = (long) wxCLIP_CHILDREN|wxSW_3D ;
8627     wxString const &arg6_defvalue = wxPySashNameStr ;
8628     wxString *arg6 = (wxString *) &arg6_defvalue ;
8629     wxSashWindow *result;
8630     wxPoint temp3 ;
8631     wxSize temp4 ;
8632     bool temp6 = false ;
8633     PyObject * obj0 = 0 ;
8634     PyObject * obj1 = 0 ;
8635     PyObject * obj2 = 0 ;
8636     PyObject * obj3 = 0 ;
8637     PyObject * obj4 = 0 ;
8638     PyObject * obj5 = 0 ;
8639     char *kwnames[] = {
8640         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
8641     };
8642
8643     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SashWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
8644     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8645     if (SWIG_arg_fail(1)) SWIG_fail;
8646     if (obj1) {
8647         {
8648             arg2 = (int)(SWIG_As_int(obj1));
8649             if (SWIG_arg_fail(2)) SWIG_fail;
8650         }
8651     }
8652     if (obj2) {
8653         {
8654             arg3 = &temp3;
8655             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
8656         }
8657     }
8658     if (obj3) {
8659         {
8660             arg4 = &temp4;
8661             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
8662         }
8663     }
8664     if (obj4) {
8665         {
8666             arg5 = (long)(SWIG_As_long(obj4));
8667             if (SWIG_arg_fail(5)) SWIG_fail;
8668         }
8669     }
8670     if (obj5) {
8671         {
8672             arg6 = wxString_in_helper(obj5);
8673             if (arg6 == NULL) SWIG_fail;
8674             temp6 = true;
8675         }
8676     }
8677     {
8678         if (!wxPyCheckForApp()) SWIG_fail;
8679         PyThreadState* __tstate = wxPyBeginAllowThreads();
8680         result = (wxSashWindow *)new wxSashWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
8681
8682         wxPyEndAllowThreads(__tstate);
8683         if (PyErr_Occurred()) SWIG_fail;
8684     }
8685     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashWindow, 1);
8686     {
8687         if (temp6)
8688         delete arg6;
8689     }
8690     return resultobj;
8691     fail:
8692     {
8693         if (temp6)
8694         delete arg6;
8695     }
8696     return NULL;
8697 }
8698
8699
8700 static PyObject *_wrap_new_PreSashWindow(PyObject *, PyObject *args, PyObject *kwargs) {
8701     PyObject *resultobj;
8702     wxSashWindow *result;
8703     char *kwnames[] = {
8704         NULL
8705     };
8706
8707     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSashWindow",kwnames)) goto fail;
8708     {
8709         if (!wxPyCheckForApp()) SWIG_fail;
8710         PyThreadState* __tstate = wxPyBeginAllowThreads();
8711         result = (wxSashWindow *)new wxSashWindow();
8712
8713         wxPyEndAllowThreads(__tstate);
8714         if (PyErr_Occurred()) SWIG_fail;
8715     }
8716     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashWindow, 1);
8717     return resultobj;
8718     fail:
8719     return NULL;
8720 }
8721
8722
8723 static PyObject *_wrap_SashWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
8724     PyObject *resultobj;
8725     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8726     wxWindow *arg2 = (wxWindow *) 0 ;
8727     int arg3 = (int) -1 ;
8728     wxPoint const &arg4_defvalue = wxDefaultPosition ;
8729     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
8730     wxSize const &arg5_defvalue = wxDefaultSize ;
8731     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
8732     long arg6 = (long) wxCLIP_CHILDREN|wxSW_3D ;
8733     wxString const &arg7_defvalue = wxPySashNameStr ;
8734     wxString *arg7 = (wxString *) &arg7_defvalue ;
8735     bool result;
8736     wxPoint temp4 ;
8737     wxSize temp5 ;
8738     bool temp7 = false ;
8739     PyObject * obj0 = 0 ;
8740     PyObject * obj1 = 0 ;
8741     PyObject * obj2 = 0 ;
8742     PyObject * obj3 = 0 ;
8743     PyObject * obj4 = 0 ;
8744     PyObject * obj5 = 0 ;
8745     PyObject * obj6 = 0 ;
8746     char *kwnames[] = {
8747         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
8748     };
8749
8750     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SashWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
8751     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8752     if (SWIG_arg_fail(1)) SWIG_fail;
8753     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8754     if (SWIG_arg_fail(2)) SWIG_fail;
8755     if (obj2) {
8756         {
8757             arg3 = (int)(SWIG_As_int(obj2));
8758             if (SWIG_arg_fail(3)) SWIG_fail;
8759         }
8760     }
8761     if (obj3) {
8762         {
8763             arg4 = &temp4;
8764             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
8765         }
8766     }
8767     if (obj4) {
8768         {
8769             arg5 = &temp5;
8770             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
8771         }
8772     }
8773     if (obj5) {
8774         {
8775             arg6 = (long)(SWIG_As_long(obj5));
8776             if (SWIG_arg_fail(6)) SWIG_fail;
8777         }
8778     }
8779     if (obj6) {
8780         {
8781             arg7 = wxString_in_helper(obj6);
8782             if (arg7 == NULL) SWIG_fail;
8783             temp7 = true;
8784         }
8785     }
8786     {
8787         PyThreadState* __tstate = wxPyBeginAllowThreads();
8788         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
8789
8790         wxPyEndAllowThreads(__tstate);
8791         if (PyErr_Occurred()) SWIG_fail;
8792     }
8793     {
8794         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8795     }
8796     {
8797         if (temp7)
8798         delete arg7;
8799     }
8800     return resultobj;
8801     fail:
8802     {
8803         if (temp7)
8804         delete arg7;
8805     }
8806     return NULL;
8807 }
8808
8809
8810 static PyObject *_wrap_SashWindow_SetSashVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8811     PyObject *resultobj;
8812     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8813     wxSashEdgePosition arg2 ;
8814     bool arg3 ;
8815     PyObject * obj0 = 0 ;
8816     PyObject * obj1 = 0 ;
8817     PyObject * obj2 = 0 ;
8818     char *kwnames[] = {
8819         (char *) "self",(char *) "edge",(char *) "sash", NULL
8820     };
8821
8822     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SashWindow_SetSashVisible",kwnames,&obj0,&obj1,&obj2)) goto fail;
8823     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8824     if (SWIG_arg_fail(1)) SWIG_fail;
8825     {
8826         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8827         if (SWIG_arg_fail(2)) SWIG_fail;
8828     }
8829     {
8830         arg3 = (bool)(SWIG_As_bool(obj2));
8831         if (SWIG_arg_fail(3)) SWIG_fail;
8832     }
8833     {
8834         PyThreadState* __tstate = wxPyBeginAllowThreads();
8835         (arg1)->SetSashVisible((wxSashEdgePosition )arg2,arg3);
8836
8837         wxPyEndAllowThreads(__tstate);
8838         if (PyErr_Occurred()) SWIG_fail;
8839     }
8840     Py_INCREF(Py_None); resultobj = Py_None;
8841     return resultobj;
8842     fail:
8843     return NULL;
8844 }
8845
8846
8847 static PyObject *_wrap_SashWindow_GetSashVisible(PyObject *, PyObject *args, PyObject *kwargs) {
8848     PyObject *resultobj;
8849     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8850     wxSashEdgePosition arg2 ;
8851     bool result;
8852     PyObject * obj0 = 0 ;
8853     PyObject * obj1 = 0 ;
8854     char *kwnames[] = {
8855         (char *) "self",(char *) "edge", NULL
8856     };
8857
8858     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_GetSashVisible",kwnames,&obj0,&obj1)) goto fail;
8859     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8860     if (SWIG_arg_fail(1)) SWIG_fail;
8861     {
8862         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8863         if (SWIG_arg_fail(2)) SWIG_fail;
8864     }
8865     {
8866         PyThreadState* __tstate = wxPyBeginAllowThreads();
8867         result = (bool)((wxSashWindow const *)arg1)->GetSashVisible((wxSashEdgePosition )arg2);
8868
8869         wxPyEndAllowThreads(__tstate);
8870         if (PyErr_Occurred()) SWIG_fail;
8871     }
8872     {
8873         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8874     }
8875     return resultobj;
8876     fail:
8877     return NULL;
8878 }
8879
8880
8881 static PyObject *_wrap_SashWindow_SetSashBorder(PyObject *, PyObject *args, PyObject *kwargs) {
8882     PyObject *resultobj;
8883     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8884     wxSashEdgePosition arg2 ;
8885     bool arg3 ;
8886     PyObject * obj0 = 0 ;
8887     PyObject * obj1 = 0 ;
8888     PyObject * obj2 = 0 ;
8889     char *kwnames[] = {
8890         (char *) "self",(char *) "edge",(char *) "border", NULL
8891     };
8892
8893     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SashWindow_SetSashBorder",kwnames,&obj0,&obj1,&obj2)) goto fail;
8894     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8895     if (SWIG_arg_fail(1)) SWIG_fail;
8896     {
8897         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8898         if (SWIG_arg_fail(2)) SWIG_fail;
8899     }
8900     {
8901         arg3 = (bool)(SWIG_As_bool(obj2));
8902         if (SWIG_arg_fail(3)) SWIG_fail;
8903     }
8904     {
8905         PyThreadState* __tstate = wxPyBeginAllowThreads();
8906         (arg1)->SetSashBorder((wxSashEdgePosition )arg2,arg3);
8907
8908         wxPyEndAllowThreads(__tstate);
8909         if (PyErr_Occurred()) SWIG_fail;
8910     }
8911     Py_INCREF(Py_None); resultobj = Py_None;
8912     return resultobj;
8913     fail:
8914     return NULL;
8915 }
8916
8917
8918 static PyObject *_wrap_SashWindow_HasBorder(PyObject *, PyObject *args, PyObject *kwargs) {
8919     PyObject *resultobj;
8920     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8921     wxSashEdgePosition arg2 ;
8922     bool result;
8923     PyObject * obj0 = 0 ;
8924     PyObject * obj1 = 0 ;
8925     char *kwnames[] = {
8926         (char *) "self",(char *) "edge", NULL
8927     };
8928
8929     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_HasBorder",kwnames,&obj0,&obj1)) goto fail;
8930     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8931     if (SWIG_arg_fail(1)) SWIG_fail;
8932     {
8933         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8934         if (SWIG_arg_fail(2)) SWIG_fail;
8935     }
8936     {
8937         PyThreadState* __tstate = wxPyBeginAllowThreads();
8938         result = (bool)((wxSashWindow const *)arg1)->HasBorder((wxSashEdgePosition )arg2);
8939
8940         wxPyEndAllowThreads(__tstate);
8941         if (PyErr_Occurred()) SWIG_fail;
8942     }
8943     {
8944         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8945     }
8946     return resultobj;
8947     fail:
8948     return NULL;
8949 }
8950
8951
8952 static PyObject *_wrap_SashWindow_GetEdgeMargin(PyObject *, PyObject *args, PyObject *kwargs) {
8953     PyObject *resultobj;
8954     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8955     wxSashEdgePosition arg2 ;
8956     int result;
8957     PyObject * obj0 = 0 ;
8958     PyObject * obj1 = 0 ;
8959     char *kwnames[] = {
8960         (char *) "self",(char *) "edge", NULL
8961     };
8962
8963     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_GetEdgeMargin",kwnames,&obj0,&obj1)) goto fail;
8964     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8965     if (SWIG_arg_fail(1)) SWIG_fail;
8966     {
8967         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
8968         if (SWIG_arg_fail(2)) SWIG_fail;
8969     }
8970     {
8971         PyThreadState* __tstate = wxPyBeginAllowThreads();
8972         result = (int)((wxSashWindow const *)arg1)->GetEdgeMargin((wxSashEdgePosition )arg2);
8973
8974         wxPyEndAllowThreads(__tstate);
8975         if (PyErr_Occurred()) SWIG_fail;
8976     }
8977     {
8978         resultobj = SWIG_From_int((int)(result));
8979     }
8980     return resultobj;
8981     fail:
8982     return NULL;
8983 }
8984
8985
8986 static PyObject *_wrap_SashWindow_SetDefaultBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
8987     PyObject *resultobj;
8988     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
8989     int arg2 ;
8990     PyObject * obj0 = 0 ;
8991     PyObject * obj1 = 0 ;
8992     char *kwnames[] = {
8993         (char *) "self",(char *) "width", NULL
8994     };
8995
8996     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetDefaultBorderSize",kwnames,&obj0,&obj1)) goto fail;
8997     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
8998     if (SWIG_arg_fail(1)) SWIG_fail;
8999     {
9000         arg2 = (int)(SWIG_As_int(obj1));
9001         if (SWIG_arg_fail(2)) SWIG_fail;
9002     }
9003     {
9004         PyThreadState* __tstate = wxPyBeginAllowThreads();
9005         (arg1)->SetDefaultBorderSize(arg2);
9006
9007         wxPyEndAllowThreads(__tstate);
9008         if (PyErr_Occurred()) SWIG_fail;
9009     }
9010     Py_INCREF(Py_None); resultobj = Py_None;
9011     return resultobj;
9012     fail:
9013     return NULL;
9014 }
9015
9016
9017 static PyObject *_wrap_SashWindow_GetDefaultBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
9018     PyObject *resultobj;
9019     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9020     int result;
9021     PyObject * obj0 = 0 ;
9022     char *kwnames[] = {
9023         (char *) "self", NULL
9024     };
9025
9026     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetDefaultBorderSize",kwnames,&obj0)) goto fail;
9027     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9028     if (SWIG_arg_fail(1)) SWIG_fail;
9029     {
9030         PyThreadState* __tstate = wxPyBeginAllowThreads();
9031         result = (int)((wxSashWindow const *)arg1)->GetDefaultBorderSize();
9032
9033         wxPyEndAllowThreads(__tstate);
9034         if (PyErr_Occurred()) SWIG_fail;
9035     }
9036     {
9037         resultobj = SWIG_From_int((int)(result));
9038     }
9039     return resultobj;
9040     fail:
9041     return NULL;
9042 }
9043
9044
9045 static PyObject *_wrap_SashWindow_SetExtraBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
9046     PyObject *resultobj;
9047     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9048     int arg2 ;
9049     PyObject * obj0 = 0 ;
9050     PyObject * obj1 = 0 ;
9051     char *kwnames[] = {
9052         (char *) "self",(char *) "width", NULL
9053     };
9054
9055     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetExtraBorderSize",kwnames,&obj0,&obj1)) goto fail;
9056     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9057     if (SWIG_arg_fail(1)) SWIG_fail;
9058     {
9059         arg2 = (int)(SWIG_As_int(obj1));
9060         if (SWIG_arg_fail(2)) SWIG_fail;
9061     }
9062     {
9063         PyThreadState* __tstate = wxPyBeginAllowThreads();
9064         (arg1)->SetExtraBorderSize(arg2);
9065
9066         wxPyEndAllowThreads(__tstate);
9067         if (PyErr_Occurred()) SWIG_fail;
9068     }
9069     Py_INCREF(Py_None); resultobj = Py_None;
9070     return resultobj;
9071     fail:
9072     return NULL;
9073 }
9074
9075
9076 static PyObject *_wrap_SashWindow_GetExtraBorderSize(PyObject *, PyObject *args, PyObject *kwargs) {
9077     PyObject *resultobj;
9078     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9079     int result;
9080     PyObject * obj0 = 0 ;
9081     char *kwnames[] = {
9082         (char *) "self", NULL
9083     };
9084
9085     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetExtraBorderSize",kwnames,&obj0)) goto fail;
9086     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9087     if (SWIG_arg_fail(1)) SWIG_fail;
9088     {
9089         PyThreadState* __tstate = wxPyBeginAllowThreads();
9090         result = (int)((wxSashWindow const *)arg1)->GetExtraBorderSize();
9091
9092         wxPyEndAllowThreads(__tstate);
9093         if (PyErr_Occurred()) SWIG_fail;
9094     }
9095     {
9096         resultobj = SWIG_From_int((int)(result));
9097     }
9098     return resultobj;
9099     fail:
9100     return NULL;
9101 }
9102
9103
9104 static PyObject *_wrap_SashWindow_SetMinimumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9105     PyObject *resultobj;
9106     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9107     int arg2 ;
9108     PyObject * obj0 = 0 ;
9109     PyObject * obj1 = 0 ;
9110     char *kwnames[] = {
9111         (char *) "self",(char *) "min", NULL
9112     };
9113
9114     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMinimumSizeX",kwnames,&obj0,&obj1)) goto fail;
9115     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9116     if (SWIG_arg_fail(1)) SWIG_fail;
9117     {
9118         arg2 = (int)(SWIG_As_int(obj1));
9119         if (SWIG_arg_fail(2)) SWIG_fail;
9120     }
9121     {
9122         PyThreadState* __tstate = wxPyBeginAllowThreads();
9123         (arg1)->SetMinimumSizeX(arg2);
9124
9125         wxPyEndAllowThreads(__tstate);
9126         if (PyErr_Occurred()) SWIG_fail;
9127     }
9128     Py_INCREF(Py_None); resultobj = Py_None;
9129     return resultobj;
9130     fail:
9131     return NULL;
9132 }
9133
9134
9135 static PyObject *_wrap_SashWindow_SetMinimumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9136     PyObject *resultobj;
9137     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9138     int arg2 ;
9139     PyObject * obj0 = 0 ;
9140     PyObject * obj1 = 0 ;
9141     char *kwnames[] = {
9142         (char *) "self",(char *) "min", NULL
9143     };
9144
9145     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMinimumSizeY",kwnames,&obj0,&obj1)) goto fail;
9146     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9147     if (SWIG_arg_fail(1)) SWIG_fail;
9148     {
9149         arg2 = (int)(SWIG_As_int(obj1));
9150         if (SWIG_arg_fail(2)) SWIG_fail;
9151     }
9152     {
9153         PyThreadState* __tstate = wxPyBeginAllowThreads();
9154         (arg1)->SetMinimumSizeY(arg2);
9155
9156         wxPyEndAllowThreads(__tstate);
9157         if (PyErr_Occurred()) SWIG_fail;
9158     }
9159     Py_INCREF(Py_None); resultobj = Py_None;
9160     return resultobj;
9161     fail:
9162     return NULL;
9163 }
9164
9165
9166 static PyObject *_wrap_SashWindow_GetMinimumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9167     PyObject *resultobj;
9168     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9169     int result;
9170     PyObject * obj0 = 0 ;
9171     char *kwnames[] = {
9172         (char *) "self", NULL
9173     };
9174
9175     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMinimumSizeX",kwnames,&obj0)) goto fail;
9176     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9177     if (SWIG_arg_fail(1)) SWIG_fail;
9178     {
9179         PyThreadState* __tstate = wxPyBeginAllowThreads();
9180         result = (int)((wxSashWindow const *)arg1)->GetMinimumSizeX();
9181
9182         wxPyEndAllowThreads(__tstate);
9183         if (PyErr_Occurred()) SWIG_fail;
9184     }
9185     {
9186         resultobj = SWIG_From_int((int)(result));
9187     }
9188     return resultobj;
9189     fail:
9190     return NULL;
9191 }
9192
9193
9194 static PyObject *_wrap_SashWindow_GetMinimumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9195     PyObject *resultobj;
9196     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9197     int result;
9198     PyObject * obj0 = 0 ;
9199     char *kwnames[] = {
9200         (char *) "self", NULL
9201     };
9202
9203     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMinimumSizeY",kwnames,&obj0)) goto fail;
9204     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9205     if (SWIG_arg_fail(1)) SWIG_fail;
9206     {
9207         PyThreadState* __tstate = wxPyBeginAllowThreads();
9208         result = (int)((wxSashWindow const *)arg1)->GetMinimumSizeY();
9209
9210         wxPyEndAllowThreads(__tstate);
9211         if (PyErr_Occurred()) SWIG_fail;
9212     }
9213     {
9214         resultobj = SWIG_From_int((int)(result));
9215     }
9216     return resultobj;
9217     fail:
9218     return NULL;
9219 }
9220
9221
9222 static PyObject *_wrap_SashWindow_SetMaximumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9223     PyObject *resultobj;
9224     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9225     int arg2 ;
9226     PyObject * obj0 = 0 ;
9227     PyObject * obj1 = 0 ;
9228     char *kwnames[] = {
9229         (char *) "self",(char *) "max", NULL
9230     };
9231
9232     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMaximumSizeX",kwnames,&obj0,&obj1)) goto fail;
9233     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9234     if (SWIG_arg_fail(1)) SWIG_fail;
9235     {
9236         arg2 = (int)(SWIG_As_int(obj1));
9237         if (SWIG_arg_fail(2)) SWIG_fail;
9238     }
9239     {
9240         PyThreadState* __tstate = wxPyBeginAllowThreads();
9241         (arg1)->SetMaximumSizeX(arg2);
9242
9243         wxPyEndAllowThreads(__tstate);
9244         if (PyErr_Occurred()) SWIG_fail;
9245     }
9246     Py_INCREF(Py_None); resultobj = Py_None;
9247     return resultobj;
9248     fail:
9249     return NULL;
9250 }
9251
9252
9253 static PyObject *_wrap_SashWindow_SetMaximumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9254     PyObject *resultobj;
9255     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9256     int arg2 ;
9257     PyObject * obj0 = 0 ;
9258     PyObject * obj1 = 0 ;
9259     char *kwnames[] = {
9260         (char *) "self",(char *) "max", NULL
9261     };
9262
9263     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashWindow_SetMaximumSizeY",kwnames,&obj0,&obj1)) goto fail;
9264     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9265     if (SWIG_arg_fail(1)) SWIG_fail;
9266     {
9267         arg2 = (int)(SWIG_As_int(obj1));
9268         if (SWIG_arg_fail(2)) SWIG_fail;
9269     }
9270     {
9271         PyThreadState* __tstate = wxPyBeginAllowThreads();
9272         (arg1)->SetMaximumSizeY(arg2);
9273
9274         wxPyEndAllowThreads(__tstate);
9275         if (PyErr_Occurred()) SWIG_fail;
9276     }
9277     Py_INCREF(Py_None); resultobj = Py_None;
9278     return resultobj;
9279     fail:
9280     return NULL;
9281 }
9282
9283
9284 static PyObject *_wrap_SashWindow_GetMaximumSizeX(PyObject *, PyObject *args, PyObject *kwargs) {
9285     PyObject *resultobj;
9286     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9287     int result;
9288     PyObject * obj0 = 0 ;
9289     char *kwnames[] = {
9290         (char *) "self", NULL
9291     };
9292
9293     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMaximumSizeX",kwnames,&obj0)) goto fail;
9294     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9295     if (SWIG_arg_fail(1)) SWIG_fail;
9296     {
9297         PyThreadState* __tstate = wxPyBeginAllowThreads();
9298         result = (int)((wxSashWindow const *)arg1)->GetMaximumSizeX();
9299
9300         wxPyEndAllowThreads(__tstate);
9301         if (PyErr_Occurred()) SWIG_fail;
9302     }
9303     {
9304         resultobj = SWIG_From_int((int)(result));
9305     }
9306     return resultobj;
9307     fail:
9308     return NULL;
9309 }
9310
9311
9312 static PyObject *_wrap_SashWindow_GetMaximumSizeY(PyObject *, PyObject *args, PyObject *kwargs) {
9313     PyObject *resultobj;
9314     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9315     int result;
9316     PyObject * obj0 = 0 ;
9317     char *kwnames[] = {
9318         (char *) "self", NULL
9319     };
9320
9321     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_GetMaximumSizeY",kwnames,&obj0)) goto fail;
9322     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9323     if (SWIG_arg_fail(1)) SWIG_fail;
9324     {
9325         PyThreadState* __tstate = wxPyBeginAllowThreads();
9326         result = (int)((wxSashWindow const *)arg1)->GetMaximumSizeY();
9327
9328         wxPyEndAllowThreads(__tstate);
9329         if (PyErr_Occurred()) SWIG_fail;
9330     }
9331     {
9332         resultobj = SWIG_From_int((int)(result));
9333     }
9334     return resultobj;
9335     fail:
9336     return NULL;
9337 }
9338
9339
9340 static PyObject *_wrap_SashWindow_SashHitTest(PyObject *, PyObject *args, PyObject *kwargs) {
9341     PyObject *resultobj;
9342     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9343     int arg2 ;
9344     int arg3 ;
9345     int arg4 = (int) 2 ;
9346     wxSashEdgePosition result;
9347     PyObject * obj0 = 0 ;
9348     PyObject * obj1 = 0 ;
9349     PyObject * obj2 = 0 ;
9350     PyObject * obj3 = 0 ;
9351     char *kwnames[] = {
9352         (char *) "self",(char *) "x",(char *) "y",(char *) "tolerance", NULL
9353     };
9354
9355     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:SashWindow_SashHitTest",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9356     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9357     if (SWIG_arg_fail(1)) SWIG_fail;
9358     {
9359         arg2 = (int)(SWIG_As_int(obj1));
9360         if (SWIG_arg_fail(2)) SWIG_fail;
9361     }
9362     {
9363         arg3 = (int)(SWIG_As_int(obj2));
9364         if (SWIG_arg_fail(3)) SWIG_fail;
9365     }
9366     if (obj3) {
9367         {
9368             arg4 = (int)(SWIG_As_int(obj3));
9369             if (SWIG_arg_fail(4)) SWIG_fail;
9370         }
9371     }
9372     {
9373         PyThreadState* __tstate = wxPyBeginAllowThreads();
9374         result = (wxSashEdgePosition)(arg1)->SashHitTest(arg2,arg3,arg4);
9375
9376         wxPyEndAllowThreads(__tstate);
9377         if (PyErr_Occurred()) SWIG_fail;
9378     }
9379     resultobj = SWIG_From_int((result));
9380     return resultobj;
9381     fail:
9382     return NULL;
9383 }
9384
9385
9386 static PyObject *_wrap_SashWindow_SizeWindows(PyObject *, PyObject *args, PyObject *kwargs) {
9387     PyObject *resultobj;
9388     wxSashWindow *arg1 = (wxSashWindow *) 0 ;
9389     PyObject * obj0 = 0 ;
9390     char *kwnames[] = {
9391         (char *) "self", NULL
9392     };
9393
9394     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashWindow_SizeWindows",kwnames,&obj0)) goto fail;
9395     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashWindow, SWIG_POINTER_EXCEPTION | 0);
9396     if (SWIG_arg_fail(1)) SWIG_fail;
9397     {
9398         PyThreadState* __tstate = wxPyBeginAllowThreads();
9399         (arg1)->SizeWindows();
9400
9401         wxPyEndAllowThreads(__tstate);
9402         if (PyErr_Occurred()) SWIG_fail;
9403     }
9404     Py_INCREF(Py_None); resultobj = Py_None;
9405     return resultobj;
9406     fail:
9407     return NULL;
9408 }
9409
9410
9411 static PyObject * SashWindow_swigregister(PyObject *, PyObject *args) {
9412     PyObject *obj;
9413     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9414     SWIG_TypeClientData(SWIGTYPE_p_wxSashWindow, obj);
9415     Py_INCREF(obj);
9416     return Py_BuildValue((char *)"");
9417 }
9418 static PyObject *_wrap_new_SashEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9419     PyObject *resultobj;
9420     int arg1 = (int) 0 ;
9421     wxSashEdgePosition arg2 = (wxSashEdgePosition) wxSASH_NONE ;
9422     wxSashEvent *result;
9423     PyObject * obj0 = 0 ;
9424     PyObject * obj1 = 0 ;
9425     char *kwnames[] = {
9426         (char *) "id",(char *) "edge", NULL
9427     };
9428
9429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SashEvent",kwnames,&obj0,&obj1)) goto fail;
9430     if (obj0) {
9431         {
9432             arg1 = (int)(SWIG_As_int(obj0));
9433             if (SWIG_arg_fail(1)) SWIG_fail;
9434         }
9435     }
9436     if (obj1) {
9437         {
9438             arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
9439             if (SWIG_arg_fail(2)) SWIG_fail;
9440         }
9441     }
9442     {
9443         PyThreadState* __tstate = wxPyBeginAllowThreads();
9444         result = (wxSashEvent *)new wxSashEvent(arg1,(wxSashEdgePosition )arg2);
9445
9446         wxPyEndAllowThreads(__tstate);
9447         if (PyErr_Occurred()) SWIG_fail;
9448     }
9449     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashEvent, 1);
9450     return resultobj;
9451     fail:
9452     return NULL;
9453 }
9454
9455
9456 static PyObject *_wrap_SashEvent_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
9457     PyObject *resultobj;
9458     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9459     wxSashEdgePosition arg2 ;
9460     PyObject * obj0 = 0 ;
9461     PyObject * obj1 = 0 ;
9462     char *kwnames[] = {
9463         (char *) "self",(char *) "edge", NULL
9464     };
9465
9466     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetEdge",kwnames,&obj0,&obj1)) goto fail;
9467     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9468     if (SWIG_arg_fail(1)) SWIG_fail;
9469     {
9470         arg2 = (wxSashEdgePosition)(SWIG_As_int(obj1));
9471         if (SWIG_arg_fail(2)) SWIG_fail;
9472     }
9473     {
9474         PyThreadState* __tstate = wxPyBeginAllowThreads();
9475         (arg1)->SetEdge((wxSashEdgePosition )arg2);
9476
9477         wxPyEndAllowThreads(__tstate);
9478         if (PyErr_Occurred()) SWIG_fail;
9479     }
9480     Py_INCREF(Py_None); resultobj = Py_None;
9481     return resultobj;
9482     fail:
9483     return NULL;
9484 }
9485
9486
9487 static PyObject *_wrap_SashEvent_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
9488     PyObject *resultobj;
9489     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9490     wxSashEdgePosition result;
9491     PyObject * obj0 = 0 ;
9492     char *kwnames[] = {
9493         (char *) "self", NULL
9494     };
9495
9496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetEdge",kwnames,&obj0)) goto fail;
9497     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9498     if (SWIG_arg_fail(1)) SWIG_fail;
9499     {
9500         PyThreadState* __tstate = wxPyBeginAllowThreads();
9501         result = (wxSashEdgePosition)((wxSashEvent const *)arg1)->GetEdge();
9502
9503         wxPyEndAllowThreads(__tstate);
9504         if (PyErr_Occurred()) SWIG_fail;
9505     }
9506     resultobj = SWIG_From_int((result));
9507     return resultobj;
9508     fail:
9509     return NULL;
9510 }
9511
9512
9513 static PyObject *_wrap_SashEvent_SetDragRect(PyObject *, PyObject *args, PyObject *kwargs) {
9514     PyObject *resultobj;
9515     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9516     wxRect *arg2 = 0 ;
9517     wxRect temp2 ;
9518     PyObject * obj0 = 0 ;
9519     PyObject * obj1 = 0 ;
9520     char *kwnames[] = {
9521         (char *) "self",(char *) "rect", NULL
9522     };
9523
9524     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetDragRect",kwnames,&obj0,&obj1)) goto fail;
9525     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9526     if (SWIG_arg_fail(1)) SWIG_fail;
9527     {
9528         arg2 = &temp2;
9529         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
9530     }
9531     {
9532         PyThreadState* __tstate = wxPyBeginAllowThreads();
9533         (arg1)->SetDragRect((wxRect const &)*arg2);
9534
9535         wxPyEndAllowThreads(__tstate);
9536         if (PyErr_Occurred()) SWIG_fail;
9537     }
9538     Py_INCREF(Py_None); resultobj = Py_None;
9539     return resultobj;
9540     fail:
9541     return NULL;
9542 }
9543
9544
9545 static PyObject *_wrap_SashEvent_GetDragRect(PyObject *, PyObject *args, PyObject *kwargs) {
9546     PyObject *resultobj;
9547     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9548     wxRect result;
9549     PyObject * obj0 = 0 ;
9550     char *kwnames[] = {
9551         (char *) "self", NULL
9552     };
9553
9554     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetDragRect",kwnames,&obj0)) goto fail;
9555     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9556     if (SWIG_arg_fail(1)) SWIG_fail;
9557     {
9558         PyThreadState* __tstate = wxPyBeginAllowThreads();
9559         result = ((wxSashEvent const *)arg1)->GetDragRect();
9560
9561         wxPyEndAllowThreads(__tstate);
9562         if (PyErr_Occurred()) SWIG_fail;
9563     }
9564     {
9565         wxRect * resultptr;
9566         resultptr = new wxRect((wxRect &)(result));
9567         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
9568     }
9569     return resultobj;
9570     fail:
9571     return NULL;
9572 }
9573
9574
9575 static PyObject *_wrap_SashEvent_SetDragStatus(PyObject *, PyObject *args, PyObject *kwargs) {
9576     PyObject *resultobj;
9577     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9578     wxSashDragStatus arg2 ;
9579     PyObject * obj0 = 0 ;
9580     PyObject * obj1 = 0 ;
9581     char *kwnames[] = {
9582         (char *) "self",(char *) "status", NULL
9583     };
9584
9585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashEvent_SetDragStatus",kwnames,&obj0,&obj1)) goto fail;
9586     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9587     if (SWIG_arg_fail(1)) SWIG_fail;
9588     {
9589         arg2 = (wxSashDragStatus)(SWIG_As_int(obj1));
9590         if (SWIG_arg_fail(2)) SWIG_fail;
9591     }
9592     {
9593         PyThreadState* __tstate = wxPyBeginAllowThreads();
9594         (arg1)->SetDragStatus((wxSashDragStatus )arg2);
9595
9596         wxPyEndAllowThreads(__tstate);
9597         if (PyErr_Occurred()) SWIG_fail;
9598     }
9599     Py_INCREF(Py_None); resultobj = Py_None;
9600     return resultobj;
9601     fail:
9602     return NULL;
9603 }
9604
9605
9606 static PyObject *_wrap_SashEvent_GetDragStatus(PyObject *, PyObject *args, PyObject *kwargs) {
9607     PyObject *resultobj;
9608     wxSashEvent *arg1 = (wxSashEvent *) 0 ;
9609     wxSashDragStatus result;
9610     PyObject * obj0 = 0 ;
9611     char *kwnames[] = {
9612         (char *) "self", NULL
9613     };
9614
9615     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashEvent_GetDragStatus",kwnames,&obj0)) goto fail;
9616     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashEvent, SWIG_POINTER_EXCEPTION | 0);
9617     if (SWIG_arg_fail(1)) SWIG_fail;
9618     {
9619         PyThreadState* __tstate = wxPyBeginAllowThreads();
9620         result = (wxSashDragStatus)((wxSashEvent const *)arg1)->GetDragStatus();
9621
9622         wxPyEndAllowThreads(__tstate);
9623         if (PyErr_Occurred()) SWIG_fail;
9624     }
9625     resultobj = SWIG_From_int((result));
9626     return resultobj;
9627     fail:
9628     return NULL;
9629 }
9630
9631
9632 static PyObject * SashEvent_swigregister(PyObject *, PyObject *args) {
9633     PyObject *obj;
9634     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9635     SWIG_TypeClientData(SWIGTYPE_p_wxSashEvent, obj);
9636     Py_INCREF(obj);
9637     return Py_BuildValue((char *)"");
9638 }
9639 static PyObject *_wrap_new_QueryLayoutInfoEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9640     PyObject *resultobj;
9641     int arg1 = (int) 0 ;
9642     wxQueryLayoutInfoEvent *result;
9643     PyObject * obj0 = 0 ;
9644     char *kwnames[] = {
9645         (char *) "id", NULL
9646     };
9647
9648     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryLayoutInfoEvent",kwnames,&obj0)) goto fail;
9649     if (obj0) {
9650         {
9651             arg1 = (int)(SWIG_As_int(obj0));
9652             if (SWIG_arg_fail(1)) SWIG_fail;
9653         }
9654     }
9655     {
9656         PyThreadState* __tstate = wxPyBeginAllowThreads();
9657         result = (wxQueryLayoutInfoEvent *)new wxQueryLayoutInfoEvent(arg1);
9658
9659         wxPyEndAllowThreads(__tstate);
9660         if (PyErr_Occurred()) SWIG_fail;
9661     }
9662     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryLayoutInfoEvent, 1);
9663     return resultobj;
9664     fail:
9665     return NULL;
9666 }
9667
9668
9669 static PyObject *_wrap_QueryLayoutInfoEvent_SetRequestedLength(PyObject *, PyObject *args, PyObject *kwargs) {
9670     PyObject *resultobj;
9671     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9672     int arg2 ;
9673     PyObject * obj0 = 0 ;
9674     PyObject * obj1 = 0 ;
9675     char *kwnames[] = {
9676         (char *) "self",(char *) "length", NULL
9677     };
9678
9679     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetRequestedLength",kwnames,&obj0,&obj1)) goto fail;
9680     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9681     if (SWIG_arg_fail(1)) SWIG_fail;
9682     {
9683         arg2 = (int)(SWIG_As_int(obj1));
9684         if (SWIG_arg_fail(2)) SWIG_fail;
9685     }
9686     {
9687         PyThreadState* __tstate = wxPyBeginAllowThreads();
9688         (arg1)->SetRequestedLength(arg2);
9689
9690         wxPyEndAllowThreads(__tstate);
9691         if (PyErr_Occurred()) SWIG_fail;
9692     }
9693     Py_INCREF(Py_None); resultobj = Py_None;
9694     return resultobj;
9695     fail:
9696     return NULL;
9697 }
9698
9699
9700 static PyObject *_wrap_QueryLayoutInfoEvent_GetRequestedLength(PyObject *, PyObject *args, PyObject *kwargs) {
9701     PyObject *resultobj;
9702     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9703     int result;
9704     PyObject * obj0 = 0 ;
9705     char *kwnames[] = {
9706         (char *) "self", NULL
9707     };
9708
9709     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetRequestedLength",kwnames,&obj0)) goto fail;
9710     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9711     if (SWIG_arg_fail(1)) SWIG_fail;
9712     {
9713         PyThreadState* __tstate = wxPyBeginAllowThreads();
9714         result = (int)((wxQueryLayoutInfoEvent const *)arg1)->GetRequestedLength();
9715
9716         wxPyEndAllowThreads(__tstate);
9717         if (PyErr_Occurred()) SWIG_fail;
9718     }
9719     {
9720         resultobj = SWIG_From_int((int)(result));
9721     }
9722     return resultobj;
9723     fail:
9724     return NULL;
9725 }
9726
9727
9728 static PyObject *_wrap_QueryLayoutInfoEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9729     PyObject *resultobj;
9730     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9731     int arg2 ;
9732     PyObject * obj0 = 0 ;
9733     PyObject * obj1 = 0 ;
9734     char *kwnames[] = {
9735         (char *) "self",(char *) "flags", NULL
9736     };
9737
9738     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
9739     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9740     if (SWIG_arg_fail(1)) SWIG_fail;
9741     {
9742         arg2 = (int)(SWIG_As_int(obj1));
9743         if (SWIG_arg_fail(2)) SWIG_fail;
9744     }
9745     {
9746         PyThreadState* __tstate = wxPyBeginAllowThreads();
9747         (arg1)->SetFlags(arg2);
9748
9749         wxPyEndAllowThreads(__tstate);
9750         if (PyErr_Occurred()) SWIG_fail;
9751     }
9752     Py_INCREF(Py_None); resultobj = Py_None;
9753     return resultobj;
9754     fail:
9755     return NULL;
9756 }
9757
9758
9759 static PyObject *_wrap_QueryLayoutInfoEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
9760     PyObject *resultobj;
9761     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9762     int result;
9763     PyObject * obj0 = 0 ;
9764     char *kwnames[] = {
9765         (char *) "self", NULL
9766     };
9767
9768     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetFlags",kwnames,&obj0)) goto fail;
9769     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9770     if (SWIG_arg_fail(1)) SWIG_fail;
9771     {
9772         PyThreadState* __tstate = wxPyBeginAllowThreads();
9773         result = (int)((wxQueryLayoutInfoEvent const *)arg1)->GetFlags();
9774
9775         wxPyEndAllowThreads(__tstate);
9776         if (PyErr_Occurred()) SWIG_fail;
9777     }
9778     {
9779         resultobj = SWIG_From_int((int)(result));
9780     }
9781     return resultobj;
9782     fail:
9783     return NULL;
9784 }
9785
9786
9787 static PyObject *_wrap_QueryLayoutInfoEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
9788     PyObject *resultobj;
9789     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9790     wxSize *arg2 = 0 ;
9791     wxSize temp2 ;
9792     PyObject * obj0 = 0 ;
9793     PyObject * obj1 = 0 ;
9794     char *kwnames[] = {
9795         (char *) "self",(char *) "size", NULL
9796     };
9797
9798     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
9799     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9800     if (SWIG_arg_fail(1)) SWIG_fail;
9801     {
9802         arg2 = &temp2;
9803         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
9804     }
9805     {
9806         PyThreadState* __tstate = wxPyBeginAllowThreads();
9807         (arg1)->SetSize((wxSize const &)*arg2);
9808
9809         wxPyEndAllowThreads(__tstate);
9810         if (PyErr_Occurred()) SWIG_fail;
9811     }
9812     Py_INCREF(Py_None); resultobj = Py_None;
9813     return resultobj;
9814     fail:
9815     return NULL;
9816 }
9817
9818
9819 static PyObject *_wrap_QueryLayoutInfoEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
9820     PyObject *resultobj;
9821     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9822     wxSize result;
9823     PyObject * obj0 = 0 ;
9824     char *kwnames[] = {
9825         (char *) "self", NULL
9826     };
9827
9828     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetSize",kwnames,&obj0)) goto fail;
9829     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9830     if (SWIG_arg_fail(1)) SWIG_fail;
9831     {
9832         PyThreadState* __tstate = wxPyBeginAllowThreads();
9833         result = ((wxQueryLayoutInfoEvent const *)arg1)->GetSize();
9834
9835         wxPyEndAllowThreads(__tstate);
9836         if (PyErr_Occurred()) SWIG_fail;
9837     }
9838     {
9839         wxSize * resultptr;
9840         resultptr = new wxSize((wxSize &)(result));
9841         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9842     }
9843     return resultobj;
9844     fail:
9845     return NULL;
9846 }
9847
9848
9849 static PyObject *_wrap_QueryLayoutInfoEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
9850     PyObject *resultobj;
9851     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9852     wxLayoutOrientation arg2 ;
9853     PyObject * obj0 = 0 ;
9854     PyObject * obj1 = 0 ;
9855     char *kwnames[] = {
9856         (char *) "self",(char *) "orient", NULL
9857     };
9858
9859     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
9860     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9861     if (SWIG_arg_fail(1)) SWIG_fail;
9862     {
9863         arg2 = (wxLayoutOrientation)(SWIG_As_int(obj1));
9864         if (SWIG_arg_fail(2)) SWIG_fail;
9865     }
9866     {
9867         PyThreadState* __tstate = wxPyBeginAllowThreads();
9868         (arg1)->SetOrientation((wxLayoutOrientation )arg2);
9869
9870         wxPyEndAllowThreads(__tstate);
9871         if (PyErr_Occurred()) SWIG_fail;
9872     }
9873     Py_INCREF(Py_None); resultobj = Py_None;
9874     return resultobj;
9875     fail:
9876     return NULL;
9877 }
9878
9879
9880 static PyObject *_wrap_QueryLayoutInfoEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
9881     PyObject *resultobj;
9882     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9883     wxLayoutOrientation result;
9884     PyObject * obj0 = 0 ;
9885     char *kwnames[] = {
9886         (char *) "self", NULL
9887     };
9888
9889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetOrientation",kwnames,&obj0)) goto fail;
9890     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9891     if (SWIG_arg_fail(1)) SWIG_fail;
9892     {
9893         PyThreadState* __tstate = wxPyBeginAllowThreads();
9894         result = (wxLayoutOrientation)((wxQueryLayoutInfoEvent const *)arg1)->GetOrientation();
9895
9896         wxPyEndAllowThreads(__tstate);
9897         if (PyErr_Occurred()) SWIG_fail;
9898     }
9899     resultobj = SWIG_From_int((result));
9900     return resultobj;
9901     fail:
9902     return NULL;
9903 }
9904
9905
9906 static PyObject *_wrap_QueryLayoutInfoEvent_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9907     PyObject *resultobj;
9908     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9909     wxLayoutAlignment arg2 ;
9910     PyObject * obj0 = 0 ;
9911     PyObject * obj1 = 0 ;
9912     char *kwnames[] = {
9913         (char *) "self",(char *) "align", NULL
9914     };
9915
9916     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryLayoutInfoEvent_SetAlignment",kwnames,&obj0,&obj1)) goto fail;
9917     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9918     if (SWIG_arg_fail(1)) SWIG_fail;
9919     {
9920         arg2 = (wxLayoutAlignment)(SWIG_As_int(obj1));
9921         if (SWIG_arg_fail(2)) SWIG_fail;
9922     }
9923     {
9924         PyThreadState* __tstate = wxPyBeginAllowThreads();
9925         (arg1)->SetAlignment((wxLayoutAlignment )arg2);
9926
9927         wxPyEndAllowThreads(__tstate);
9928         if (PyErr_Occurred()) SWIG_fail;
9929     }
9930     Py_INCREF(Py_None); resultobj = Py_None;
9931     return resultobj;
9932     fail:
9933     return NULL;
9934 }
9935
9936
9937 static PyObject *_wrap_QueryLayoutInfoEvent_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
9938     PyObject *resultobj;
9939     wxQueryLayoutInfoEvent *arg1 = (wxQueryLayoutInfoEvent *) 0 ;
9940     wxLayoutAlignment result;
9941     PyObject * obj0 = 0 ;
9942     char *kwnames[] = {
9943         (char *) "self", NULL
9944     };
9945
9946     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryLayoutInfoEvent_GetAlignment",kwnames,&obj0)) goto fail;
9947     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryLayoutInfoEvent, SWIG_POINTER_EXCEPTION | 0);
9948     if (SWIG_arg_fail(1)) SWIG_fail;
9949     {
9950         PyThreadState* __tstate = wxPyBeginAllowThreads();
9951         result = (wxLayoutAlignment)((wxQueryLayoutInfoEvent const *)arg1)->GetAlignment();
9952
9953         wxPyEndAllowThreads(__tstate);
9954         if (PyErr_Occurred()) SWIG_fail;
9955     }
9956     resultobj = SWIG_From_int((result));
9957     return resultobj;
9958     fail:
9959     return NULL;
9960 }
9961
9962
9963 static PyObject * QueryLayoutInfoEvent_swigregister(PyObject *, PyObject *args) {
9964     PyObject *obj;
9965     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9966     SWIG_TypeClientData(SWIGTYPE_p_wxQueryLayoutInfoEvent, obj);
9967     Py_INCREF(obj);
9968     return Py_BuildValue((char *)"");
9969 }
9970 static PyObject *_wrap_new_CalculateLayoutEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9971     PyObject *resultobj;
9972     int arg1 = (int) 0 ;
9973     wxCalculateLayoutEvent *result;
9974     PyObject * obj0 = 0 ;
9975     char *kwnames[] = {
9976         (char *) "id", NULL
9977     };
9978
9979     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_CalculateLayoutEvent",kwnames,&obj0)) goto fail;
9980     if (obj0) {
9981         {
9982             arg1 = (int)(SWIG_As_int(obj0));
9983             if (SWIG_arg_fail(1)) SWIG_fail;
9984         }
9985     }
9986     {
9987         PyThreadState* __tstate = wxPyBeginAllowThreads();
9988         result = (wxCalculateLayoutEvent *)new wxCalculateLayoutEvent(arg1);
9989
9990         wxPyEndAllowThreads(__tstate);
9991         if (PyErr_Occurred()) SWIG_fail;
9992     }
9993     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCalculateLayoutEvent, 1);
9994     return resultobj;
9995     fail:
9996     return NULL;
9997 }
9998
9999
10000 static PyObject *_wrap_CalculateLayoutEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
10001     PyObject *resultobj;
10002     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10003     int arg2 ;
10004     PyObject * obj0 = 0 ;
10005     PyObject * obj1 = 0 ;
10006     char *kwnames[] = {
10007         (char *) "self",(char *) "flags", NULL
10008     };
10009
10010     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CalculateLayoutEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
10011     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10012     if (SWIG_arg_fail(1)) SWIG_fail;
10013     {
10014         arg2 = (int)(SWIG_As_int(obj1));
10015         if (SWIG_arg_fail(2)) SWIG_fail;
10016     }
10017     {
10018         PyThreadState* __tstate = wxPyBeginAllowThreads();
10019         (arg1)->SetFlags(arg2);
10020
10021         wxPyEndAllowThreads(__tstate);
10022         if (PyErr_Occurred()) SWIG_fail;
10023     }
10024     Py_INCREF(Py_None); resultobj = Py_None;
10025     return resultobj;
10026     fail:
10027     return NULL;
10028 }
10029
10030
10031 static PyObject *_wrap_CalculateLayoutEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
10032     PyObject *resultobj;
10033     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10034     int result;
10035     PyObject * obj0 = 0 ;
10036     char *kwnames[] = {
10037         (char *) "self", NULL
10038     };
10039
10040     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CalculateLayoutEvent_GetFlags",kwnames,&obj0)) goto fail;
10041     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10042     if (SWIG_arg_fail(1)) SWIG_fail;
10043     {
10044         PyThreadState* __tstate = wxPyBeginAllowThreads();
10045         result = (int)((wxCalculateLayoutEvent const *)arg1)->GetFlags();
10046
10047         wxPyEndAllowThreads(__tstate);
10048         if (PyErr_Occurred()) SWIG_fail;
10049     }
10050     {
10051         resultobj = SWIG_From_int((int)(result));
10052     }
10053     return resultobj;
10054     fail:
10055     return NULL;
10056 }
10057
10058
10059 static PyObject *_wrap_CalculateLayoutEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
10060     PyObject *resultobj;
10061     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10062     wxRect *arg2 = 0 ;
10063     wxRect temp2 ;
10064     PyObject * obj0 = 0 ;
10065     PyObject * obj1 = 0 ;
10066     char *kwnames[] = {
10067         (char *) "self",(char *) "rect", NULL
10068     };
10069
10070     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CalculateLayoutEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
10071     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10072     if (SWIG_arg_fail(1)) SWIG_fail;
10073     {
10074         arg2 = &temp2;
10075         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10076     }
10077     {
10078         PyThreadState* __tstate = wxPyBeginAllowThreads();
10079         (arg1)->SetRect((wxRect const &)*arg2);
10080
10081         wxPyEndAllowThreads(__tstate);
10082         if (PyErr_Occurred()) SWIG_fail;
10083     }
10084     Py_INCREF(Py_None); resultobj = Py_None;
10085     return resultobj;
10086     fail:
10087     return NULL;
10088 }
10089
10090
10091 static PyObject *_wrap_CalculateLayoutEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
10092     PyObject *resultobj;
10093     wxCalculateLayoutEvent *arg1 = (wxCalculateLayoutEvent *) 0 ;
10094     wxRect result;
10095     PyObject * obj0 = 0 ;
10096     char *kwnames[] = {
10097         (char *) "self", NULL
10098     };
10099
10100     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CalculateLayoutEvent_GetRect",kwnames,&obj0)) goto fail;
10101     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCalculateLayoutEvent, SWIG_POINTER_EXCEPTION | 0);
10102     if (SWIG_arg_fail(1)) SWIG_fail;
10103     {
10104         PyThreadState* __tstate = wxPyBeginAllowThreads();
10105         result = ((wxCalculateLayoutEvent const *)arg1)->GetRect();
10106
10107         wxPyEndAllowThreads(__tstate);
10108         if (PyErr_Occurred()) SWIG_fail;
10109     }
10110     {
10111         wxRect * resultptr;
10112         resultptr = new wxRect((wxRect &)(result));
10113         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
10114     }
10115     return resultobj;
10116     fail:
10117     return NULL;
10118 }
10119
10120
10121 static PyObject * CalculateLayoutEvent_swigregister(PyObject *, PyObject *args) {
10122     PyObject *obj;
10123     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10124     SWIG_TypeClientData(SWIGTYPE_p_wxCalculateLayoutEvent, obj);
10125     Py_INCREF(obj);
10126     return Py_BuildValue((char *)"");
10127 }
10128 static PyObject *_wrap_new_SashLayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10129     PyObject *resultobj;
10130     wxWindow *arg1 = (wxWindow *) 0 ;
10131     int arg2 = (int) -1 ;
10132     wxPoint const &arg3_defvalue = wxDefaultPosition ;
10133     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10134     wxSize const &arg4_defvalue = wxDefaultSize ;
10135     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10136     long arg5 = (long) wxCLIP_CHILDREN|wxSW_3D ;
10137     wxString const &arg6_defvalue = wxPySashLayoutNameStr ;
10138     wxString *arg6 = (wxString *) &arg6_defvalue ;
10139     wxSashLayoutWindow *result;
10140     wxPoint temp3 ;
10141     wxSize temp4 ;
10142     bool temp6 = false ;
10143     PyObject * obj0 = 0 ;
10144     PyObject * obj1 = 0 ;
10145     PyObject * obj2 = 0 ;
10146     PyObject * obj3 = 0 ;
10147     PyObject * obj4 = 0 ;
10148     PyObject * obj5 = 0 ;
10149     char *kwnames[] = {
10150         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10151     };
10152
10153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SashLayoutWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10154     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10155     if (SWIG_arg_fail(1)) SWIG_fail;
10156     if (obj1) {
10157         {
10158             arg2 = (int)(SWIG_As_int(obj1));
10159             if (SWIG_arg_fail(2)) SWIG_fail;
10160         }
10161     }
10162     if (obj2) {
10163         {
10164             arg3 = &temp3;
10165             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10166         }
10167     }
10168     if (obj3) {
10169         {
10170             arg4 = &temp4;
10171             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10172         }
10173     }
10174     if (obj4) {
10175         {
10176             arg5 = (long)(SWIG_As_long(obj4));
10177             if (SWIG_arg_fail(5)) SWIG_fail;
10178         }
10179     }
10180     if (obj5) {
10181         {
10182             arg6 = wxString_in_helper(obj5);
10183             if (arg6 == NULL) SWIG_fail;
10184             temp6 = true;
10185         }
10186     }
10187     {
10188         if (!wxPyCheckForApp()) SWIG_fail;
10189         PyThreadState* __tstate = wxPyBeginAllowThreads();
10190         result = (wxSashLayoutWindow *)new wxSashLayoutWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10191
10192         wxPyEndAllowThreads(__tstate);
10193         if (PyErr_Occurred()) SWIG_fail;
10194     }
10195     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashLayoutWindow, 1);
10196     {
10197         if (temp6)
10198         delete arg6;
10199     }
10200     return resultobj;
10201     fail:
10202     {
10203         if (temp6)
10204         delete arg6;
10205     }
10206     return NULL;
10207 }
10208
10209
10210 static PyObject *_wrap_new_PreSashLayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10211     PyObject *resultobj;
10212     wxSashLayoutWindow *result;
10213     char *kwnames[] = {
10214         NULL
10215     };
10216
10217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSashLayoutWindow",kwnames)) goto fail;
10218     {
10219         if (!wxPyCheckForApp()) SWIG_fail;
10220         PyThreadState* __tstate = wxPyBeginAllowThreads();
10221         result = (wxSashLayoutWindow *)new wxSashLayoutWindow();
10222
10223         wxPyEndAllowThreads(__tstate);
10224         if (PyErr_Occurred()) SWIG_fail;
10225     }
10226     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSashLayoutWindow, 1);
10227     return resultobj;
10228     fail:
10229     return NULL;
10230 }
10231
10232
10233 static PyObject *_wrap_SashLayoutWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10234     PyObject *resultobj;
10235     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10236     wxWindow *arg2 = (wxWindow *) 0 ;
10237     int arg3 = (int) -1 ;
10238     wxPoint const &arg4_defvalue = wxDefaultPosition ;
10239     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10240     wxSize const &arg5_defvalue = wxDefaultSize ;
10241     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10242     long arg6 = (long) wxCLIP_CHILDREN|wxSW_3D ;
10243     wxString const &arg7_defvalue = wxPySashLayoutNameStr ;
10244     wxString *arg7 = (wxString *) &arg7_defvalue ;
10245     bool result;
10246     wxPoint temp4 ;
10247     wxSize temp5 ;
10248     bool temp7 = false ;
10249     PyObject * obj0 = 0 ;
10250     PyObject * obj1 = 0 ;
10251     PyObject * obj2 = 0 ;
10252     PyObject * obj3 = 0 ;
10253     PyObject * obj4 = 0 ;
10254     PyObject * obj5 = 0 ;
10255     PyObject * obj6 = 0 ;
10256     char *kwnames[] = {
10257         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10258     };
10259
10260     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SashLayoutWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10261     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10262     if (SWIG_arg_fail(1)) SWIG_fail;
10263     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10264     if (SWIG_arg_fail(2)) SWIG_fail;
10265     if (obj2) {
10266         {
10267             arg3 = (int)(SWIG_As_int(obj2));
10268             if (SWIG_arg_fail(3)) SWIG_fail;
10269         }
10270     }
10271     if (obj3) {
10272         {
10273             arg4 = &temp4;
10274             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10275         }
10276     }
10277     if (obj4) {
10278         {
10279             arg5 = &temp5;
10280             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10281         }
10282     }
10283     if (obj5) {
10284         {
10285             arg6 = (long)(SWIG_As_long(obj5));
10286             if (SWIG_arg_fail(6)) SWIG_fail;
10287         }
10288     }
10289     if (obj6) {
10290         {
10291             arg7 = wxString_in_helper(obj6);
10292             if (arg7 == NULL) SWIG_fail;
10293             temp7 = true;
10294         }
10295     }
10296     {
10297         PyThreadState* __tstate = wxPyBeginAllowThreads();
10298         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10299
10300         wxPyEndAllowThreads(__tstate);
10301         if (PyErr_Occurred()) SWIG_fail;
10302     }
10303     {
10304         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10305     }
10306     {
10307         if (temp7)
10308         delete arg7;
10309     }
10310     return resultobj;
10311     fail:
10312     {
10313         if (temp7)
10314         delete arg7;
10315     }
10316     return NULL;
10317 }
10318
10319
10320 static PyObject *_wrap_SashLayoutWindow_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
10321     PyObject *resultobj;
10322     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10323     wxLayoutAlignment result;
10324     PyObject * obj0 = 0 ;
10325     char *kwnames[] = {
10326         (char *) "self", NULL
10327     };
10328
10329     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashLayoutWindow_GetAlignment",kwnames,&obj0)) goto fail;
10330     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10331     if (SWIG_arg_fail(1)) SWIG_fail;
10332     {
10333         PyThreadState* __tstate = wxPyBeginAllowThreads();
10334         result = (wxLayoutAlignment)(arg1)->GetAlignment();
10335
10336         wxPyEndAllowThreads(__tstate);
10337         if (PyErr_Occurred()) SWIG_fail;
10338     }
10339     resultobj = SWIG_From_int((result));
10340     return resultobj;
10341     fail:
10342     return NULL;
10343 }
10344
10345
10346 static PyObject *_wrap_SashLayoutWindow_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
10347     PyObject *resultobj;
10348     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10349     wxLayoutOrientation result;
10350     PyObject * obj0 = 0 ;
10351     char *kwnames[] = {
10352         (char *) "self", NULL
10353     };
10354
10355     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SashLayoutWindow_GetOrientation",kwnames,&obj0)) goto fail;
10356     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10357     if (SWIG_arg_fail(1)) SWIG_fail;
10358     {
10359         PyThreadState* __tstate = wxPyBeginAllowThreads();
10360         result = (wxLayoutOrientation)(arg1)->GetOrientation();
10361
10362         wxPyEndAllowThreads(__tstate);
10363         if (PyErr_Occurred()) SWIG_fail;
10364     }
10365     resultobj = SWIG_From_int((result));
10366     return resultobj;
10367     fail:
10368     return NULL;
10369 }
10370
10371
10372 static PyObject *_wrap_SashLayoutWindow_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
10373     PyObject *resultobj;
10374     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10375     wxLayoutAlignment arg2 ;
10376     PyObject * obj0 = 0 ;
10377     PyObject * obj1 = 0 ;
10378     char *kwnames[] = {
10379         (char *) "self",(char *) "alignment", NULL
10380     };
10381
10382     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetAlignment",kwnames,&obj0,&obj1)) goto fail;
10383     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10384     if (SWIG_arg_fail(1)) SWIG_fail;
10385     {
10386         arg2 = (wxLayoutAlignment)(SWIG_As_int(obj1));
10387         if (SWIG_arg_fail(2)) SWIG_fail;
10388     }
10389     {
10390         PyThreadState* __tstate = wxPyBeginAllowThreads();
10391         (arg1)->SetAlignment((wxLayoutAlignment )arg2);
10392
10393         wxPyEndAllowThreads(__tstate);
10394         if (PyErr_Occurred()) SWIG_fail;
10395     }
10396     Py_INCREF(Py_None); resultobj = Py_None;
10397     return resultobj;
10398     fail:
10399     return NULL;
10400 }
10401
10402
10403 static PyObject *_wrap_SashLayoutWindow_SetDefaultSize(PyObject *, PyObject *args, PyObject *kwargs) {
10404     PyObject *resultobj;
10405     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10406     wxSize *arg2 = 0 ;
10407     wxSize temp2 ;
10408     PyObject * obj0 = 0 ;
10409     PyObject * obj1 = 0 ;
10410     char *kwnames[] = {
10411         (char *) "self",(char *) "size", NULL
10412     };
10413
10414     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetDefaultSize",kwnames,&obj0,&obj1)) goto fail;
10415     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10416     if (SWIG_arg_fail(1)) SWIG_fail;
10417     {
10418         arg2 = &temp2;
10419         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10420     }
10421     {
10422         PyThreadState* __tstate = wxPyBeginAllowThreads();
10423         (arg1)->SetDefaultSize((wxSize const &)*arg2);
10424
10425         wxPyEndAllowThreads(__tstate);
10426         if (PyErr_Occurred()) SWIG_fail;
10427     }
10428     Py_INCREF(Py_None); resultobj = Py_None;
10429     return resultobj;
10430     fail:
10431     return NULL;
10432 }
10433
10434
10435 static PyObject *_wrap_SashLayoutWindow_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
10436     PyObject *resultobj;
10437     wxSashLayoutWindow *arg1 = (wxSashLayoutWindow *) 0 ;
10438     wxLayoutOrientation arg2 ;
10439     PyObject * obj0 = 0 ;
10440     PyObject * obj1 = 0 ;
10441     char *kwnames[] = {
10442         (char *) "self",(char *) "orientation", NULL
10443     };
10444
10445     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SashLayoutWindow_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
10446     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSashLayoutWindow, SWIG_POINTER_EXCEPTION | 0);
10447     if (SWIG_arg_fail(1)) SWIG_fail;
10448     {
10449         arg2 = (wxLayoutOrientation)(SWIG_As_int(obj1));
10450         if (SWIG_arg_fail(2)) SWIG_fail;
10451     }
10452     {
10453         PyThreadState* __tstate = wxPyBeginAllowThreads();
10454         (arg1)->SetOrientation((wxLayoutOrientation )arg2);
10455
10456         wxPyEndAllowThreads(__tstate);
10457         if (PyErr_Occurred()) SWIG_fail;
10458     }
10459     Py_INCREF(Py_None); resultobj = Py_None;
10460     return resultobj;
10461     fail:
10462     return NULL;
10463 }
10464
10465
10466 static PyObject * SashLayoutWindow_swigregister(PyObject *, PyObject *args) {
10467     PyObject *obj;
10468     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10469     SWIG_TypeClientData(SWIGTYPE_p_wxSashLayoutWindow, obj);
10470     Py_INCREF(obj);
10471     return Py_BuildValue((char *)"");
10472 }
10473 static PyObject *_wrap_new_LayoutAlgorithm(PyObject *, PyObject *args, PyObject *kwargs) {
10474     PyObject *resultobj;
10475     wxLayoutAlgorithm *result;
10476     char *kwnames[] = {
10477         NULL
10478     };
10479
10480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutAlgorithm",kwnames)) goto fail;
10481     {
10482         PyThreadState* __tstate = wxPyBeginAllowThreads();
10483         result = (wxLayoutAlgorithm *)new wxLayoutAlgorithm();
10484
10485         wxPyEndAllowThreads(__tstate);
10486         if (PyErr_Occurred()) SWIG_fail;
10487     }
10488     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutAlgorithm, 1);
10489     return resultobj;
10490     fail:
10491     return NULL;
10492 }
10493
10494
10495 static PyObject *_wrap_delete_LayoutAlgorithm(PyObject *, PyObject *args, PyObject *kwargs) {
10496     PyObject *resultobj;
10497     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10498     PyObject * obj0 = 0 ;
10499     char *kwnames[] = {
10500         (char *) "self", NULL
10501     };
10502
10503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LayoutAlgorithm",kwnames,&obj0)) goto fail;
10504     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10505     if (SWIG_arg_fail(1)) SWIG_fail;
10506     {
10507         PyThreadState* __tstate = wxPyBeginAllowThreads();
10508         delete arg1;
10509
10510         wxPyEndAllowThreads(__tstate);
10511         if (PyErr_Occurred()) SWIG_fail;
10512     }
10513     Py_INCREF(Py_None); resultobj = Py_None;
10514     return resultobj;
10515     fail:
10516     return NULL;
10517 }
10518
10519
10520 static PyObject *_wrap_LayoutAlgorithm_LayoutMDIFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10521     PyObject *resultobj;
10522     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10523     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
10524     wxRect *arg3 = (wxRect *) NULL ;
10525     bool result;
10526     PyObject * obj0 = 0 ;
10527     PyObject * obj1 = 0 ;
10528     PyObject * obj2 = 0 ;
10529     char *kwnames[] = {
10530         (char *) "self",(char *) "frame",(char *) "rect", NULL
10531     };
10532
10533     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutMDIFrame",kwnames,&obj0,&obj1,&obj2)) goto fail;
10534     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10535     if (SWIG_arg_fail(1)) SWIG_fail;
10536     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
10537     if (SWIG_arg_fail(2)) SWIG_fail;
10538     if (obj2) {
10539         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
10540         if (SWIG_arg_fail(3)) SWIG_fail;
10541     }
10542     {
10543         PyThreadState* __tstate = wxPyBeginAllowThreads();
10544         result = (bool)(arg1)->LayoutMDIFrame(arg2,arg3);
10545
10546         wxPyEndAllowThreads(__tstate);
10547         if (PyErr_Occurred()) SWIG_fail;
10548     }
10549     {
10550         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10551     }
10552     return resultobj;
10553     fail:
10554     return NULL;
10555 }
10556
10557
10558 static PyObject *_wrap_LayoutAlgorithm_LayoutFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10559     PyObject *resultobj;
10560     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10561     wxFrame *arg2 = (wxFrame *) 0 ;
10562     wxWindow *arg3 = (wxWindow *) NULL ;
10563     bool result;
10564     PyObject * obj0 = 0 ;
10565     PyObject * obj1 = 0 ;
10566     PyObject * obj2 = 0 ;
10567     char *kwnames[] = {
10568         (char *) "self",(char *) "frame",(char *) "mainWindow", NULL
10569     };
10570
10571     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutFrame",kwnames,&obj0,&obj1,&obj2)) goto fail;
10572     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10573     if (SWIG_arg_fail(1)) SWIG_fail;
10574     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10575     if (SWIG_arg_fail(2)) SWIG_fail;
10576     if (obj2) {
10577         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10578         if (SWIG_arg_fail(3)) SWIG_fail;
10579     }
10580     {
10581         PyThreadState* __tstate = wxPyBeginAllowThreads();
10582         result = (bool)(arg1)->LayoutFrame(arg2,arg3);
10583
10584         wxPyEndAllowThreads(__tstate);
10585         if (PyErr_Occurred()) SWIG_fail;
10586     }
10587     {
10588         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10589     }
10590     return resultobj;
10591     fail:
10592     return NULL;
10593 }
10594
10595
10596 static PyObject *_wrap_LayoutAlgorithm_LayoutWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10597     PyObject *resultobj;
10598     wxLayoutAlgorithm *arg1 = (wxLayoutAlgorithm *) 0 ;
10599     wxWindow *arg2 = (wxWindow *) 0 ;
10600     wxWindow *arg3 = (wxWindow *) NULL ;
10601     bool result;
10602     PyObject * obj0 = 0 ;
10603     PyObject * obj1 = 0 ;
10604     PyObject * obj2 = 0 ;
10605     char *kwnames[] = {
10606         (char *) "self",(char *) "parent",(char *) "mainWindow", NULL
10607     };
10608
10609     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:LayoutAlgorithm_LayoutWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
10610     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutAlgorithm, SWIG_POINTER_EXCEPTION | 0);
10611     if (SWIG_arg_fail(1)) SWIG_fail;
10612     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10613     if (SWIG_arg_fail(2)) SWIG_fail;
10614     if (obj2) {
10615         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10616         if (SWIG_arg_fail(3)) SWIG_fail;
10617     }
10618     {
10619         PyThreadState* __tstate = wxPyBeginAllowThreads();
10620         result = (bool)(arg1)->LayoutWindow(arg2,arg3);
10621
10622         wxPyEndAllowThreads(__tstate);
10623         if (PyErr_Occurred()) SWIG_fail;
10624     }
10625     {
10626         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10627     }
10628     return resultobj;
10629     fail:
10630     return NULL;
10631 }
10632
10633
10634 static PyObject * LayoutAlgorithm_swigregister(PyObject *, PyObject *args) {
10635     PyObject *obj;
10636     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10637     SWIG_TypeClientData(SWIGTYPE_p_wxLayoutAlgorithm, obj);
10638     Py_INCREF(obj);
10639     return Py_BuildValue((char *)"");
10640 }
10641 static PyObject *_wrap_new_PopupWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10642     PyObject *resultobj;
10643     wxWindow *arg1 = (wxWindow *) 0 ;
10644     int arg2 = (int) wxBORDER_NONE ;
10645     wxPopupWindow *result;
10646     PyObject * obj0 = 0 ;
10647     PyObject * obj1 = 0 ;
10648     char *kwnames[] = {
10649         (char *) "parent",(char *) "flags", NULL
10650     };
10651
10652     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PopupWindow",kwnames,&obj0,&obj1)) goto fail;
10653     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10654     if (SWIG_arg_fail(1)) SWIG_fail;
10655     if (obj1) {
10656         {
10657             arg2 = (int)(SWIG_As_int(obj1));
10658             if (SWIG_arg_fail(2)) SWIG_fail;
10659         }
10660     }
10661     {
10662         PyThreadState* __tstate = wxPyBeginAllowThreads();
10663         result = (wxPopupWindow *)new wxPopupWindow(arg1,arg2);
10664
10665         wxPyEndAllowThreads(__tstate);
10666         if (PyErr_Occurred()) SWIG_fail;
10667     }
10668     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPopupWindow, 1);
10669     return resultobj;
10670     fail:
10671     return NULL;
10672 }
10673
10674
10675 static PyObject *_wrap_new_PrePopupWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10676     PyObject *resultobj;
10677     wxPopupWindow *result;
10678     char *kwnames[] = {
10679         NULL
10680     };
10681
10682     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePopupWindow",kwnames)) goto fail;
10683     {
10684         PyThreadState* __tstate = wxPyBeginAllowThreads();
10685         result = (wxPopupWindow *)new wxPopupWindow();
10686
10687         wxPyEndAllowThreads(__tstate);
10688         if (PyErr_Occurred()) SWIG_fail;
10689     }
10690     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPopupWindow, 1);
10691     return resultobj;
10692     fail:
10693     return NULL;
10694 }
10695
10696
10697 static PyObject * PopupWindow_swigregister(PyObject *, PyObject *args) {
10698     PyObject *obj;
10699     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10700     SWIG_TypeClientData(SWIGTYPE_p_wxPopupWindow, obj);
10701     Py_INCREF(obj);
10702     return Py_BuildValue((char *)"");
10703 }
10704 static PyObject *_wrap_new_PopupTransientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10705     PyObject *resultobj;
10706     wxWindow *arg1 = (wxWindow *) 0 ;
10707     int arg2 = (int) wxBORDER_NONE ;
10708     wxPyPopupTransientWindow *result;
10709     PyObject * obj0 = 0 ;
10710     PyObject * obj1 = 0 ;
10711     char *kwnames[] = {
10712         (char *) "parent",(char *) "style", NULL
10713     };
10714
10715     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PopupTransientWindow",kwnames,&obj0,&obj1)) goto fail;
10716     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10717     if (SWIG_arg_fail(1)) SWIG_fail;
10718     if (obj1) {
10719         {
10720             arg2 = (int)(SWIG_As_int(obj1));
10721             if (SWIG_arg_fail(2)) SWIG_fail;
10722         }
10723     }
10724     {
10725         PyThreadState* __tstate = wxPyBeginAllowThreads();
10726         result = (wxPyPopupTransientWindow *)new wxPyPopupTransientWindow(arg1,arg2);
10727
10728         wxPyEndAllowThreads(__tstate);
10729         if (PyErr_Occurred()) SWIG_fail;
10730     }
10731     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPopupTransientWindow, 1);
10732     return resultobj;
10733     fail:
10734     return NULL;
10735 }
10736
10737
10738 static PyObject *_wrap_new_PrePopupTransientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10739     PyObject *resultobj;
10740     wxPyPopupTransientWindow *result;
10741     char *kwnames[] = {
10742         NULL
10743     };
10744
10745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePopupTransientWindow",kwnames)) goto fail;
10746     {
10747         PyThreadState* __tstate = wxPyBeginAllowThreads();
10748         result = (wxPyPopupTransientWindow *)new wxPyPopupTransientWindow();
10749
10750         wxPyEndAllowThreads(__tstate);
10751         if (PyErr_Occurred()) SWIG_fail;
10752     }
10753     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPopupTransientWindow, 1);
10754     return resultobj;
10755     fail:
10756     return NULL;
10757 }
10758
10759
10760 static PyObject * PopupTransientWindow_swigregister(PyObject *, PyObject *args) {
10761     PyObject *obj;
10762     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10763     SWIG_TypeClientData(SWIGTYPE_p_wxPyPopupTransientWindow, obj);
10764     Py_INCREF(obj);
10765     return Py_BuildValue((char *)"");
10766 }
10767 static PyObject *_wrap_new_TipWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10768     PyObject *resultobj;
10769     wxWindow *arg1 = (wxWindow *) 0 ;
10770     wxString *arg2 = 0 ;
10771     int arg3 = (int) 100 ;
10772     wxRect *arg4 = (wxRect *) NULL ;
10773     wxTipWindow *result;
10774     bool temp2 = false ;
10775     PyObject * obj0 = 0 ;
10776     PyObject * obj1 = 0 ;
10777     PyObject * obj2 = 0 ;
10778     PyObject * obj3 = 0 ;
10779     char *kwnames[] = {
10780         (char *) "parent",(char *) "text",(char *) "maxLength",(char *) "rectBound", NULL
10781     };
10782
10783     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_TipWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10784     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10785     if (SWIG_arg_fail(1)) SWIG_fail;
10786     {
10787         arg2 = wxString_in_helper(obj1);
10788         if (arg2 == NULL) SWIG_fail;
10789         temp2 = true;
10790     }
10791     if (obj2) {
10792         {
10793             arg3 = (int)(SWIG_As_int(obj2));
10794             if (SWIG_arg_fail(3)) SWIG_fail;
10795         }
10796     }
10797     if (obj3) {
10798         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
10799         if (SWIG_arg_fail(4)) SWIG_fail;
10800     }
10801     {
10802         if (!wxPyCheckForApp()) SWIG_fail;
10803         PyThreadState* __tstate = wxPyBeginAllowThreads();
10804         result = (wxTipWindow *)new_wxTipWindow(arg1,(wxString const &)*arg2,arg3,arg4);
10805
10806         wxPyEndAllowThreads(__tstate);
10807         if (PyErr_Occurred()) SWIG_fail;
10808     }
10809     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipWindow, 1);
10810     {
10811         if (temp2)
10812         delete arg2;
10813     }
10814     return resultobj;
10815     fail:
10816     {
10817         if (temp2)
10818         delete arg2;
10819     }
10820     return NULL;
10821 }
10822
10823
10824 static PyObject *_wrap_TipWindow_SetBoundingRect(PyObject *, PyObject *args, PyObject *kwargs) {
10825     PyObject *resultobj;
10826     wxTipWindow *arg1 = (wxTipWindow *) 0 ;
10827     wxRect *arg2 = 0 ;
10828     wxRect temp2 ;
10829     PyObject * obj0 = 0 ;
10830     PyObject * obj1 = 0 ;
10831     char *kwnames[] = {
10832         (char *) "self",(char *) "rectBound", NULL
10833     };
10834
10835     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipWindow_SetBoundingRect",kwnames,&obj0,&obj1)) goto fail;
10836     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipWindow, SWIG_POINTER_EXCEPTION | 0);
10837     if (SWIG_arg_fail(1)) SWIG_fail;
10838     {
10839         arg2 = &temp2;
10840         if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10841     }
10842     {
10843         PyThreadState* __tstate = wxPyBeginAllowThreads();
10844         (arg1)->SetBoundingRect((wxRect const &)*arg2);
10845
10846         wxPyEndAllowThreads(__tstate);
10847         if (PyErr_Occurred()) SWIG_fail;
10848     }
10849     Py_INCREF(Py_None); resultobj = Py_None;
10850     return resultobj;
10851     fail:
10852     return NULL;
10853 }
10854
10855
10856 static PyObject *_wrap_TipWindow_Close(PyObject *, PyObject *args, PyObject *kwargs) {
10857     PyObject *resultobj;
10858     wxTipWindow *arg1 = (wxTipWindow *) 0 ;
10859     PyObject * obj0 = 0 ;
10860     char *kwnames[] = {
10861         (char *) "self", NULL
10862     };
10863
10864     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipWindow_Close",kwnames,&obj0)) goto fail;
10865     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipWindow, SWIG_POINTER_EXCEPTION | 0);
10866     if (SWIG_arg_fail(1)) SWIG_fail;
10867     {
10868         PyThreadState* __tstate = wxPyBeginAllowThreads();
10869         (arg1)->Close();
10870
10871         wxPyEndAllowThreads(__tstate);
10872         if (PyErr_Occurred()) SWIG_fail;
10873     }
10874     Py_INCREF(Py_None); resultobj = Py_None;
10875     return resultobj;
10876     fail:
10877     return NULL;
10878 }
10879
10880
10881 static PyObject * TipWindow_swigregister(PyObject *, PyObject *args) {
10882     PyObject *obj;
10883     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10884     SWIG_TypeClientData(SWIGTYPE_p_wxTipWindow, obj);
10885     Py_INCREF(obj);
10886     return Py_BuildValue((char *)"");
10887 }
10888 static PyObject *_wrap_new_VScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10889     PyObject *resultobj;
10890     wxWindow *arg1 = (wxWindow *) 0 ;
10891     int arg2 = (int) wxID_ANY ;
10892     wxPoint const &arg3_defvalue = wxDefaultPosition ;
10893     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10894     wxSize const &arg4_defvalue = wxDefaultSize ;
10895     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10896     long arg5 = (long) 0 ;
10897     wxString const &arg6_defvalue = wxPyPanelNameStr ;
10898     wxString *arg6 = (wxString *) &arg6_defvalue ;
10899     wxPyVScrolledWindow *result;
10900     wxPoint temp3 ;
10901     wxSize temp4 ;
10902     bool temp6 = false ;
10903     PyObject * obj0 = 0 ;
10904     PyObject * obj1 = 0 ;
10905     PyObject * obj2 = 0 ;
10906     PyObject * obj3 = 0 ;
10907     PyObject * obj4 = 0 ;
10908     PyObject * obj5 = 0 ;
10909     char *kwnames[] = {
10910         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10911     };
10912
10913     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_VScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10914     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
10915     if (SWIG_arg_fail(1)) SWIG_fail;
10916     if (obj1) {
10917         {
10918             arg2 = (int)(SWIG_As_int(obj1));
10919             if (SWIG_arg_fail(2)) SWIG_fail;
10920         }
10921     }
10922     if (obj2) {
10923         {
10924             arg3 = &temp3;
10925             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10926         }
10927     }
10928     if (obj3) {
10929         {
10930             arg4 = &temp4;
10931             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10932         }
10933     }
10934     if (obj4) {
10935         {
10936             arg5 = (long)(SWIG_As_long(obj4));
10937             if (SWIG_arg_fail(5)) SWIG_fail;
10938         }
10939     }
10940     if (obj5) {
10941         {
10942             arg6 = wxString_in_helper(obj5);
10943             if (arg6 == NULL) SWIG_fail;
10944             temp6 = true;
10945         }
10946     }
10947     {
10948         if (!wxPyCheckForApp()) SWIG_fail;
10949         PyThreadState* __tstate = wxPyBeginAllowThreads();
10950         result = (wxPyVScrolledWindow *)new wxPyVScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10951
10952         wxPyEndAllowThreads(__tstate);
10953         if (PyErr_Occurred()) SWIG_fail;
10954     }
10955     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVScrolledWindow, 1);
10956     {
10957         if (temp6)
10958         delete arg6;
10959     }
10960     return resultobj;
10961     fail:
10962     {
10963         if (temp6)
10964         delete arg6;
10965     }
10966     return NULL;
10967 }
10968
10969
10970 static PyObject *_wrap_new_PreVScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10971     PyObject *resultobj;
10972     wxPyVScrolledWindow *result;
10973     char *kwnames[] = {
10974         NULL
10975     };
10976
10977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreVScrolledWindow",kwnames)) goto fail;
10978     {
10979         if (!wxPyCheckForApp()) SWIG_fail;
10980         PyThreadState* __tstate = wxPyBeginAllowThreads();
10981         result = (wxPyVScrolledWindow *)new wxPyVScrolledWindow();
10982
10983         wxPyEndAllowThreads(__tstate);
10984         if (PyErr_Occurred()) SWIG_fail;
10985     }
10986     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVScrolledWindow, 1);
10987     return resultobj;
10988     fail:
10989     return NULL;
10990 }
10991
10992
10993 static PyObject *_wrap_VScrolledWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10994     PyObject *resultobj;
10995     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
10996     PyObject *arg2 = (PyObject *) 0 ;
10997     PyObject *arg3 = (PyObject *) 0 ;
10998     PyObject * obj0 = 0 ;
10999     PyObject * obj1 = 0 ;
11000     PyObject * obj2 = 0 ;
11001     char *kwnames[] = {
11002         (char *) "self",(char *) "self",(char *) "_class", NULL
11003     };
11004
11005     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11006     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11007     if (SWIG_arg_fail(1)) SWIG_fail;
11008     arg2 = obj1;
11009     arg3 = obj2;
11010     {
11011         PyThreadState* __tstate = wxPyBeginAllowThreads();
11012         (arg1)->_setCallbackInfo(arg2,arg3);
11013
11014         wxPyEndAllowThreads(__tstate);
11015         if (PyErr_Occurred()) SWIG_fail;
11016     }
11017     Py_INCREF(Py_None); resultobj = Py_None;
11018     return resultobj;
11019     fail:
11020     return NULL;
11021 }
11022
11023
11024 static PyObject *_wrap_VScrolledWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11025     PyObject *resultobj;
11026     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11027     wxWindow *arg2 = (wxWindow *) 0 ;
11028     int arg3 = (int) wxID_ANY ;
11029     wxPoint const &arg4_defvalue = wxDefaultPosition ;
11030     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
11031     wxSize const &arg5_defvalue = wxDefaultSize ;
11032     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
11033     long arg6 = (long) 0 ;
11034     wxString const &arg7_defvalue = wxPyPanelNameStr ;
11035     wxString *arg7 = (wxString *) &arg7_defvalue ;
11036     bool result;
11037     wxPoint temp4 ;
11038     wxSize temp5 ;
11039     bool temp7 = false ;
11040     PyObject * obj0 = 0 ;
11041     PyObject * obj1 = 0 ;
11042     PyObject * obj2 = 0 ;
11043     PyObject * obj3 = 0 ;
11044     PyObject * obj4 = 0 ;
11045     PyObject * obj5 = 0 ;
11046     PyObject * obj6 = 0 ;
11047     char *kwnames[] = {
11048         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11049     };
11050
11051     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:VScrolledWindow_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
11052     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11053     if (SWIG_arg_fail(1)) SWIG_fail;
11054     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11055     if (SWIG_arg_fail(2)) SWIG_fail;
11056     if (obj2) {
11057         {
11058             arg3 = (int)(SWIG_As_int(obj2));
11059             if (SWIG_arg_fail(3)) SWIG_fail;
11060         }
11061     }
11062     if (obj3) {
11063         {
11064             arg4 = &temp4;
11065             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
11066         }
11067     }
11068     if (obj4) {
11069         {
11070             arg5 = &temp5;
11071             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
11072         }
11073     }
11074     if (obj5) {
11075         {
11076             arg6 = (long)(SWIG_As_long(obj5));
11077             if (SWIG_arg_fail(6)) SWIG_fail;
11078         }
11079     }
11080     if (obj6) {
11081         {
11082             arg7 = wxString_in_helper(obj6);
11083             if (arg7 == NULL) SWIG_fail;
11084             temp7 = true;
11085         }
11086     }
11087     {
11088         PyThreadState* __tstate = wxPyBeginAllowThreads();
11089         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
11090
11091         wxPyEndAllowThreads(__tstate);
11092         if (PyErr_Occurred()) SWIG_fail;
11093     }
11094     {
11095         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11096     }
11097     {
11098         if (temp7)
11099         delete arg7;
11100     }
11101     return resultobj;
11102     fail:
11103     {
11104         if (temp7)
11105         delete arg7;
11106     }
11107     return NULL;
11108 }
11109
11110
11111 static PyObject *_wrap_VScrolledWindow_SetLineCount(PyObject *, PyObject *args, PyObject *kwargs) {
11112     PyObject *resultobj;
11113     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11114     size_t arg2 ;
11115     PyObject * obj0 = 0 ;
11116     PyObject * obj1 = 0 ;
11117     char *kwnames[] = {
11118         (char *) "self",(char *) "count", NULL
11119     };
11120
11121     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_SetLineCount",kwnames,&obj0,&obj1)) goto fail;
11122     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11123     if (SWIG_arg_fail(1)) SWIG_fail;
11124     {
11125         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11126         if (SWIG_arg_fail(2)) SWIG_fail;
11127     }
11128     {
11129         PyThreadState* __tstate = wxPyBeginAllowThreads();
11130         (arg1)->SetLineCount(arg2);
11131
11132         wxPyEndAllowThreads(__tstate);
11133         if (PyErr_Occurred()) SWIG_fail;
11134     }
11135     Py_INCREF(Py_None); resultobj = Py_None;
11136     return resultobj;
11137     fail:
11138     return NULL;
11139 }
11140
11141
11142 static PyObject *_wrap_VScrolledWindow_ScrollToLine(PyObject *, PyObject *args, PyObject *kwargs) {
11143     PyObject *resultobj;
11144     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11145     size_t arg2 ;
11146     bool result;
11147     PyObject * obj0 = 0 ;
11148     PyObject * obj1 = 0 ;
11149     char *kwnames[] = {
11150         (char *) "self",(char *) "line", NULL
11151     };
11152
11153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollToLine",kwnames,&obj0,&obj1)) goto fail;
11154     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11155     if (SWIG_arg_fail(1)) SWIG_fail;
11156     {
11157         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11158         if (SWIG_arg_fail(2)) SWIG_fail;
11159     }
11160     {
11161         PyThreadState* __tstate = wxPyBeginAllowThreads();
11162         result = (bool)(arg1)->ScrollToLine(arg2);
11163
11164         wxPyEndAllowThreads(__tstate);
11165         if (PyErr_Occurred()) SWIG_fail;
11166     }
11167     {
11168         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11169     }
11170     return resultobj;
11171     fail:
11172     return NULL;
11173 }
11174
11175
11176 static PyObject *_wrap_VScrolledWindow_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
11177     PyObject *resultobj;
11178     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11179     int arg2 ;
11180     bool result;
11181     PyObject * obj0 = 0 ;
11182     PyObject * obj1 = 0 ;
11183     char *kwnames[] = {
11184         (char *) "self",(char *) "lines", NULL
11185     };
11186
11187     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
11188     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11189     if (SWIG_arg_fail(1)) SWIG_fail;
11190     {
11191         arg2 = (int)(SWIG_As_int(obj1));
11192         if (SWIG_arg_fail(2)) SWIG_fail;
11193     }
11194     {
11195         PyThreadState* __tstate = wxPyBeginAllowThreads();
11196         result = (bool)(arg1)->ScrollLines(arg2);
11197
11198         wxPyEndAllowThreads(__tstate);
11199         if (PyErr_Occurred()) SWIG_fail;
11200     }
11201     {
11202         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11203     }
11204     return resultobj;
11205     fail:
11206     return NULL;
11207 }
11208
11209
11210 static PyObject *_wrap_VScrolledWindow_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
11211     PyObject *resultobj;
11212     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11213     int arg2 ;
11214     bool result;
11215     PyObject * obj0 = 0 ;
11216     PyObject * obj1 = 0 ;
11217     char *kwnames[] = {
11218         (char *) "self",(char *) "pages", NULL
11219     };
11220
11221     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
11222     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11223     if (SWIG_arg_fail(1)) SWIG_fail;
11224     {
11225         arg2 = (int)(SWIG_As_int(obj1));
11226         if (SWIG_arg_fail(2)) SWIG_fail;
11227     }
11228     {
11229         PyThreadState* __tstate = wxPyBeginAllowThreads();
11230         result = (bool)(arg1)->ScrollPages(arg2);
11231
11232         wxPyEndAllowThreads(__tstate);
11233         if (PyErr_Occurred()) SWIG_fail;
11234     }
11235     {
11236         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11237     }
11238     return resultobj;
11239     fail:
11240     return NULL;
11241 }
11242
11243
11244 static PyObject *_wrap_VScrolledWindow_RefreshLine(PyObject *, PyObject *args, PyObject *kwargs) {
11245     PyObject *resultobj;
11246     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11247     size_t arg2 ;
11248     PyObject * obj0 = 0 ;
11249     PyObject * obj1 = 0 ;
11250     char *kwnames[] = {
11251         (char *) "self",(char *) "line", NULL
11252     };
11253
11254     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_RefreshLine",kwnames,&obj0,&obj1)) goto fail;
11255     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11256     if (SWIG_arg_fail(1)) SWIG_fail;
11257     {
11258         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11259         if (SWIG_arg_fail(2)) SWIG_fail;
11260     }
11261     {
11262         PyThreadState* __tstate = wxPyBeginAllowThreads();
11263         (arg1)->RefreshLine(arg2);
11264
11265         wxPyEndAllowThreads(__tstate);
11266         if (PyErr_Occurred()) SWIG_fail;
11267     }
11268     Py_INCREF(Py_None); resultobj = Py_None;
11269     return resultobj;
11270     fail:
11271     return NULL;
11272 }
11273
11274
11275 static PyObject *_wrap_VScrolledWindow_RefreshLines(PyObject *, PyObject *args, PyObject *kwargs) {
11276     PyObject *resultobj;
11277     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11278     size_t arg2 ;
11279     size_t arg3 ;
11280     PyObject * obj0 = 0 ;
11281     PyObject * obj1 = 0 ;
11282     PyObject * obj2 = 0 ;
11283     char *kwnames[] = {
11284         (char *) "self",(char *) "from",(char *) "to", NULL
11285     };
11286
11287     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow_RefreshLines",kwnames,&obj0,&obj1,&obj2)) goto fail;
11288     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11289     if (SWIG_arg_fail(1)) SWIG_fail;
11290     {
11291         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11292         if (SWIG_arg_fail(2)) SWIG_fail;
11293     }
11294     {
11295         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11296         if (SWIG_arg_fail(3)) SWIG_fail;
11297     }
11298     {
11299         PyThreadState* __tstate = wxPyBeginAllowThreads();
11300         (arg1)->RefreshLines(arg2,arg3);
11301
11302         wxPyEndAllowThreads(__tstate);
11303         if (PyErr_Occurred()) SWIG_fail;
11304     }
11305     Py_INCREF(Py_None); resultobj = Py_None;
11306     return resultobj;
11307     fail:
11308     return NULL;
11309 }
11310
11311
11312 static PyObject *_wrap_VScrolledWindow_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
11313     PyObject *resultobj;
11314     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11315     int arg2 ;
11316     int arg3 ;
11317     int result;
11318     PyObject * obj0 = 0 ;
11319     PyObject * obj1 = 0 ;
11320     PyObject * obj2 = 0 ;
11321     char *kwnames[] = {
11322         (char *) "self",(char *) "x",(char *) "y", NULL
11323     };
11324
11325     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VScrolledWindow_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
11326     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11327     if (SWIG_arg_fail(1)) SWIG_fail;
11328     {
11329         arg2 = (int)(SWIG_As_int(obj1));
11330         if (SWIG_arg_fail(2)) SWIG_fail;
11331     }
11332     {
11333         arg3 = (int)(SWIG_As_int(obj2));
11334         if (SWIG_arg_fail(3)) SWIG_fail;
11335     }
11336     {
11337         PyThreadState* __tstate = wxPyBeginAllowThreads();
11338         result = (int)((wxPyVScrolledWindow const *)arg1)->HitTest(arg2,arg3);
11339
11340         wxPyEndAllowThreads(__tstate);
11341         if (PyErr_Occurred()) SWIG_fail;
11342     }
11343     {
11344         resultobj = SWIG_From_int((int)(result));
11345     }
11346     return resultobj;
11347     fail:
11348     return NULL;
11349 }
11350
11351
11352 static PyObject *_wrap_VScrolledWindow_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
11353     PyObject *resultobj;
11354     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11355     wxPoint *arg2 = 0 ;
11356     int result;
11357     wxPoint temp2 ;
11358     PyObject * obj0 = 0 ;
11359     PyObject * obj1 = 0 ;
11360     char *kwnames[] = {
11361         (char *) "self",(char *) "pt", NULL
11362     };
11363
11364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_HitTest",kwnames,&obj0,&obj1)) goto fail;
11365     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11366     if (SWIG_arg_fail(1)) SWIG_fail;
11367     {
11368         arg2 = &temp2;
11369         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
11370     }
11371     {
11372         PyThreadState* __tstate = wxPyBeginAllowThreads();
11373         result = (int)((wxPyVScrolledWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
11374
11375         wxPyEndAllowThreads(__tstate);
11376         if (PyErr_Occurred()) SWIG_fail;
11377     }
11378     {
11379         resultobj = SWIG_From_int((int)(result));
11380     }
11381     return resultobj;
11382     fail:
11383     return NULL;
11384 }
11385
11386
11387 static PyObject *_wrap_VScrolledWindow_RefreshAll(PyObject *, PyObject *args, PyObject *kwargs) {
11388     PyObject *resultobj;
11389     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11390     PyObject * obj0 = 0 ;
11391     char *kwnames[] = {
11392         (char *) "self", NULL
11393     };
11394
11395     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_RefreshAll",kwnames,&obj0)) goto fail;
11396     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11397     if (SWIG_arg_fail(1)) SWIG_fail;
11398     {
11399         PyThreadState* __tstate = wxPyBeginAllowThreads();
11400         (arg1)->RefreshAll();
11401
11402         wxPyEndAllowThreads(__tstate);
11403         if (PyErr_Occurred()) SWIG_fail;
11404     }
11405     Py_INCREF(Py_None); resultobj = Py_None;
11406     return resultobj;
11407     fail:
11408     return NULL;
11409 }
11410
11411
11412 static PyObject *_wrap_VScrolledWindow_GetLineCount(PyObject *, PyObject *args, PyObject *kwargs) {
11413     PyObject *resultobj;
11414     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11415     size_t result;
11416     PyObject * obj0 = 0 ;
11417     char *kwnames[] = {
11418         (char *) "self", NULL
11419     };
11420
11421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetLineCount",kwnames,&obj0)) goto fail;
11422     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11423     if (SWIG_arg_fail(1)) SWIG_fail;
11424     {
11425         PyThreadState* __tstate = wxPyBeginAllowThreads();
11426         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetLineCount();
11427
11428         wxPyEndAllowThreads(__tstate);
11429         if (PyErr_Occurred()) SWIG_fail;
11430     }
11431     {
11432         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11433     }
11434     return resultobj;
11435     fail:
11436     return NULL;
11437 }
11438
11439
11440 static PyObject *_wrap_VScrolledWindow_GetVisibleBegin(PyObject *, PyObject *args, PyObject *kwargs) {
11441     PyObject *resultobj;
11442     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11443     size_t result;
11444     PyObject * obj0 = 0 ;
11445     char *kwnames[] = {
11446         (char *) "self", NULL
11447     };
11448
11449     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetVisibleBegin",kwnames,&obj0)) goto fail;
11450     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11451     if (SWIG_arg_fail(1)) SWIG_fail;
11452     {
11453         PyThreadState* __tstate = wxPyBeginAllowThreads();
11454         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetVisibleBegin();
11455
11456         wxPyEndAllowThreads(__tstate);
11457         if (PyErr_Occurred()) SWIG_fail;
11458     }
11459     {
11460         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11461     }
11462     return resultobj;
11463     fail:
11464     return NULL;
11465 }
11466
11467
11468 static PyObject *_wrap_VScrolledWindow_GetVisibleEnd(PyObject *, PyObject *args, PyObject *kwargs) {
11469     PyObject *resultobj;
11470     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11471     size_t result;
11472     PyObject * obj0 = 0 ;
11473     char *kwnames[] = {
11474         (char *) "self", NULL
11475     };
11476
11477     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetVisibleEnd",kwnames,&obj0)) goto fail;
11478     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11479     if (SWIG_arg_fail(1)) SWIG_fail;
11480     {
11481         PyThreadState* __tstate = wxPyBeginAllowThreads();
11482         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetVisibleEnd();
11483
11484         wxPyEndAllowThreads(__tstate);
11485         if (PyErr_Occurred()) SWIG_fail;
11486     }
11487     {
11488         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11489     }
11490     return resultobj;
11491     fail:
11492     return NULL;
11493 }
11494
11495
11496 static PyObject *_wrap_VScrolledWindow_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11497     PyObject *resultobj;
11498     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11499     size_t arg2 ;
11500     bool result;
11501     PyObject * obj0 = 0 ;
11502     PyObject * obj1 = 0 ;
11503     char *kwnames[] = {
11504         (char *) "self",(char *) "line", NULL
11505     };
11506
11507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VScrolledWindow_IsVisible",kwnames,&obj0,&obj1)) goto fail;
11508     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11509     if (SWIG_arg_fail(1)) SWIG_fail;
11510     {
11511         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11512         if (SWIG_arg_fail(2)) SWIG_fail;
11513     }
11514     {
11515         PyThreadState* __tstate = wxPyBeginAllowThreads();
11516         result = (bool)((wxPyVScrolledWindow const *)arg1)->IsVisible(arg2);
11517
11518         wxPyEndAllowThreads(__tstate);
11519         if (PyErr_Occurred()) SWIG_fail;
11520     }
11521     {
11522         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11523     }
11524     return resultobj;
11525     fail:
11526     return NULL;
11527 }
11528
11529
11530 static PyObject *_wrap_VScrolledWindow_GetFirstVisibleLine(PyObject *, PyObject *args, PyObject *kwargs) {
11531     PyObject *resultobj;
11532     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11533     size_t result;
11534     PyObject * obj0 = 0 ;
11535     char *kwnames[] = {
11536         (char *) "self", NULL
11537     };
11538
11539     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetFirstVisibleLine",kwnames,&obj0)) goto fail;
11540     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11541     if (SWIG_arg_fail(1)) SWIG_fail;
11542     {
11543         PyThreadState* __tstate = wxPyBeginAllowThreads();
11544         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetFirstVisibleLine();
11545
11546         wxPyEndAllowThreads(__tstate);
11547         if (PyErr_Occurred()) SWIG_fail;
11548     }
11549     {
11550         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11551     }
11552     return resultobj;
11553     fail:
11554     return NULL;
11555 }
11556
11557
11558 static PyObject *_wrap_VScrolledWindow_GetLastVisibleLine(PyObject *, PyObject *args, PyObject *kwargs) {
11559     PyObject *resultobj;
11560     wxPyVScrolledWindow *arg1 = (wxPyVScrolledWindow *) 0 ;
11561     size_t result;
11562     PyObject * obj0 = 0 ;
11563     char *kwnames[] = {
11564         (char *) "self", NULL
11565     };
11566
11567     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VScrolledWindow_GetLastVisibleLine",kwnames,&obj0)) goto fail;
11568     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
11569     if (SWIG_arg_fail(1)) SWIG_fail;
11570     {
11571         PyThreadState* __tstate = wxPyBeginAllowThreads();
11572         result = (size_t)((wxPyVScrolledWindow const *)arg1)->GetLastVisibleLine();
11573
11574         wxPyEndAllowThreads(__tstate);
11575         if (PyErr_Occurred()) SWIG_fail;
11576     }
11577     {
11578         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11579     }
11580     return resultobj;
11581     fail:
11582     return NULL;
11583 }
11584
11585
11586 static PyObject * VScrolledWindow_swigregister(PyObject *, PyObject *args) {
11587     PyObject *obj;
11588     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11589     SWIG_TypeClientData(SWIGTYPE_p_wxPyVScrolledWindow, obj);
11590     Py_INCREF(obj);
11591     return Py_BuildValue((char *)"");
11592 }
11593 static int _wrap_VListBoxNameStr_set(PyObject *) {
11594     PyErr_SetString(PyExc_TypeError,"Variable VListBoxNameStr is read-only.");
11595     return 1;
11596 }
11597
11598
11599 static PyObject *_wrap_VListBoxNameStr_get(void) {
11600     PyObject *pyobj;
11601
11602     {
11603 #if wxUSE_UNICODE
11604         pyobj = PyUnicode_FromWideChar((&wxPyVListBoxNameStr)->c_str(), (&wxPyVListBoxNameStr)->Len());
11605 #else
11606         pyobj = PyString_FromStringAndSize((&wxPyVListBoxNameStr)->c_str(), (&wxPyVListBoxNameStr)->Len());
11607 #endif
11608     }
11609     return pyobj;
11610 }
11611
11612
11613 static PyObject *_wrap_new_VListBox(PyObject *, PyObject *args, PyObject *kwargs) {
11614     PyObject *resultobj;
11615     wxWindow *arg1 = (wxWindow *) 0 ;
11616     int arg2 = (int) wxID_ANY ;
11617     wxPoint const &arg3_defvalue = wxDefaultPosition ;
11618     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
11619     wxSize const &arg4_defvalue = wxDefaultSize ;
11620     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
11621     long arg5 = (long) 0 ;
11622     wxString const &arg6_defvalue = wxPyVListBoxNameStr ;
11623     wxString *arg6 = (wxString *) &arg6_defvalue ;
11624     wxPyVListBox *result;
11625     wxPoint temp3 ;
11626     wxSize temp4 ;
11627     bool temp6 = false ;
11628     PyObject * obj0 = 0 ;
11629     PyObject * obj1 = 0 ;
11630     PyObject * obj2 = 0 ;
11631     PyObject * obj3 = 0 ;
11632     PyObject * obj4 = 0 ;
11633     PyObject * obj5 = 0 ;
11634     char *kwnames[] = {
11635         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11636     };
11637
11638     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_VListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11639     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11640     if (SWIG_arg_fail(1)) SWIG_fail;
11641     if (obj1) {
11642         {
11643             arg2 = (int)(SWIG_As_int(obj1));
11644             if (SWIG_arg_fail(2)) SWIG_fail;
11645         }
11646     }
11647     if (obj2) {
11648         {
11649             arg3 = &temp3;
11650             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11651         }
11652     }
11653     if (obj3) {
11654         {
11655             arg4 = &temp4;
11656             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
11657         }
11658     }
11659     if (obj4) {
11660         {
11661             arg5 = (long)(SWIG_As_long(obj4));
11662             if (SWIG_arg_fail(5)) SWIG_fail;
11663         }
11664     }
11665     if (obj5) {
11666         {
11667             arg6 = wxString_in_helper(obj5);
11668             if (arg6 == NULL) SWIG_fail;
11669             temp6 = true;
11670         }
11671     }
11672     {
11673         if (!wxPyCheckForApp()) SWIG_fail;
11674         PyThreadState* __tstate = wxPyBeginAllowThreads();
11675         result = (wxPyVListBox *)new wxPyVListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
11676
11677         wxPyEndAllowThreads(__tstate);
11678         if (PyErr_Occurred()) SWIG_fail;
11679     }
11680     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVListBox, 1);
11681     {
11682         if (temp6)
11683         delete arg6;
11684     }
11685     return resultobj;
11686     fail:
11687     {
11688         if (temp6)
11689         delete arg6;
11690     }
11691     return NULL;
11692 }
11693
11694
11695 static PyObject *_wrap_new_PreVListBox(PyObject *, PyObject *args, PyObject *kwargs) {
11696     PyObject *resultobj;
11697     wxPyVListBox *result;
11698     char *kwnames[] = {
11699         NULL
11700     };
11701
11702     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreVListBox",kwnames)) goto fail;
11703     {
11704         if (!wxPyCheckForApp()) SWIG_fail;
11705         PyThreadState* __tstate = wxPyBeginAllowThreads();
11706         result = (wxPyVListBox *)new wxPyVListBox();
11707
11708         wxPyEndAllowThreads(__tstate);
11709         if (PyErr_Occurred()) SWIG_fail;
11710     }
11711     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyVListBox, 1);
11712     return resultobj;
11713     fail:
11714     return NULL;
11715 }
11716
11717
11718 static PyObject *_wrap_VListBox__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11719     PyObject *resultobj;
11720     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11721     PyObject *arg2 = (PyObject *) 0 ;
11722     PyObject *arg3 = (PyObject *) 0 ;
11723     PyObject * obj0 = 0 ;
11724     PyObject * obj1 = 0 ;
11725     PyObject * obj2 = 0 ;
11726     char *kwnames[] = {
11727         (char *) "self",(char *) "self",(char *) "_class", NULL
11728     };
11729
11730     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11731     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11732     if (SWIG_arg_fail(1)) SWIG_fail;
11733     arg2 = obj1;
11734     arg3 = obj2;
11735     {
11736         PyThreadState* __tstate = wxPyBeginAllowThreads();
11737         (arg1)->_setCallbackInfo(arg2,arg3);
11738
11739         wxPyEndAllowThreads(__tstate);
11740         if (PyErr_Occurred()) SWIG_fail;
11741     }
11742     Py_INCREF(Py_None); resultobj = Py_None;
11743     return resultobj;
11744     fail:
11745     return NULL;
11746 }
11747
11748
11749 static PyObject *_wrap_VListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11750     PyObject *resultobj;
11751     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11752     wxWindow *arg2 = (wxWindow *) 0 ;
11753     int arg3 = (int) wxID_ANY ;
11754     wxPoint const &arg4_defvalue = wxDefaultPosition ;
11755     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
11756     wxSize const &arg5_defvalue = wxDefaultSize ;
11757     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
11758     long arg6 = (long) 0 ;
11759     wxString const &arg7_defvalue = wxPyVListBoxNameStr ;
11760     wxString *arg7 = (wxString *) &arg7_defvalue ;
11761     bool result;
11762     wxPoint temp4 ;
11763     wxSize temp5 ;
11764     bool temp7 = false ;
11765     PyObject * obj0 = 0 ;
11766     PyObject * obj1 = 0 ;
11767     PyObject * obj2 = 0 ;
11768     PyObject * obj3 = 0 ;
11769     PyObject * obj4 = 0 ;
11770     PyObject * obj5 = 0 ;
11771     PyObject * obj6 = 0 ;
11772     char *kwnames[] = {
11773         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
11774     };
11775
11776     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:VListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
11777     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11778     if (SWIG_arg_fail(1)) SWIG_fail;
11779     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
11780     if (SWIG_arg_fail(2)) SWIG_fail;
11781     if (obj2) {
11782         {
11783             arg3 = (int)(SWIG_As_int(obj2));
11784             if (SWIG_arg_fail(3)) SWIG_fail;
11785         }
11786     }
11787     if (obj3) {
11788         {
11789             arg4 = &temp4;
11790             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
11791         }
11792     }
11793     if (obj4) {
11794         {
11795             arg5 = &temp5;
11796             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
11797         }
11798     }
11799     if (obj5) {
11800         {
11801             arg6 = (long)(SWIG_As_long(obj5));
11802             if (SWIG_arg_fail(6)) SWIG_fail;
11803         }
11804     }
11805     if (obj6) {
11806         {
11807             arg7 = wxString_in_helper(obj6);
11808             if (arg7 == NULL) SWIG_fail;
11809             temp7 = true;
11810         }
11811     }
11812     {
11813         PyThreadState* __tstate = wxPyBeginAllowThreads();
11814         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
11815
11816         wxPyEndAllowThreads(__tstate);
11817         if (PyErr_Occurred()) SWIG_fail;
11818     }
11819     {
11820         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11821     }
11822     {
11823         if (temp7)
11824         delete arg7;
11825     }
11826     return resultobj;
11827     fail:
11828     {
11829         if (temp7)
11830         delete arg7;
11831     }
11832     return NULL;
11833 }
11834
11835
11836 static PyObject *_wrap_VListBox_GetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
11837     PyObject *resultobj;
11838     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11839     size_t result;
11840     PyObject * obj0 = 0 ;
11841     char *kwnames[] = {
11842         (char *) "self", NULL
11843     };
11844
11845     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetItemCount",kwnames,&obj0)) goto fail;
11846     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11847     if (SWIG_arg_fail(1)) SWIG_fail;
11848     {
11849         PyThreadState* __tstate = wxPyBeginAllowThreads();
11850         result = (size_t)((wxPyVListBox const *)arg1)->GetItemCount();
11851
11852         wxPyEndAllowThreads(__tstate);
11853         if (PyErr_Occurred()) SWIG_fail;
11854     }
11855     {
11856         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
11857     }
11858     return resultobj;
11859     fail:
11860     return NULL;
11861 }
11862
11863
11864 static PyObject *_wrap_VListBox_HasMultipleSelection(PyObject *, PyObject *args, PyObject *kwargs) {
11865     PyObject *resultobj;
11866     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11867     bool result;
11868     PyObject * obj0 = 0 ;
11869     char *kwnames[] = {
11870         (char *) "self", NULL
11871     };
11872
11873     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_HasMultipleSelection",kwnames,&obj0)) goto fail;
11874     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11875     if (SWIG_arg_fail(1)) SWIG_fail;
11876     {
11877         PyThreadState* __tstate = wxPyBeginAllowThreads();
11878         result = (bool)((wxPyVListBox const *)arg1)->HasMultipleSelection();
11879
11880         wxPyEndAllowThreads(__tstate);
11881         if (PyErr_Occurred()) SWIG_fail;
11882     }
11883     {
11884         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11885     }
11886     return resultobj;
11887     fail:
11888     return NULL;
11889 }
11890
11891
11892 static PyObject *_wrap_VListBox_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
11893     PyObject *resultobj;
11894     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11895     int result;
11896     PyObject * obj0 = 0 ;
11897     char *kwnames[] = {
11898         (char *) "self", NULL
11899     };
11900
11901     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelection",kwnames,&obj0)) goto fail;
11902     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11903     if (SWIG_arg_fail(1)) SWIG_fail;
11904     {
11905         PyThreadState* __tstate = wxPyBeginAllowThreads();
11906         result = (int)((wxPyVListBox const *)arg1)->GetSelection();
11907
11908         wxPyEndAllowThreads(__tstate);
11909         if (PyErr_Occurred()) SWIG_fail;
11910     }
11911     {
11912         resultobj = SWIG_From_int((int)(result));
11913     }
11914     return resultobj;
11915     fail:
11916     return NULL;
11917 }
11918
11919
11920 static PyObject *_wrap_VListBox_IsCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
11921     PyObject *resultobj;
11922     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11923     size_t arg2 ;
11924     bool result;
11925     PyObject * obj0 = 0 ;
11926     PyObject * obj1 = 0 ;
11927     char *kwnames[] = {
11928         (char *) "self",(char *) "item", NULL
11929     };
11930
11931     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_IsCurrent",kwnames,&obj0,&obj1)) goto fail;
11932     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11933     if (SWIG_arg_fail(1)) SWIG_fail;
11934     {
11935         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11936         if (SWIG_arg_fail(2)) SWIG_fail;
11937     }
11938     {
11939         PyThreadState* __tstate = wxPyBeginAllowThreads();
11940         result = (bool)((wxPyVListBox const *)arg1)->IsCurrent(arg2);
11941
11942         wxPyEndAllowThreads(__tstate);
11943         if (PyErr_Occurred()) SWIG_fail;
11944     }
11945     {
11946         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11947     }
11948     return resultobj;
11949     fail:
11950     return NULL;
11951 }
11952
11953
11954 static PyObject *_wrap_VListBox_IsSelected(PyObject *, PyObject *args, PyObject *kwargs) {
11955     PyObject *resultobj;
11956     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11957     size_t arg2 ;
11958     bool result;
11959     PyObject * obj0 = 0 ;
11960     PyObject * obj1 = 0 ;
11961     char *kwnames[] = {
11962         (char *) "self",(char *) "item", NULL
11963     };
11964
11965     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_IsSelected",kwnames,&obj0,&obj1)) goto fail;
11966     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11967     if (SWIG_arg_fail(1)) SWIG_fail;
11968     {
11969         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
11970         if (SWIG_arg_fail(2)) SWIG_fail;
11971     }
11972     {
11973         PyThreadState* __tstate = wxPyBeginAllowThreads();
11974         result = (bool)((wxPyVListBox const *)arg1)->IsSelected(arg2);
11975
11976         wxPyEndAllowThreads(__tstate);
11977         if (PyErr_Occurred()) SWIG_fail;
11978     }
11979     {
11980         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11981     }
11982     return resultobj;
11983     fail:
11984     return NULL;
11985 }
11986
11987
11988 static PyObject *_wrap_VListBox_GetSelectedCount(PyObject *, PyObject *args, PyObject *kwargs) {
11989     PyObject *resultobj;
11990     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
11991     size_t result;
11992     PyObject * obj0 = 0 ;
11993     char *kwnames[] = {
11994         (char *) "self", NULL
11995     };
11996
11997     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelectedCount",kwnames,&obj0)) goto fail;
11998     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
11999     if (SWIG_arg_fail(1)) SWIG_fail;
12000     {
12001         PyThreadState* __tstate = wxPyBeginAllowThreads();
12002         result = (size_t)((wxPyVListBox const *)arg1)->GetSelectedCount();
12003
12004         wxPyEndAllowThreads(__tstate);
12005         if (PyErr_Occurred()) SWIG_fail;
12006     }
12007     {
12008         resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
12009     }
12010     return resultobj;
12011     fail:
12012     return NULL;
12013 }
12014
12015
12016 static PyObject *_wrap_VListBox_GetFirstSelected(PyObject *, PyObject *args, PyObject *kwargs) {
12017     PyObject *resultobj;
12018     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12019     PyObject *result;
12020     PyObject * obj0 = 0 ;
12021     char *kwnames[] = {
12022         (char *) "self", NULL
12023     };
12024
12025     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetFirstSelected",kwnames,&obj0)) goto fail;
12026     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12027     if (SWIG_arg_fail(1)) SWIG_fail;
12028     {
12029         PyThreadState* __tstate = wxPyBeginAllowThreads();
12030         result = (PyObject *)wxPyVListBox_GetFirstSelected(arg1);
12031
12032         wxPyEndAllowThreads(__tstate);
12033         if (PyErr_Occurred()) SWIG_fail;
12034     }
12035     resultobj = result;
12036     return resultobj;
12037     fail:
12038     return NULL;
12039 }
12040
12041
12042 static PyObject *_wrap_VListBox_GetNextSelected(PyObject *, PyObject *args, PyObject *kwargs) {
12043     PyObject *resultobj;
12044     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12045     unsigned long arg2 ;
12046     PyObject *result;
12047     PyObject * obj0 = 0 ;
12048     PyObject * obj1 = 0 ;
12049     char *kwnames[] = {
12050         (char *) "self",(char *) "cookie", NULL
12051     };
12052
12053     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_GetNextSelected",kwnames,&obj0,&obj1)) goto fail;
12054     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12055     if (SWIG_arg_fail(1)) SWIG_fail;
12056     {
12057         arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
12058         if (SWIG_arg_fail(2)) SWIG_fail;
12059     }
12060     {
12061         PyThreadState* __tstate = wxPyBeginAllowThreads();
12062         result = (PyObject *)wxPyVListBox_GetNextSelected(arg1,arg2);
12063
12064         wxPyEndAllowThreads(__tstate);
12065         if (PyErr_Occurred()) SWIG_fail;
12066     }
12067     resultobj = result;
12068     return resultobj;
12069     fail:
12070     return NULL;
12071 }
12072
12073
12074 static PyObject *_wrap_VListBox_GetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
12075     PyObject *resultobj;
12076     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12077     wxPoint result;
12078     PyObject * obj0 = 0 ;
12079     char *kwnames[] = {
12080         (char *) "self", NULL
12081     };
12082
12083     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetMargins",kwnames,&obj0)) goto fail;
12084     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12085     if (SWIG_arg_fail(1)) SWIG_fail;
12086     {
12087         PyThreadState* __tstate = wxPyBeginAllowThreads();
12088         result = ((wxPyVListBox const *)arg1)->GetMargins();
12089
12090         wxPyEndAllowThreads(__tstate);
12091         if (PyErr_Occurred()) SWIG_fail;
12092     }
12093     {
12094         wxPoint * resultptr;
12095         resultptr = new wxPoint((wxPoint &)(result));
12096         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12097     }
12098     return resultobj;
12099     fail:
12100     return NULL;
12101 }
12102
12103
12104 static PyObject *_wrap_VListBox_GetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
12105     PyObject *resultobj;
12106     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12107     wxColour *result;
12108     PyObject * obj0 = 0 ;
12109     char *kwnames[] = {
12110         (char *) "self", NULL
12111     };
12112
12113     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_GetSelectionBackground",kwnames,&obj0)) goto fail;
12114     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12115     if (SWIG_arg_fail(1)) SWIG_fail;
12116     {
12117         PyThreadState* __tstate = wxPyBeginAllowThreads();
12118         {
12119             wxColour const &_result_ref = ((wxPyVListBox const *)arg1)->GetSelectionBackground();
12120             result = (wxColour *) &_result_ref;
12121         }
12122
12123         wxPyEndAllowThreads(__tstate);
12124         if (PyErr_Occurred()) SWIG_fail;
12125     }
12126     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
12127     return resultobj;
12128     fail:
12129     return NULL;
12130 }
12131
12132
12133 static PyObject *_wrap_VListBox_SetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
12134     PyObject *resultobj;
12135     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12136     size_t arg2 ;
12137     PyObject * obj0 = 0 ;
12138     PyObject * obj1 = 0 ;
12139     char *kwnames[] = {
12140         (char *) "self",(char *) "count", NULL
12141     };
12142
12143     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetItemCount",kwnames,&obj0,&obj1)) goto fail;
12144     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12145     if (SWIG_arg_fail(1)) SWIG_fail;
12146     {
12147         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12148         if (SWIG_arg_fail(2)) SWIG_fail;
12149     }
12150     {
12151         PyThreadState* __tstate = wxPyBeginAllowThreads();
12152         (arg1)->SetItemCount(arg2);
12153
12154         wxPyEndAllowThreads(__tstate);
12155         if (PyErr_Occurred()) SWIG_fail;
12156     }
12157     Py_INCREF(Py_None); resultobj = Py_None;
12158     return resultobj;
12159     fail:
12160     return NULL;
12161 }
12162
12163
12164 static PyObject *_wrap_VListBox_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
12165     PyObject *resultobj;
12166     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12167     PyObject * obj0 = 0 ;
12168     char *kwnames[] = {
12169         (char *) "self", NULL
12170     };
12171
12172     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_Clear",kwnames,&obj0)) goto fail;
12173     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12174     if (SWIG_arg_fail(1)) SWIG_fail;
12175     {
12176         PyThreadState* __tstate = wxPyBeginAllowThreads();
12177         (arg1)->Clear();
12178
12179         wxPyEndAllowThreads(__tstate);
12180         if (PyErr_Occurred()) SWIG_fail;
12181     }
12182     Py_INCREF(Py_None); resultobj = Py_None;
12183     return resultobj;
12184     fail:
12185     return NULL;
12186 }
12187
12188
12189 static PyObject *_wrap_VListBox_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
12190     PyObject *resultobj;
12191     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12192     int arg2 ;
12193     PyObject * obj0 = 0 ;
12194     PyObject * obj1 = 0 ;
12195     char *kwnames[] = {
12196         (char *) "self",(char *) "selection", NULL
12197     };
12198
12199     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetSelection",kwnames,&obj0,&obj1)) goto fail;
12200     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12201     if (SWIG_arg_fail(1)) SWIG_fail;
12202     {
12203         arg2 = (int)(SWIG_As_int(obj1));
12204         if (SWIG_arg_fail(2)) SWIG_fail;
12205     }
12206     {
12207         PyThreadState* __tstate = wxPyBeginAllowThreads();
12208         (arg1)->SetSelection(arg2);
12209
12210         wxPyEndAllowThreads(__tstate);
12211         if (PyErr_Occurred()) SWIG_fail;
12212     }
12213     Py_INCREF(Py_None); resultobj = Py_None;
12214     return resultobj;
12215     fail:
12216     return NULL;
12217 }
12218
12219
12220 static PyObject *_wrap_VListBox_Select(PyObject *, PyObject *args, PyObject *kwargs) {
12221     PyObject *resultobj;
12222     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12223     size_t arg2 ;
12224     bool arg3 = (bool) true ;
12225     bool result;
12226     PyObject * obj0 = 0 ;
12227     PyObject * obj1 = 0 ;
12228     PyObject * obj2 = 0 ;
12229     char *kwnames[] = {
12230         (char *) "self",(char *) "item",(char *) "select", NULL
12231     };
12232
12233     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:VListBox_Select",kwnames,&obj0,&obj1,&obj2)) goto fail;
12234     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12235     if (SWIG_arg_fail(1)) SWIG_fail;
12236     {
12237         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12238         if (SWIG_arg_fail(2)) SWIG_fail;
12239     }
12240     if (obj2) {
12241         {
12242             arg3 = (bool)(SWIG_As_bool(obj2));
12243             if (SWIG_arg_fail(3)) SWIG_fail;
12244         }
12245     }
12246     {
12247         PyThreadState* __tstate = wxPyBeginAllowThreads();
12248         result = (bool)(arg1)->Select(arg2,arg3);
12249
12250         wxPyEndAllowThreads(__tstate);
12251         if (PyErr_Occurred()) SWIG_fail;
12252     }
12253     {
12254         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12255     }
12256     return resultobj;
12257     fail:
12258     return NULL;
12259 }
12260
12261
12262 static PyObject *_wrap_VListBox_SelectRange(PyObject *, PyObject *args, PyObject *kwargs) {
12263     PyObject *resultobj;
12264     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12265     size_t arg2 ;
12266     size_t arg3 ;
12267     bool result;
12268     PyObject * obj0 = 0 ;
12269     PyObject * obj1 = 0 ;
12270     PyObject * obj2 = 0 ;
12271     char *kwnames[] = {
12272         (char *) "self",(char *) "from",(char *) "to", NULL
12273     };
12274
12275     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox_SelectRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
12276     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12277     if (SWIG_arg_fail(1)) SWIG_fail;
12278     {
12279         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12280         if (SWIG_arg_fail(2)) SWIG_fail;
12281     }
12282     {
12283         arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12284         if (SWIG_arg_fail(3)) SWIG_fail;
12285     }
12286     {
12287         PyThreadState* __tstate = wxPyBeginAllowThreads();
12288         result = (bool)(arg1)->SelectRange(arg2,arg3);
12289
12290         wxPyEndAllowThreads(__tstate);
12291         if (PyErr_Occurred()) SWIG_fail;
12292     }
12293     {
12294         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12295     }
12296     return resultobj;
12297     fail:
12298     return NULL;
12299 }
12300
12301
12302 static PyObject *_wrap_VListBox_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
12303     PyObject *resultobj;
12304     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12305     size_t arg2 ;
12306     PyObject * obj0 = 0 ;
12307     PyObject * obj1 = 0 ;
12308     char *kwnames[] = {
12309         (char *) "self",(char *) "item", NULL
12310     };
12311
12312     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_Toggle",kwnames,&obj0,&obj1)) goto fail;
12313     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12314     if (SWIG_arg_fail(1)) SWIG_fail;
12315     {
12316         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12317         if (SWIG_arg_fail(2)) SWIG_fail;
12318     }
12319     {
12320         PyThreadState* __tstate = wxPyBeginAllowThreads();
12321         (arg1)->Toggle(arg2);
12322
12323         wxPyEndAllowThreads(__tstate);
12324         if (PyErr_Occurred()) SWIG_fail;
12325     }
12326     Py_INCREF(Py_None); resultobj = Py_None;
12327     return resultobj;
12328     fail:
12329     return NULL;
12330 }
12331
12332
12333 static PyObject *_wrap_VListBox_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
12334     PyObject *resultobj;
12335     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12336     bool result;
12337     PyObject * obj0 = 0 ;
12338     char *kwnames[] = {
12339         (char *) "self", NULL
12340     };
12341
12342     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_SelectAll",kwnames,&obj0)) goto fail;
12343     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12344     if (SWIG_arg_fail(1)) SWIG_fail;
12345     {
12346         PyThreadState* __tstate = wxPyBeginAllowThreads();
12347         result = (bool)(arg1)->SelectAll();
12348
12349         wxPyEndAllowThreads(__tstate);
12350         if (PyErr_Occurred()) SWIG_fail;
12351     }
12352     {
12353         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12354     }
12355     return resultobj;
12356     fail:
12357     return NULL;
12358 }
12359
12360
12361 static PyObject *_wrap_VListBox_DeselectAll(PyObject *, PyObject *args, PyObject *kwargs) {
12362     PyObject *resultobj;
12363     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12364     bool result;
12365     PyObject * obj0 = 0 ;
12366     char *kwnames[] = {
12367         (char *) "self", NULL
12368     };
12369
12370     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VListBox_DeselectAll",kwnames,&obj0)) goto fail;
12371     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12372     if (SWIG_arg_fail(1)) SWIG_fail;
12373     {
12374         PyThreadState* __tstate = wxPyBeginAllowThreads();
12375         result = (bool)(arg1)->DeselectAll();
12376
12377         wxPyEndAllowThreads(__tstate);
12378         if (PyErr_Occurred()) SWIG_fail;
12379     }
12380     {
12381         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12382     }
12383     return resultobj;
12384     fail:
12385     return NULL;
12386 }
12387
12388
12389 static PyObject *_wrap_VListBox_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
12390     PyObject *resultobj;
12391     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12392     wxPoint *arg2 = 0 ;
12393     wxPoint temp2 ;
12394     PyObject * obj0 = 0 ;
12395     PyObject * obj1 = 0 ;
12396     char *kwnames[] = {
12397         (char *) "self",(char *) "pt", NULL
12398     };
12399
12400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetMargins",kwnames,&obj0,&obj1)) goto fail;
12401     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12402     if (SWIG_arg_fail(1)) SWIG_fail;
12403     {
12404         arg2 = &temp2;
12405         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12406     }
12407     {
12408         PyThreadState* __tstate = wxPyBeginAllowThreads();
12409         (arg1)->SetMargins((wxPoint const &)*arg2);
12410
12411         wxPyEndAllowThreads(__tstate);
12412         if (PyErr_Occurred()) SWIG_fail;
12413     }
12414     Py_INCREF(Py_None); resultobj = Py_None;
12415     return resultobj;
12416     fail:
12417     return NULL;
12418 }
12419
12420
12421 static PyObject *_wrap_VListBox_SetMarginsXY(PyObject *, PyObject *args, PyObject *kwargs) {
12422     PyObject *resultobj;
12423     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12424     int arg2 ;
12425     int arg3 ;
12426     PyObject * obj0 = 0 ;
12427     PyObject * obj1 = 0 ;
12428     PyObject * obj2 = 0 ;
12429     char *kwnames[] = {
12430         (char *) "self",(char *) "x",(char *) "y", NULL
12431     };
12432
12433     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:VListBox_SetMarginsXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
12434     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12435     if (SWIG_arg_fail(1)) SWIG_fail;
12436     {
12437         arg2 = (int)(SWIG_As_int(obj1));
12438         if (SWIG_arg_fail(2)) SWIG_fail;
12439     }
12440     {
12441         arg3 = (int)(SWIG_As_int(obj2));
12442         if (SWIG_arg_fail(3)) SWIG_fail;
12443     }
12444     {
12445         PyThreadState* __tstate = wxPyBeginAllowThreads();
12446         (arg1)->SetMargins(arg2,arg3);
12447
12448         wxPyEndAllowThreads(__tstate);
12449         if (PyErr_Occurred()) SWIG_fail;
12450     }
12451     Py_INCREF(Py_None); resultobj = Py_None;
12452     return resultobj;
12453     fail:
12454     return NULL;
12455 }
12456
12457
12458 static PyObject *_wrap_VListBox_SetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
12459     PyObject *resultobj;
12460     wxPyVListBox *arg1 = (wxPyVListBox *) 0 ;
12461     wxColour *arg2 = 0 ;
12462     wxColour temp2 ;
12463     PyObject * obj0 = 0 ;
12464     PyObject * obj1 = 0 ;
12465     char *kwnames[] = {
12466         (char *) "self",(char *) "col", NULL
12467     };
12468
12469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VListBox_SetSelectionBackground",kwnames,&obj0,&obj1)) goto fail;
12470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyVListBox, SWIG_POINTER_EXCEPTION | 0);
12471     if (SWIG_arg_fail(1)) SWIG_fail;
12472     {
12473         arg2 = &temp2;
12474         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12475     }
12476     {
12477         PyThreadState* __tstate = wxPyBeginAllowThreads();
12478         (arg1)->SetSelectionBackground((wxColour const &)*arg2);
12479
12480         wxPyEndAllowThreads(__tstate);
12481         if (PyErr_Occurred()) SWIG_fail;
12482     }
12483     Py_INCREF(Py_None); resultobj = Py_None;
12484     return resultobj;
12485     fail:
12486     return NULL;
12487 }
12488
12489
12490 static PyObject * VListBox_swigregister(PyObject *, PyObject *args) {
12491     PyObject *obj;
12492     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12493     SWIG_TypeClientData(SWIGTYPE_p_wxPyVListBox, obj);
12494     Py_INCREF(obj);
12495     return Py_BuildValue((char *)"");
12496 }
12497 static PyObject *_wrap_new_HtmlListBox(PyObject *, PyObject *args, PyObject *kwargs) {
12498     PyObject *resultobj;
12499     wxWindow *arg1 = (wxWindow *) 0 ;
12500     int arg2 = (int) wxID_ANY ;
12501     wxPoint const &arg3_defvalue = wxDefaultPosition ;
12502     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
12503     wxSize const &arg4_defvalue = wxDefaultSize ;
12504     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
12505     long arg5 = (long) 0 ;
12506     wxString const &arg6_defvalue = wxPyVListBoxNameStr ;
12507     wxString *arg6 = (wxString *) &arg6_defvalue ;
12508     wxPyHtmlListBox *result;
12509     wxPoint temp3 ;
12510     wxSize temp4 ;
12511     bool temp6 = false ;
12512     PyObject * obj0 = 0 ;
12513     PyObject * obj1 = 0 ;
12514     PyObject * obj2 = 0 ;
12515     PyObject * obj3 = 0 ;
12516     PyObject * obj4 = 0 ;
12517     PyObject * obj5 = 0 ;
12518     char *kwnames[] = {
12519         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12520     };
12521
12522     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_HtmlListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12523     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12524     if (SWIG_arg_fail(1)) SWIG_fail;
12525     if (obj1) {
12526         {
12527             arg2 = (int)(SWIG_As_int(obj1));
12528             if (SWIG_arg_fail(2)) SWIG_fail;
12529         }
12530     }
12531     if (obj2) {
12532         {
12533             arg3 = &temp3;
12534             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12535         }
12536     }
12537     if (obj3) {
12538         {
12539             arg4 = &temp4;
12540             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
12541         }
12542     }
12543     if (obj4) {
12544         {
12545             arg5 = (long)(SWIG_As_long(obj4));
12546             if (SWIG_arg_fail(5)) SWIG_fail;
12547         }
12548     }
12549     if (obj5) {
12550         {
12551             arg6 = wxString_in_helper(obj5);
12552             if (arg6 == NULL) SWIG_fail;
12553             temp6 = true;
12554         }
12555     }
12556     {
12557         if (!wxPyCheckForApp()) SWIG_fail;
12558         PyThreadState* __tstate = wxPyBeginAllowThreads();
12559         result = (wxPyHtmlListBox *)new wxPyHtmlListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
12560
12561         wxPyEndAllowThreads(__tstate);
12562         if (PyErr_Occurred()) SWIG_fail;
12563     }
12564     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyHtmlListBox, 1);
12565     {
12566         if (temp6)
12567         delete arg6;
12568     }
12569     return resultobj;
12570     fail:
12571     {
12572         if (temp6)
12573         delete arg6;
12574     }
12575     return NULL;
12576 }
12577
12578
12579 static PyObject *_wrap_new_PreHtmlListBox(PyObject *, PyObject *args, PyObject *kwargs) {
12580     PyObject *resultobj;
12581     wxPyHtmlListBox *result;
12582     char *kwnames[] = {
12583         NULL
12584     };
12585
12586     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreHtmlListBox",kwnames)) goto fail;
12587     {
12588         if (!wxPyCheckForApp()) SWIG_fail;
12589         PyThreadState* __tstate = wxPyBeginAllowThreads();
12590         result = (wxPyHtmlListBox *)new wxPyHtmlListBox();
12591
12592         wxPyEndAllowThreads(__tstate);
12593         if (PyErr_Occurred()) SWIG_fail;
12594     }
12595     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyHtmlListBox, 1);
12596     return resultobj;
12597     fail:
12598     return NULL;
12599 }
12600
12601
12602 static PyObject *_wrap_HtmlListBox__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12603     PyObject *resultobj;
12604     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12605     PyObject *arg2 = (PyObject *) 0 ;
12606     PyObject *arg3 = (PyObject *) 0 ;
12607     PyObject * obj0 = 0 ;
12608     PyObject * obj1 = 0 ;
12609     PyObject * obj2 = 0 ;
12610     char *kwnames[] = {
12611         (char *) "self",(char *) "self",(char *) "_class", NULL
12612     };
12613
12614     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:HtmlListBox__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
12615     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12616     if (SWIG_arg_fail(1)) SWIG_fail;
12617     arg2 = obj1;
12618     arg3 = obj2;
12619     {
12620         PyThreadState* __tstate = wxPyBeginAllowThreads();
12621         (arg1)->_setCallbackInfo(arg2,arg3);
12622
12623         wxPyEndAllowThreads(__tstate);
12624         if (PyErr_Occurred()) SWIG_fail;
12625     }
12626     Py_INCREF(Py_None); resultobj = Py_None;
12627     return resultobj;
12628     fail:
12629     return NULL;
12630 }
12631
12632
12633 static PyObject *_wrap_HtmlListBox_Create(PyObject *, PyObject *args, PyObject *kwargs) {
12634     PyObject *resultobj;
12635     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12636     wxWindow *arg2 = (wxWindow *) 0 ;
12637     int arg3 = (int) wxID_ANY ;
12638     wxPoint const &arg4_defvalue = wxDefaultPosition ;
12639     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
12640     wxSize const &arg5_defvalue = wxDefaultSize ;
12641     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
12642     long arg6 = (long) 0 ;
12643     wxString const &arg7_defvalue = wxPyVListBoxNameStr ;
12644     wxString *arg7 = (wxString *) &arg7_defvalue ;
12645     bool result;
12646     wxPoint temp4 ;
12647     wxSize temp5 ;
12648     bool temp7 = false ;
12649     PyObject * obj0 = 0 ;
12650     PyObject * obj1 = 0 ;
12651     PyObject * obj2 = 0 ;
12652     PyObject * obj3 = 0 ;
12653     PyObject * obj4 = 0 ;
12654     PyObject * obj5 = 0 ;
12655     PyObject * obj6 = 0 ;
12656     char *kwnames[] = {
12657         (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
12658     };
12659
12660     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:HtmlListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12661     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12662     if (SWIG_arg_fail(1)) SWIG_fail;
12663     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12664     if (SWIG_arg_fail(2)) SWIG_fail;
12665     if (obj2) {
12666         {
12667             arg3 = (int)(SWIG_As_int(obj2));
12668             if (SWIG_arg_fail(3)) SWIG_fail;
12669         }
12670     }
12671     if (obj3) {
12672         {
12673             arg4 = &temp4;
12674             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12675         }
12676     }
12677     if (obj4) {
12678         {
12679             arg5 = &temp5;
12680             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
12681         }
12682     }
12683     if (obj5) {
12684         {
12685             arg6 = (long)(SWIG_As_long(obj5));
12686             if (SWIG_arg_fail(6)) SWIG_fail;
12687         }
12688     }
12689     if (obj6) {
12690         {
12691             arg7 = wxString_in_helper(obj6);
12692             if (arg7 == NULL) SWIG_fail;
12693             temp7 = true;
12694         }
12695     }
12696     {
12697         PyThreadState* __tstate = wxPyBeginAllowThreads();
12698         result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
12699
12700         wxPyEndAllowThreads(__tstate);
12701         if (PyErr_Occurred()) SWIG_fail;
12702     }
12703     {
12704         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12705     }
12706     {
12707         if (temp7)
12708         delete arg7;
12709     }
12710     return resultobj;
12711     fail:
12712     {
12713         if (temp7)
12714         delete arg7;
12715     }
12716     return NULL;
12717 }
12718
12719
12720 static PyObject *_wrap_HtmlListBox_RefreshAll(PyObject *, PyObject *args, PyObject *kwargs) {
12721     PyObject *resultobj;
12722     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12723     PyObject * obj0 = 0 ;
12724     char *kwnames[] = {
12725         (char *) "self", NULL
12726     };
12727
12728     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HtmlListBox_RefreshAll",kwnames,&obj0)) goto fail;
12729     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12730     if (SWIG_arg_fail(1)) SWIG_fail;
12731     {
12732         PyThreadState* __tstate = wxPyBeginAllowThreads();
12733         (arg1)->RefreshAll();
12734
12735         wxPyEndAllowThreads(__tstate);
12736         if (PyErr_Occurred()) SWIG_fail;
12737     }
12738     Py_INCREF(Py_None); resultobj = Py_None;
12739     return resultobj;
12740     fail:
12741     return NULL;
12742 }
12743
12744
12745 static PyObject *_wrap_HtmlListBox_SetItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
12746     PyObject *resultobj;
12747     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12748     size_t arg2 ;
12749     PyObject * obj0 = 0 ;
12750     PyObject * obj1 = 0 ;
12751     char *kwnames[] = {
12752         (char *) "self",(char *) "count", NULL
12753     };
12754
12755     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HtmlListBox_SetItemCount",kwnames,&obj0,&obj1)) goto fail;
12756     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12757     if (SWIG_arg_fail(1)) SWIG_fail;
12758     {
12759         arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
12760         if (SWIG_arg_fail(2)) SWIG_fail;
12761     }
12762     {
12763         PyThreadState* __tstate = wxPyBeginAllowThreads();
12764         (arg1)->SetItemCount(arg2);
12765
12766         wxPyEndAllowThreads(__tstate);
12767         if (PyErr_Occurred()) SWIG_fail;
12768     }
12769     Py_INCREF(Py_None); resultobj = Py_None;
12770     return resultobj;
12771     fail:
12772     return NULL;
12773 }
12774
12775
12776 static PyObject *_wrap_HtmlListBox_GetFileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
12777     PyObject *resultobj;
12778     wxPyHtmlListBox *arg1 = (wxPyHtmlListBox *) 0 ;
12779     wxFileSystem *result;
12780     PyObject * obj0 = 0 ;
12781     char *kwnames[] = {
12782         (char *) "self", NULL
12783     };
12784
12785     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HtmlListBox_GetFileSystem",kwnames,&obj0)) goto fail;
12786     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyHtmlListBox, SWIG_POINTER_EXCEPTION | 0);
12787     if (SWIG_arg_fail(1)) SWIG_fail;
12788     {
12789         PyThreadState* __tstate = wxPyBeginAllowThreads();
12790         {
12791             wxFileSystem &_result_ref = (arg1)->GetFileSystem();
12792             result = (wxFileSystem *) &_result_ref;
12793         }
12794
12795         wxPyEndAllowThreads(__tstate);
12796         if (PyErr_Occurred()) SWIG_fail;
12797     }
12798     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileSystem, 0);
12799     return resultobj;
12800     fail:
12801     return NULL;
12802 }
12803
12804
12805 static PyObject * HtmlListBox_swigregister(PyObject *, PyObject *args) {
12806     PyObject *obj;
12807     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12808     SWIG_TypeClientData(SWIGTYPE_p_wxPyHtmlListBox, obj);
12809     Py_INCREF(obj);
12810     return Py_BuildValue((char *)"");
12811 }
12812 static PyObject *_wrap_new_TaskBarIcon(PyObject *, PyObject *args, PyObject *kwargs) {
12813     PyObject *resultobj;
12814     wxPyTaskBarIcon *result;
12815     char *kwnames[] = {
12816         NULL
12817     };
12818
12819     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TaskBarIcon",kwnames)) goto fail;
12820     {
12821         if (!wxPyCheckForApp()) SWIG_fail;
12822         PyThreadState* __tstate = wxPyBeginAllowThreads();
12823         result = (wxPyTaskBarIcon *)new wxPyTaskBarIcon();
12824
12825         wxPyEndAllowThreads(__tstate);
12826         if (PyErr_Occurred()) SWIG_fail;
12827     }
12828     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTaskBarIcon, 1);
12829     return resultobj;
12830     fail:
12831     return NULL;
12832 }
12833
12834
12835 static PyObject *_wrap_TaskBarIcon__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12836     PyObject *resultobj;
12837     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12838     PyObject *arg2 = (PyObject *) 0 ;
12839     PyObject *arg3 = (PyObject *) 0 ;
12840     int arg4 ;
12841     PyObject * obj0 = 0 ;
12842     PyObject * obj1 = 0 ;
12843     PyObject * obj2 = 0 ;
12844     PyObject * obj3 = 0 ;
12845     char *kwnames[] = {
12846         (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
12847     };
12848
12849     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TaskBarIcon__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12850     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12851     if (SWIG_arg_fail(1)) SWIG_fail;
12852     arg2 = obj1;
12853     arg3 = obj2;
12854     {
12855         arg4 = (int)(SWIG_As_int(obj3));
12856         if (SWIG_arg_fail(4)) SWIG_fail;
12857     }
12858     {
12859         PyThreadState* __tstate = wxPyBeginAllowThreads();
12860         (arg1)->_setCallbackInfo(arg2,arg3,arg4);
12861
12862         wxPyEndAllowThreads(__tstate);
12863         if (PyErr_Occurred()) SWIG_fail;
12864     }
12865     Py_INCREF(Py_None); resultobj = Py_None;
12866     return resultobj;
12867     fail:
12868     return NULL;
12869 }
12870
12871
12872 static PyObject *_wrap_TaskBarIcon_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
12873     PyObject *resultobj;
12874     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12875     PyObject * obj0 = 0 ;
12876     char *kwnames[] = {
12877         (char *) "self", NULL
12878     };
12879
12880     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_Destroy",kwnames,&obj0)) goto fail;
12881     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12882     if (SWIG_arg_fail(1)) SWIG_fail;
12883     {
12884         PyThreadState* __tstate = wxPyBeginAllowThreads();
12885         wxPyTaskBarIcon_Destroy(arg1);
12886
12887         wxPyEndAllowThreads(__tstate);
12888         if (PyErr_Occurred()) SWIG_fail;
12889     }
12890     Py_INCREF(Py_None); resultobj = Py_None;
12891     return resultobj;
12892     fail:
12893     return NULL;
12894 }
12895
12896
12897 static PyObject *_wrap_TaskBarIcon_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12898     PyObject *resultobj;
12899     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12900     bool result;
12901     PyObject * obj0 = 0 ;
12902     char *kwnames[] = {
12903         (char *) "self", NULL
12904     };
12905
12906     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_IsOk",kwnames,&obj0)) goto fail;
12907     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12908     if (SWIG_arg_fail(1)) SWIG_fail;
12909     {
12910         PyThreadState* __tstate = wxPyBeginAllowThreads();
12911         result = (bool)((wxPyTaskBarIcon const *)arg1)->IsOk();
12912
12913         wxPyEndAllowThreads(__tstate);
12914         if (PyErr_Occurred()) SWIG_fail;
12915     }
12916     {
12917         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12918     }
12919     return resultobj;
12920     fail:
12921     return NULL;
12922 }
12923
12924
12925 static PyObject *_wrap_TaskBarIcon_IsIconInstalled(PyObject *, PyObject *args, PyObject *kwargs) {
12926     PyObject *resultobj;
12927     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12928     bool result;
12929     PyObject * obj0 = 0 ;
12930     char *kwnames[] = {
12931         (char *) "self", NULL
12932     };
12933
12934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_IsIconInstalled",kwnames,&obj0)) goto fail;
12935     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12936     if (SWIG_arg_fail(1)) SWIG_fail;
12937     {
12938         PyThreadState* __tstate = wxPyBeginAllowThreads();
12939         result = (bool)((wxPyTaskBarIcon const *)arg1)->IsIconInstalled();
12940
12941         wxPyEndAllowThreads(__tstate);
12942         if (PyErr_Occurred()) SWIG_fail;
12943     }
12944     {
12945         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12946     }
12947     return resultobj;
12948     fail:
12949     return NULL;
12950 }
12951
12952
12953 static PyObject *_wrap_TaskBarIcon_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
12954     PyObject *resultobj;
12955     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
12956     wxIcon *arg2 = 0 ;
12957     wxString const &arg3_defvalue = wxPyEmptyString ;
12958     wxString *arg3 = (wxString *) &arg3_defvalue ;
12959     bool result;
12960     bool temp3 = false ;
12961     PyObject * obj0 = 0 ;
12962     PyObject * obj1 = 0 ;
12963     PyObject * obj2 = 0 ;
12964     char *kwnames[] = {
12965         (char *) "self",(char *) "icon",(char *) "tooltip", NULL
12966     };
12967
12968     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TaskBarIcon_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
12969     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
12970     if (SWIG_arg_fail(1)) SWIG_fail;
12971     {
12972         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
12973         if (SWIG_arg_fail(2)) SWIG_fail;
12974         if (arg2 == NULL) {
12975             SWIG_null_ref("wxIcon");
12976         }
12977         if (SWIG_arg_fail(2)) SWIG_fail;
12978     }
12979     if (obj2) {
12980         {
12981             arg3 = wxString_in_helper(obj2);
12982             if (arg3 == NULL) SWIG_fail;
12983             temp3 = true;
12984         }
12985     }
12986     {
12987         PyThreadState* __tstate = wxPyBeginAllowThreads();
12988         result = (bool)(arg1)->SetIcon((wxIcon const &)*arg2,(wxString const &)*arg3);
12989
12990         wxPyEndAllowThreads(__tstate);
12991         if (PyErr_Occurred()) SWIG_fail;
12992     }
12993     {
12994         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12995     }
12996     {
12997         if (temp3)
12998         delete arg3;
12999     }
13000     return resultobj;
13001     fail:
13002     {
13003         if (temp3)
13004         delete arg3;
13005     }
13006     return NULL;
13007 }
13008
13009
13010 static PyObject *_wrap_TaskBarIcon_RemoveIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13011     PyObject *resultobj;
13012     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13013     bool result;
13014     PyObject * obj0 = 0 ;
13015     char *kwnames[] = {
13016         (char *) "self", NULL
13017     };
13018
13019     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TaskBarIcon_RemoveIcon",kwnames,&obj0)) goto fail;
13020     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13021     if (SWIG_arg_fail(1)) SWIG_fail;
13022     {
13023         PyThreadState* __tstate = wxPyBeginAllowThreads();
13024         result = (bool)(arg1)->RemoveIcon();
13025
13026         wxPyEndAllowThreads(__tstate);
13027         if (PyErr_Occurred()) SWIG_fail;
13028     }
13029     {
13030         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13031     }
13032     return resultobj;
13033     fail:
13034     return NULL;
13035 }
13036
13037
13038 static PyObject *_wrap_TaskBarIcon_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
13039     PyObject *resultobj;
13040     wxPyTaskBarIcon *arg1 = (wxPyTaskBarIcon *) 0 ;
13041     wxMenu *arg2 = (wxMenu *) 0 ;
13042     bool result;
13043     PyObject * obj0 = 0 ;
13044     PyObject * obj1 = 0 ;
13045     char *kwnames[] = {
13046         (char *) "self",(char *) "menu", NULL
13047     };
13048
13049     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TaskBarIcon_PopupMenu",kwnames,&obj0,&obj1)) goto fail;
13050     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13051     if (SWIG_arg_fail(1)) SWIG_fail;
13052     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
13053     if (SWIG_arg_fail(2)) SWIG_fail;
13054     {
13055         PyThreadState* __tstate = wxPyBeginAllowThreads();
13056         result = (bool)(arg1)->PopupMenu(arg2);
13057
13058         wxPyEndAllowThreads(__tstate);
13059         if (PyErr_Occurred()) SWIG_fail;
13060     }
13061     {
13062         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13063     }
13064     return resultobj;
13065     fail:
13066     return NULL;
13067 }
13068
13069
13070 static PyObject * TaskBarIcon_swigregister(PyObject *, PyObject *args) {
13071     PyObject *obj;
13072     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13073     SWIG_TypeClientData(SWIGTYPE_p_wxPyTaskBarIcon, obj);
13074     Py_INCREF(obj);
13075     return Py_BuildValue((char *)"");
13076 }
13077 static PyObject *_wrap_new_TaskBarIconEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13078     PyObject *resultobj;
13079     wxEventType arg1 ;
13080     wxTaskBarIcon *arg2 = (wxTaskBarIcon *) 0 ;
13081     wxTaskBarIconEvent *result;
13082     PyObject * obj0 = 0 ;
13083     PyObject * obj1 = 0 ;
13084     char *kwnames[] = {
13085         (char *) "evtType",(char *) "tbIcon", NULL
13086     };
13087
13088     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_TaskBarIconEvent",kwnames,&obj0,&obj1)) goto fail;
13089     {
13090         arg1 = (wxEventType)(SWIG_As_int(obj0));
13091         if (SWIG_arg_fail(1)) SWIG_fail;
13092     }
13093     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTaskBarIcon, SWIG_POINTER_EXCEPTION | 0);
13094     if (SWIG_arg_fail(2)) SWIG_fail;
13095     {
13096         PyThreadState* __tstate = wxPyBeginAllowThreads();
13097         result = (wxTaskBarIconEvent *)new wxTaskBarIconEvent(arg1,arg2);
13098
13099         wxPyEndAllowThreads(__tstate);
13100         if (PyErr_Occurred()) SWIG_fail;
13101     }
13102     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTaskBarIconEvent, 1);
13103     return resultobj;
13104     fail:
13105     return NULL;
13106 }
13107
13108
13109 static PyObject * TaskBarIconEvent_swigregister(PyObject *, PyObject *args) {
13110     PyObject *obj;
13111     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13112     SWIG_TypeClientData(SWIGTYPE_p_wxTaskBarIconEvent, obj);
13113     Py_INCREF(obj);
13114     return Py_BuildValue((char *)"");
13115 }
13116 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
13117     PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
13118     return 1;
13119 }
13120
13121
13122 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
13123     PyObject *pyobj;
13124
13125     {
13126 #if wxUSE_UNICODE
13127         pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
13128 #else
13129         pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
13130 #endif
13131     }
13132     return pyobj;
13133 }
13134
13135
13136 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
13137     PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
13138     return 1;
13139 }
13140
13141
13142 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
13143     PyObject *pyobj;
13144
13145     {
13146 #if wxUSE_UNICODE
13147         pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
13148 #else
13149         pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
13150 #endif
13151     }
13152     return pyobj;
13153 }
13154
13155
13156 static int _wrap_DirDialogNameStr_set(PyObject *) {
13157     PyErr_SetString(PyExc_TypeError,"Variable DirDialogNameStr is read-only.");
13158     return 1;
13159 }
13160
13161
13162 static PyObject *_wrap_DirDialogNameStr_get(void) {
13163     PyObject *pyobj;
13164
13165     {
13166 #if wxUSE_UNICODE
13167         pyobj = PyUnicode_FromWideChar((&wxPyDirDialogNameStr)->c_str(), (&wxPyDirDialogNameStr)->Len());
13168 #else
13169         pyobj = PyString_FromStringAndSize((&wxPyDirDialogNameStr)->c_str(), (&wxPyDirDialogNameStr)->Len());
13170 #endif
13171     }
13172     return pyobj;
13173 }
13174
13175
13176 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
13177     PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
13178     return 1;
13179 }
13180
13181
13182 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
13183     PyObject *pyobj;
13184
13185     {
13186 #if wxUSE_UNICODE
13187         pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
13188 #else
13189         pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
13190 #endif
13191     }
13192     return pyobj;
13193 }
13194
13195
13196 static int _wrap_GetTextFromUserPromptStr_set(PyObject *) {
13197     PyErr_SetString(PyExc_TypeError,"Variable GetTextFromUserPromptStr is read-only.");
13198     return 1;
13199 }
13200
13201
13202 static PyObject *_wrap_GetTextFromUserPromptStr_get(void) {
13203     PyObject *pyobj;
13204
13205     {
13206 #if wxUSE_UNICODE
13207         pyobj = PyUnicode_FromWideChar((&wxPyGetTextFromUserPromptStr)->c_str(), (&wxPyGetTextFromUserPromptStr)->Len());
13208 #else
13209         pyobj = PyString_FromStringAndSize((&wxPyGetTextFromUserPromptStr)->c_str(), (&wxPyGetTextFromUserPromptStr)->Len());
13210 #endif
13211     }
13212     return pyobj;
13213 }
13214
13215
13216 static int _wrap_MessageBoxCaptionStr_set(PyObject *) {
13217     PyErr_SetString(PyExc_TypeError,"Variable MessageBoxCaptionStr is read-only.");
13218     return 1;
13219 }
13220
13221
13222 static PyObject *_wrap_MessageBoxCaptionStr_get(void) {
13223     PyObject *pyobj;
13224
13225     {
13226 #if wxUSE_UNICODE
13227         pyobj = PyUnicode_FromWideChar((&wxPyMessageBoxCaptionStr)->c_str(), (&wxPyMessageBoxCaptionStr)->Len());
13228 #else
13229         pyobj = PyString_FromStringAndSize((&wxPyMessageBoxCaptionStr)->c_str(), (&wxPyMessageBoxCaptionStr)->Len());
13230 #endif
13231     }
13232     return pyobj;
13233 }
13234
13235
13236 static PyObject *_wrap_new_ColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13237     PyObject *resultobj;
13238     wxColourData *result;
13239     char *kwnames[] = {
13240         NULL
13241     };
13242
13243     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourData",kwnames)) goto fail;
13244     {
13245         PyThreadState* __tstate = wxPyBeginAllowThreads();
13246         result = (wxColourData *)new wxColourData();
13247
13248         wxPyEndAllowThreads(__tstate);
13249         if (PyErr_Occurred()) SWIG_fail;
13250     }
13251     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourData, 1);
13252     return resultobj;
13253     fail:
13254     return NULL;
13255 }
13256
13257
13258 static PyObject *_wrap_delete_ColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13259     PyObject *resultobj;
13260     wxColourData *arg1 = (wxColourData *) 0 ;
13261     PyObject * obj0 = 0 ;
13262     char *kwnames[] = {
13263         (char *) "self", NULL
13264     };
13265
13266     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourData",kwnames,&obj0)) goto fail;
13267     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13268     if (SWIG_arg_fail(1)) SWIG_fail;
13269     {
13270         PyThreadState* __tstate = wxPyBeginAllowThreads();
13271         delete arg1;
13272
13273         wxPyEndAllowThreads(__tstate);
13274         if (PyErr_Occurred()) SWIG_fail;
13275     }
13276     Py_INCREF(Py_None); resultobj = Py_None;
13277     return resultobj;
13278     fail:
13279     return NULL;
13280 }
13281
13282
13283 static PyObject *_wrap_ColourData_GetChooseFull(PyObject *, PyObject *args, PyObject *kwargs) {
13284     PyObject *resultobj;
13285     wxColourData *arg1 = (wxColourData *) 0 ;
13286     bool result;
13287     PyObject * obj0 = 0 ;
13288     char *kwnames[] = {
13289         (char *) "self", NULL
13290     };
13291
13292     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourData_GetChooseFull",kwnames,&obj0)) goto fail;
13293     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13294     if (SWIG_arg_fail(1)) SWIG_fail;
13295     {
13296         PyThreadState* __tstate = wxPyBeginAllowThreads();
13297         result = (bool)(arg1)->GetChooseFull();
13298
13299         wxPyEndAllowThreads(__tstate);
13300         if (PyErr_Occurred()) SWIG_fail;
13301     }
13302     {
13303         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13304     }
13305     return resultobj;
13306     fail:
13307     return NULL;
13308 }
13309
13310
13311 static PyObject *_wrap_ColourData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
13312     PyObject *resultobj;
13313     wxColourData *arg1 = (wxColourData *) 0 ;
13314     wxColour result;
13315     PyObject * obj0 = 0 ;
13316     char *kwnames[] = {
13317         (char *) "self", NULL
13318     };
13319
13320     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourData_GetColour",kwnames,&obj0)) goto fail;
13321     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13322     if (SWIG_arg_fail(1)) SWIG_fail;
13323     {
13324         PyThreadState* __tstate = wxPyBeginAllowThreads();
13325         result = (arg1)->GetColour();
13326
13327         wxPyEndAllowThreads(__tstate);
13328         if (PyErr_Occurred()) SWIG_fail;
13329     }
13330     {
13331         wxColour * resultptr;
13332         resultptr = new wxColour((wxColour &)(result));
13333         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13334     }
13335     return resultobj;
13336     fail:
13337     return NULL;
13338 }
13339
13340
13341 static PyObject *_wrap_ColourData_GetCustomColour(PyObject *, PyObject *args, PyObject *kwargs) {
13342     PyObject *resultobj;
13343     wxColourData *arg1 = (wxColourData *) 0 ;
13344     int arg2 ;
13345     wxColour result;
13346     PyObject * obj0 = 0 ;
13347     PyObject * obj1 = 0 ;
13348     char *kwnames[] = {
13349         (char *) "self",(char *) "i", NULL
13350     };
13351
13352     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_GetCustomColour",kwnames,&obj0,&obj1)) goto fail;
13353     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13354     if (SWIG_arg_fail(1)) SWIG_fail;
13355     {
13356         arg2 = (int)(SWIG_As_int(obj1));
13357         if (SWIG_arg_fail(2)) SWIG_fail;
13358     }
13359     {
13360         PyThreadState* __tstate = wxPyBeginAllowThreads();
13361         result = (arg1)->GetCustomColour(arg2);
13362
13363         wxPyEndAllowThreads(__tstate);
13364         if (PyErr_Occurred()) SWIG_fail;
13365     }
13366     {
13367         wxColour * resultptr;
13368         resultptr = new wxColour((wxColour &)(result));
13369         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13370     }
13371     return resultobj;
13372     fail:
13373     return NULL;
13374 }
13375
13376
13377 static PyObject *_wrap_ColourData_SetChooseFull(PyObject *, PyObject *args, PyObject *kwargs) {
13378     PyObject *resultobj;
13379     wxColourData *arg1 = (wxColourData *) 0 ;
13380     int arg2 ;
13381     PyObject * obj0 = 0 ;
13382     PyObject * obj1 = 0 ;
13383     char *kwnames[] = {
13384         (char *) "self",(char *) "flag", NULL
13385     };
13386
13387     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_SetChooseFull",kwnames,&obj0,&obj1)) goto fail;
13388     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13389     if (SWIG_arg_fail(1)) SWIG_fail;
13390     {
13391         arg2 = (int)(SWIG_As_int(obj1));
13392         if (SWIG_arg_fail(2)) SWIG_fail;
13393     }
13394     {
13395         PyThreadState* __tstate = wxPyBeginAllowThreads();
13396         (arg1)->SetChooseFull(arg2);
13397
13398         wxPyEndAllowThreads(__tstate);
13399         if (PyErr_Occurred()) SWIG_fail;
13400     }
13401     Py_INCREF(Py_None); resultobj = Py_None;
13402     return resultobj;
13403     fail:
13404     return NULL;
13405 }
13406
13407
13408 static PyObject *_wrap_ColourData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
13409     PyObject *resultobj;
13410     wxColourData *arg1 = (wxColourData *) 0 ;
13411     wxColour *arg2 = 0 ;
13412     wxColour temp2 ;
13413     PyObject * obj0 = 0 ;
13414     PyObject * obj1 = 0 ;
13415     char *kwnames[] = {
13416         (char *) "self",(char *) "colour", NULL
13417     };
13418
13419     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourData_SetColour",kwnames,&obj0,&obj1)) goto fail;
13420     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13421     if (SWIG_arg_fail(1)) SWIG_fail;
13422     {
13423         arg2 = &temp2;
13424         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13425     }
13426     {
13427         PyThreadState* __tstate = wxPyBeginAllowThreads();
13428         (arg1)->SetColour((wxColour const &)*arg2);
13429
13430         wxPyEndAllowThreads(__tstate);
13431         if (PyErr_Occurred()) SWIG_fail;
13432     }
13433     Py_INCREF(Py_None); resultobj = Py_None;
13434     return resultobj;
13435     fail:
13436     return NULL;
13437 }
13438
13439
13440 static PyObject *_wrap_ColourData_SetCustomColour(PyObject *, PyObject *args, PyObject *kwargs) {
13441     PyObject *resultobj;
13442     wxColourData *arg1 = (wxColourData *) 0 ;
13443     int arg2 ;
13444     wxColour *arg3 = 0 ;
13445     wxColour temp3 ;
13446     PyObject * obj0 = 0 ;
13447     PyObject * obj1 = 0 ;
13448     PyObject * obj2 = 0 ;
13449     char *kwnames[] = {
13450         (char *) "self",(char *) "i",(char *) "colour", NULL
13451     };
13452
13453     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourData_SetCustomColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13454     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13455     if (SWIG_arg_fail(1)) SWIG_fail;
13456     {
13457         arg2 = (int)(SWIG_As_int(obj1));
13458         if (SWIG_arg_fail(2)) SWIG_fail;
13459     }
13460     {
13461         arg3 = &temp3;
13462         if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13463     }
13464     {
13465         PyThreadState* __tstate = wxPyBeginAllowThreads();
13466         (arg1)->SetCustomColour(arg2,(wxColour const &)*arg3);
13467
13468         wxPyEndAllowThreads(__tstate);
13469         if (PyErr_Occurred()) SWIG_fail;
13470     }
13471     Py_INCREF(Py_None); resultobj = Py_None;
13472     return resultobj;
13473     fail:
13474     return NULL;
13475 }
13476
13477
13478 static PyObject * ColourData_swigregister(PyObject *, PyObject *args) {
13479     PyObject *obj;
13480     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13481     SWIG_TypeClientData(SWIGTYPE_p_wxColourData, obj);
13482     Py_INCREF(obj);
13483     return Py_BuildValue((char *)"");
13484 }
13485 static PyObject *_wrap_new_ColourDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13486     PyObject *resultobj;
13487     wxWindow *arg1 = (wxWindow *) 0 ;
13488     wxColourData *arg2 = (wxColourData *) NULL ;
13489     wxColourDialog *result;
13490     PyObject * obj0 = 0 ;
13491     PyObject * obj1 = 0 ;
13492     char *kwnames[] = {
13493         (char *) "parent",(char *) "data", NULL
13494     };
13495
13496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_ColourDialog",kwnames,&obj0,&obj1)) goto fail;
13497     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13498     if (SWIG_arg_fail(1)) SWIG_fail;
13499     if (obj1) {
13500         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColourData, SWIG_POINTER_EXCEPTION | 0);
13501         if (SWIG_arg_fail(2)) SWIG_fail;
13502     }
13503     {
13504         if (!wxPyCheckForApp()) SWIG_fail;
13505         PyThreadState* __tstate = wxPyBeginAllowThreads();
13506         result = (wxColourDialog *)new wxColourDialog(arg1,arg2);
13507
13508         wxPyEndAllowThreads(__tstate);
13509         if (PyErr_Occurred()) SWIG_fail;
13510     }
13511     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDialog, 1);
13512     return resultobj;
13513     fail:
13514     return NULL;
13515 }
13516
13517
13518 static PyObject *_wrap_ColourDialog_GetColourData(PyObject *, PyObject *args, PyObject *kwargs) {
13519     PyObject *resultobj;
13520     wxColourDialog *arg1 = (wxColourDialog *) 0 ;
13521     wxColourData *result;
13522     PyObject * obj0 = 0 ;
13523     char *kwnames[] = {
13524         (char *) "self", NULL
13525     };
13526
13527     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ColourDialog_GetColourData",kwnames,&obj0)) goto fail;
13528     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDialog, SWIG_POINTER_EXCEPTION | 0);
13529     if (SWIG_arg_fail(1)) SWIG_fail;
13530     {
13531         PyThreadState* __tstate = wxPyBeginAllowThreads();
13532         {
13533             wxColourData &_result_ref = (arg1)->GetColourData();
13534             result = (wxColourData *) &_result_ref;
13535         }
13536
13537         wxPyEndAllowThreads(__tstate);
13538         if (PyErr_Occurred()) SWIG_fail;
13539     }
13540     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourData, 0);
13541     return resultobj;
13542     fail:
13543     return NULL;
13544 }
13545
13546
13547 static PyObject * ColourDialog_swigregister(PyObject *, PyObject *args) {
13548     PyObject *obj;
13549     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13550     SWIG_TypeClientData(SWIGTYPE_p_wxColourDialog, obj);
13551     Py_INCREF(obj);
13552     return Py_BuildValue((char *)"");
13553 }
13554 static PyObject *_wrap_new_DirDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13555     PyObject *resultobj;
13556     wxWindow *arg1 = (wxWindow *) 0 ;
13557     wxString const &arg2_defvalue = wxPyDirSelectorPromptStr ;
13558     wxString *arg2 = (wxString *) &arg2_defvalue ;
13559     wxString const &arg3_defvalue = wxPyEmptyString ;
13560     wxString *arg3 = (wxString *) &arg3_defvalue ;
13561     long arg4 = (long) 0 ;
13562     wxPoint const &arg5_defvalue = wxDefaultPosition ;
13563     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
13564     wxSize const &arg6_defvalue = wxDefaultSize ;
13565     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
13566     wxString const &arg7_defvalue = wxPyDirDialogNameStr ;
13567     wxString *arg7 = (wxString *) &arg7_defvalue ;
13568     wxDirDialog *result;
13569     bool temp2 = false ;
13570     bool temp3 = false ;
13571     wxPoint temp5 ;
13572     wxSize temp6 ;
13573     bool temp7 = false ;
13574     PyObject * obj0 = 0 ;
13575     PyObject * obj1 = 0 ;
13576     PyObject * obj2 = 0 ;
13577     PyObject * obj3 = 0 ;
13578     PyObject * obj4 = 0 ;
13579     PyObject * obj5 = 0 ;
13580     PyObject * obj6 = 0 ;
13581     char *kwnames[] = {
13582         (char *) "parent",(char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "size",(char *) "name", NULL
13583     };
13584
13585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DirDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13586     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13587     if (SWIG_arg_fail(1)) SWIG_fail;
13588     if (obj1) {
13589         {
13590             arg2 = wxString_in_helper(obj1);
13591             if (arg2 == NULL) SWIG_fail;
13592             temp2 = true;
13593         }
13594     }
13595     if (obj2) {
13596         {
13597             arg3 = wxString_in_helper(obj2);
13598             if (arg3 == NULL) SWIG_fail;
13599             temp3 = true;
13600         }
13601     }
13602     if (obj3) {
13603         {
13604             arg4 = (long)(SWIG_As_long(obj3));
13605             if (SWIG_arg_fail(4)) SWIG_fail;
13606         }
13607     }
13608     if (obj4) {
13609         {
13610             arg5 = &temp5;
13611             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13612         }
13613     }
13614     if (obj5) {
13615         {
13616             arg6 = &temp6;
13617             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
13618         }
13619     }
13620     if (obj6) {
13621         {
13622             arg7 = wxString_in_helper(obj6);
13623             if (arg7 == NULL) SWIG_fail;
13624             temp7 = true;
13625         }
13626     }
13627     {
13628         if (!wxPyCheckForApp()) SWIG_fail;
13629         PyThreadState* __tstate = wxPyBeginAllowThreads();
13630         result = (wxDirDialog *)new wxDirDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,(wxString const &)*arg7);
13631
13632         wxPyEndAllowThreads(__tstate);
13633         if (PyErr_Occurred()) SWIG_fail;
13634     }
13635     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDirDialog, 1);
13636     {
13637         if (temp2)
13638         delete arg2;
13639     }
13640     {
13641         if (temp3)
13642         delete arg3;
13643     }
13644     {
13645         if (temp7)
13646         delete arg7;
13647     }
13648     return resultobj;
13649     fail:
13650     {
13651         if (temp2)
13652         delete arg2;
13653     }
13654     {
13655         if (temp3)
13656         delete arg3;
13657     }
13658     {
13659         if (temp7)
13660         delete arg7;
13661     }
13662     return NULL;
13663 }
13664
13665
13666 static PyObject *_wrap_DirDialog_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
13667     PyObject *resultobj;
13668     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13669     wxString result;
13670     PyObject * obj0 = 0 ;
13671     char *kwnames[] = {
13672         (char *) "self", NULL
13673     };
13674
13675     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetPath",kwnames,&obj0)) goto fail;
13676     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13677     if (SWIG_arg_fail(1)) SWIG_fail;
13678     {
13679         PyThreadState* __tstate = wxPyBeginAllowThreads();
13680         result = (arg1)->GetPath();
13681
13682         wxPyEndAllowThreads(__tstate);
13683         if (PyErr_Occurred()) SWIG_fail;
13684     }
13685     {
13686 #if wxUSE_UNICODE
13687         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13688 #else
13689         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13690 #endif
13691     }
13692     return resultobj;
13693     fail:
13694     return NULL;
13695 }
13696
13697
13698 static PyObject *_wrap_DirDialog_GetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
13699     PyObject *resultobj;
13700     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13701     wxString result;
13702     PyObject * obj0 = 0 ;
13703     char *kwnames[] = {
13704         (char *) "self", NULL
13705     };
13706
13707     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetMessage",kwnames,&obj0)) goto fail;
13708     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13709     if (SWIG_arg_fail(1)) SWIG_fail;
13710     {
13711         PyThreadState* __tstate = wxPyBeginAllowThreads();
13712         result = (arg1)->GetMessage();
13713
13714         wxPyEndAllowThreads(__tstate);
13715         if (PyErr_Occurred()) SWIG_fail;
13716     }
13717     {
13718 #if wxUSE_UNICODE
13719         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13720 #else
13721         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13722 #endif
13723     }
13724     return resultobj;
13725     fail:
13726     return NULL;
13727 }
13728
13729
13730 static PyObject *_wrap_DirDialog_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
13731     PyObject *resultobj;
13732     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13733     long result;
13734     PyObject * obj0 = 0 ;
13735     char *kwnames[] = {
13736         (char *) "self", NULL
13737     };
13738
13739     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DirDialog_GetStyle",kwnames,&obj0)) goto fail;
13740     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13741     if (SWIG_arg_fail(1)) SWIG_fail;
13742     {
13743         PyThreadState* __tstate = wxPyBeginAllowThreads();
13744         result = (long)(arg1)->GetStyle();
13745
13746         wxPyEndAllowThreads(__tstate);
13747         if (PyErr_Occurred()) SWIG_fail;
13748     }
13749     {
13750         resultobj = SWIG_From_long((long)(result));
13751     }
13752     return resultobj;
13753     fail:
13754     return NULL;
13755 }
13756
13757
13758 static PyObject *_wrap_DirDialog_SetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
13759     PyObject *resultobj;
13760     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13761     wxString *arg2 = 0 ;
13762     bool temp2 = false ;
13763     PyObject * obj0 = 0 ;
13764     PyObject * obj1 = 0 ;
13765     char *kwnames[] = {
13766         (char *) "self",(char *) "message", NULL
13767     };
13768
13769     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirDialog_SetMessage",kwnames,&obj0,&obj1)) goto fail;
13770     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13771     if (SWIG_arg_fail(1)) SWIG_fail;
13772     {
13773         arg2 = wxString_in_helper(obj1);
13774         if (arg2 == NULL) SWIG_fail;
13775         temp2 = true;
13776     }
13777     {
13778         PyThreadState* __tstate = wxPyBeginAllowThreads();
13779         (arg1)->SetMessage((wxString const &)*arg2);
13780
13781         wxPyEndAllowThreads(__tstate);
13782         if (PyErr_Occurred()) SWIG_fail;
13783     }
13784     Py_INCREF(Py_None); resultobj = Py_None;
13785     {
13786         if (temp2)
13787         delete arg2;
13788     }
13789     return resultobj;
13790     fail:
13791     {
13792         if (temp2)
13793         delete arg2;
13794     }
13795     return NULL;
13796 }
13797
13798
13799 static PyObject *_wrap_DirDialog_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
13800     PyObject *resultobj;
13801     wxDirDialog *arg1 = (wxDirDialog *) 0 ;
13802     wxString *arg2 = 0 ;
13803     bool temp2 = false ;
13804     PyObject * obj0 = 0 ;
13805     PyObject * obj1 = 0 ;
13806     char *kwnames[] = {
13807         (char *) "self",(char *) "path", NULL
13808     };
13809
13810     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirDialog_SetPath",kwnames,&obj0,&obj1)) goto fail;
13811     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDirDialog, SWIG_POINTER_EXCEPTION | 0);
13812     if (SWIG_arg_fail(1)) SWIG_fail;
13813     {
13814         arg2 = wxString_in_helper(obj1);
13815         if (arg2 == NULL) SWIG_fail;
13816         temp2 = true;
13817     }
13818     {
13819         PyThreadState* __tstate = wxPyBeginAllowThreads();
13820         (arg1)->SetPath((wxString const &)*arg2);
13821
13822         wxPyEndAllowThreads(__tstate);
13823         if (PyErr_Occurred()) SWIG_fail;
13824     }
13825     Py_INCREF(Py_None); resultobj = Py_None;
13826     {
13827         if (temp2)
13828         delete arg2;
13829     }
13830     return resultobj;
13831     fail:
13832     {
13833         if (temp2)
13834         delete arg2;
13835     }
13836     return NULL;
13837 }
13838
13839
13840 static PyObject * DirDialog_swigregister(PyObject *, PyObject *args) {
13841     PyObject *obj;
13842     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13843     SWIG_TypeClientData(SWIGTYPE_p_wxDirDialog, obj);
13844     Py_INCREF(obj);
13845     return Py_BuildValue((char *)"");
13846 }
13847 static PyObject *_wrap_new_FileDialog(PyObject *, PyObject *args, PyObject *kwargs) {
13848     PyObject *resultobj;
13849     wxWindow *arg1 = (wxWindow *) 0 ;
13850     wxString const &arg2_defvalue = wxPyFileSelectorPromptStr ;
13851     wxString *arg2 = (wxString *) &arg2_defvalue ;
13852     wxString const &arg3_defvalue = wxPyEmptyString ;
13853     wxString *arg3 = (wxString *) &arg3_defvalue ;
13854     wxString const &arg4_defvalue = wxPyEmptyString ;
13855     wxString *arg4 = (wxString *) &arg4_defvalue ;
13856     wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
13857     wxString *arg5 = (wxString *) &arg5_defvalue ;
13858     long arg6 = (long) 0 ;
13859     wxPoint const &arg7_defvalue = wxDefaultPosition ;
13860     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
13861     wxFileDialog *result;
13862     bool temp2 = false ;
13863     bool temp3 = false ;
13864     bool temp4 = false ;
13865     bool temp5 = false ;
13866     wxPoint temp7 ;
13867     PyObject * obj0 = 0 ;
13868     PyObject * obj1 = 0 ;
13869     PyObject * obj2 = 0 ;
13870     PyObject * obj3 = 0 ;
13871     PyObject * obj4 = 0 ;
13872     PyObject * obj5 = 0 ;
13873     PyObject * obj6 = 0 ;
13874     char *kwnames[] = {
13875         (char *) "parent",(char *) "message",(char *) "defaultDir",(char *) "defaultFile",(char *) "wildcard",(char *) "style",(char *) "pos", NULL
13876     };
13877
13878     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_FileDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13879     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13880     if (SWIG_arg_fail(1)) SWIG_fail;
13881     if (obj1) {
13882         {
13883             arg2 = wxString_in_helper(obj1);
13884             if (arg2 == NULL) SWIG_fail;
13885             temp2 = true;
13886         }
13887     }
13888     if (obj2) {
13889         {
13890             arg3 = wxString_in_helper(obj2);
13891             if (arg3 == NULL) SWIG_fail;
13892             temp3 = true;
13893         }
13894     }
13895     if (obj3) {
13896         {
13897             arg4 = wxString_in_helper(obj3);
13898             if (arg4 == NULL) SWIG_fail;
13899             temp4 = true;
13900         }
13901     }
13902     if (obj4) {
13903         {
13904             arg5 = wxString_in_helper(obj4);
13905             if (arg5 == NULL) SWIG_fail;
13906             temp5 = true;
13907         }
13908     }
13909     if (obj5) {
13910         {
13911             arg6 = (long)(SWIG_As_long(obj5));
13912             if (SWIG_arg_fail(6)) SWIG_fail;
13913         }
13914     }
13915     if (obj6) {
13916         {
13917             arg7 = &temp7;
13918             if ( ! wxPoint_helper(obj6, &arg7)) SWIG_fail;
13919         }
13920     }
13921     {
13922         if (!wxPyCheckForApp()) SWIG_fail;
13923         PyThreadState* __tstate = wxPyBeginAllowThreads();
13924         result = (wxFileDialog *)new wxFileDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,(wxPoint const &)*arg7);
13925
13926         wxPyEndAllowThreads(__tstate);
13927         if (PyErr_Occurred()) SWIG_fail;
13928     }
13929     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDialog, 1);
13930     {
13931         if (temp2)
13932         delete arg2;
13933     }
13934     {
13935         if (temp3)
13936         delete arg3;
13937     }
13938     {
13939         if (temp4)
13940         delete arg4;
13941     }
13942     {
13943         if (temp5)
13944         delete arg5;
13945     }
13946     return resultobj;
13947     fail:
13948     {
13949         if (temp2)
13950         delete arg2;
13951     }
13952     {
13953         if (temp3)
13954         delete arg3;
13955     }
13956     {
13957         if (temp4)
13958         delete arg4;
13959     }
13960     {
13961         if (temp5)
13962         delete arg5;
13963     }
13964     return NULL;
13965 }
13966
13967
13968 static PyObject *_wrap_FileDialog_SetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
13969     PyObject *resultobj;
13970     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
13971     wxString *arg2 = 0 ;
13972     bool temp2 = false ;
13973     PyObject * obj0 = 0 ;
13974     PyObject * obj1 = 0 ;
13975     char *kwnames[] = {
13976         (char *) "self",(char *) "message", NULL
13977     };
13978
13979     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetMessage",kwnames,&obj0,&obj1)) goto fail;
13980     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
13981     if (SWIG_arg_fail(1)) SWIG_fail;
13982     {
13983         arg2 = wxString_in_helper(obj1);
13984         if (arg2 == NULL) SWIG_fail;
13985         temp2 = true;
13986     }
13987     {
13988         PyThreadState* __tstate = wxPyBeginAllowThreads();
13989         (arg1)->SetMessage((wxString const &)*arg2);
13990
13991         wxPyEndAllowThreads(__tstate);
13992         if (PyErr_Occurred()) SWIG_fail;
13993     }
13994     Py_INCREF(Py_None); resultobj = Py_None;
13995     {
13996         if (temp2)
13997         delete arg2;
13998     }
13999     return resultobj;
14000     fail:
14001     {
14002         if (temp2)
14003         delete arg2;
14004     }
14005     return NULL;
14006 }
14007
14008
14009 static PyObject *_wrap_FileDialog_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
14010     PyObject *resultobj;
14011     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14012     wxString *arg2 = 0 ;
14013     bool temp2 = false ;
14014     PyObject * obj0 = 0 ;
14015     PyObject * obj1 = 0 ;
14016     char *kwnames[] = {
14017         (char *) "self",(char *) "path", NULL
14018     };
14019
14020     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetPath",kwnames,&obj0,&obj1)) goto fail;
14021     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14022     if (SWIG_arg_fail(1)) SWIG_fail;
14023     {
14024         arg2 = wxString_in_helper(obj1);
14025         if (arg2 == NULL) SWIG_fail;
14026         temp2 = true;
14027     }
14028     {
14029         PyThreadState* __tstate = wxPyBeginAllowThreads();
14030         (arg1)->SetPath((wxString const &)*arg2);
14031
14032         wxPyEndAllowThreads(__tstate);
14033         if (PyErr_Occurred()) SWIG_fail;
14034     }
14035     Py_INCREF(Py_None); resultobj = Py_None;
14036     {
14037         if (temp2)
14038         delete arg2;
14039     }
14040     return resultobj;
14041     fail:
14042     {
14043         if (temp2)
14044         delete arg2;
14045     }
14046     return NULL;
14047 }
14048
14049
14050 static PyObject *_wrap_FileDialog_SetDirectory(PyObject *, PyObject *args, PyObject *kwargs) {
14051     PyObject *resultobj;
14052     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14053     wxString *arg2 = 0 ;
14054     bool temp2 = false ;
14055     PyObject * obj0 = 0 ;
14056     PyObject * obj1 = 0 ;
14057     char *kwnames[] = {
14058         (char *) "self",(char *) "dir", NULL
14059     };
14060
14061     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetDirectory",kwnames,&obj0,&obj1)) goto fail;
14062     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14063     if (SWIG_arg_fail(1)) SWIG_fail;
14064     {
14065         arg2 = wxString_in_helper(obj1);
14066         if (arg2 == NULL) SWIG_fail;
14067         temp2 = true;
14068     }
14069     {
14070         PyThreadState* __tstate = wxPyBeginAllowThreads();
14071         (arg1)->SetDirectory((wxString const &)*arg2);
14072
14073         wxPyEndAllowThreads(__tstate);
14074         if (PyErr_Occurred()) SWIG_fail;
14075     }
14076     Py_INCREF(Py_None); resultobj = Py_None;
14077     {
14078         if (temp2)
14079         delete arg2;
14080     }
14081     return resultobj;
14082     fail:
14083     {
14084         if (temp2)
14085         delete arg2;
14086     }
14087     return NULL;
14088 }
14089
14090
14091 static PyObject *_wrap_FileDialog_SetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
14092     PyObject *resultobj;
14093     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14094     wxString *arg2 = 0 ;
14095     bool temp2 = false ;
14096     PyObject * obj0 = 0 ;
14097     PyObject * obj1 = 0 ;
14098     char *kwnames[] = {
14099         (char *) "self",(char *) "name", NULL
14100     };
14101
14102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetFilename",kwnames,&obj0,&obj1)) goto fail;
14103     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14104     if (SWIG_arg_fail(1)) SWIG_fail;
14105     {
14106         arg2 = wxString_in_helper(obj1);
14107         if (arg2 == NULL) SWIG_fail;
14108         temp2 = true;
14109     }
14110     {
14111         PyThreadState* __tstate = wxPyBeginAllowThreads();
14112         (arg1)->SetFilename((wxString const &)*arg2);
14113
14114         wxPyEndAllowThreads(__tstate);
14115         if (PyErr_Occurred()) SWIG_fail;
14116     }
14117     Py_INCREF(Py_None); resultobj = Py_None;
14118     {
14119         if (temp2)
14120         delete arg2;
14121     }
14122     return resultobj;
14123     fail:
14124     {
14125         if (temp2)
14126         delete arg2;
14127     }
14128     return NULL;
14129 }
14130
14131
14132 static PyObject *_wrap_FileDialog_SetWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14133     PyObject *resultobj;
14134     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14135     wxString *arg2 = 0 ;
14136     bool temp2 = false ;
14137     PyObject * obj0 = 0 ;
14138     PyObject * obj1 = 0 ;
14139     char *kwnames[] = {
14140         (char *) "self",(char *) "wildCard", NULL
14141     };
14142
14143     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetWildcard",kwnames,&obj0,&obj1)) goto fail;
14144     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14145     if (SWIG_arg_fail(1)) SWIG_fail;
14146     {
14147         arg2 = wxString_in_helper(obj1);
14148         if (arg2 == NULL) SWIG_fail;
14149         temp2 = true;
14150     }
14151     {
14152         PyThreadState* __tstate = wxPyBeginAllowThreads();
14153         (arg1)->SetWildcard((wxString const &)*arg2);
14154
14155         wxPyEndAllowThreads(__tstate);
14156         if (PyErr_Occurred()) SWIG_fail;
14157     }
14158     Py_INCREF(Py_None); resultobj = Py_None;
14159     {
14160         if (temp2)
14161         delete arg2;
14162     }
14163     return resultobj;
14164     fail:
14165     {
14166         if (temp2)
14167         delete arg2;
14168     }
14169     return NULL;
14170 }
14171
14172
14173 static PyObject *_wrap_FileDialog_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
14174     PyObject *resultobj;
14175     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14176     long arg2 ;
14177     PyObject * obj0 = 0 ;
14178     PyObject * obj1 = 0 ;
14179     char *kwnames[] = {
14180         (char *) "self",(char *) "style", NULL
14181     };
14182
14183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetStyle",kwnames,&obj0,&obj1)) goto fail;
14184     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14185     if (SWIG_arg_fail(1)) SWIG_fail;
14186     {
14187         arg2 = (long)(SWIG_As_long(obj1));
14188         if (SWIG_arg_fail(2)) SWIG_fail;
14189     }
14190     {
14191         PyThreadState* __tstate = wxPyBeginAllowThreads();
14192         (arg1)->SetStyle(arg2);
14193
14194         wxPyEndAllowThreads(__tstate);
14195         if (PyErr_Occurred()) SWIG_fail;
14196     }
14197     Py_INCREF(Py_None); resultobj = Py_None;
14198     return resultobj;
14199     fail:
14200     return NULL;
14201 }
14202
14203
14204 static PyObject *_wrap_FileDialog_SetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14205     PyObject *resultobj;
14206     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14207     int arg2 ;
14208     PyObject * obj0 = 0 ;
14209     PyObject * obj1 = 0 ;
14210     char *kwnames[] = {
14211         (char *) "self",(char *) "filterIndex", NULL
14212     };
14213
14214     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDialog_SetFilterIndex",kwnames,&obj0,&obj1)) goto fail;
14215     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14216     if (SWIG_arg_fail(1)) SWIG_fail;
14217     {
14218         arg2 = (int)(SWIG_As_int(obj1));
14219         if (SWIG_arg_fail(2)) SWIG_fail;
14220     }
14221     {
14222         PyThreadState* __tstate = wxPyBeginAllowThreads();
14223         (arg1)->SetFilterIndex(arg2);
14224
14225         wxPyEndAllowThreads(__tstate);
14226         if (PyErr_Occurred()) SWIG_fail;
14227     }
14228     Py_INCREF(Py_None); resultobj = Py_None;
14229     return resultobj;
14230     fail:
14231     return NULL;
14232 }
14233
14234
14235 static PyObject *_wrap_FileDialog_GetMessage(PyObject *, PyObject *args, PyObject *kwargs) {
14236     PyObject *resultobj;
14237     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14238     wxString result;
14239     PyObject * obj0 = 0 ;
14240     char *kwnames[] = {
14241         (char *) "self", NULL
14242     };
14243
14244     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetMessage",kwnames,&obj0)) goto fail;
14245     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14246     if (SWIG_arg_fail(1)) SWIG_fail;
14247     {
14248         PyThreadState* __tstate = wxPyBeginAllowThreads();
14249         result = ((wxFileDialog const *)arg1)->GetMessage();
14250
14251         wxPyEndAllowThreads(__tstate);
14252         if (PyErr_Occurred()) SWIG_fail;
14253     }
14254     {
14255 #if wxUSE_UNICODE
14256         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14257 #else
14258         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14259 #endif
14260     }
14261     return resultobj;
14262     fail:
14263     return NULL;
14264 }
14265
14266
14267 static PyObject *_wrap_FileDialog_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
14268     PyObject *resultobj;
14269     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14270     wxString result;
14271     PyObject * obj0 = 0 ;
14272     char *kwnames[] = {
14273         (char *) "self", NULL
14274     };
14275
14276     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetPath",kwnames,&obj0)) goto fail;
14277     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14278     if (SWIG_arg_fail(1)) SWIG_fail;
14279     {
14280         PyThreadState* __tstate = wxPyBeginAllowThreads();
14281         result = ((wxFileDialog const *)arg1)->GetPath();
14282
14283         wxPyEndAllowThreads(__tstate);
14284         if (PyErr_Occurred()) SWIG_fail;
14285     }
14286     {
14287 #if wxUSE_UNICODE
14288         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14289 #else
14290         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14291 #endif
14292     }
14293     return resultobj;
14294     fail:
14295     return NULL;
14296 }
14297
14298
14299 static PyObject *_wrap_FileDialog_GetDirectory(PyObject *, PyObject *args, PyObject *kwargs) {
14300     PyObject *resultobj;
14301     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14302     wxString result;
14303     PyObject * obj0 = 0 ;
14304     char *kwnames[] = {
14305         (char *) "self", NULL
14306     };
14307
14308     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetDirectory",kwnames,&obj0)) goto fail;
14309     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14310     if (SWIG_arg_fail(1)) SWIG_fail;
14311     {
14312         PyThreadState* __tstate = wxPyBeginAllowThreads();
14313         result = ((wxFileDialog const *)arg1)->GetDirectory();
14314
14315         wxPyEndAllowThreads(__tstate);
14316         if (PyErr_Occurred()) SWIG_fail;
14317     }
14318     {
14319 #if wxUSE_UNICODE
14320         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14321 #else
14322         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14323 #endif
14324     }
14325     return resultobj;
14326     fail:
14327     return NULL;
14328 }
14329
14330
14331 static PyObject *_wrap_FileDialog_GetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
14332     PyObject *resultobj;
14333     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14334     wxString result;
14335     PyObject * obj0 = 0 ;
14336     char *kwnames[] = {
14337         (char *) "self", NULL
14338     };
14339
14340     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilename",kwnames,&obj0)) goto fail;
14341     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14342     if (SWIG_arg_fail(1)) SWIG_fail;
14343     {
14344         PyThreadState* __tstate = wxPyBeginAllowThreads();
14345         result = ((wxFileDialog const *)arg1)->GetFilename();
14346
14347         wxPyEndAllowThreads(__tstate);
14348         if (PyErr_Occurred()) SWIG_fail;
14349     }
14350     {
14351 #if wxUSE_UNICODE
14352         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14353 #else
14354         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14355 #endif
14356     }
14357     return resultobj;
14358     fail:
14359     return NULL;
14360 }
14361
14362
14363 static PyObject *_wrap_FileDialog_GetWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14364     PyObject *resultobj;
14365     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14366     wxString result;
14367     PyObject * obj0 = 0 ;
14368     char *kwnames[] = {
14369         (char *) "self", NULL
14370     };
14371
14372     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetWildcard",kwnames,&obj0)) goto fail;
14373     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14374     if (SWIG_arg_fail(1)) SWIG_fail;
14375     {
14376         PyThreadState* __tstate = wxPyBeginAllowThreads();
14377         result = ((wxFileDialog const *)arg1)->GetWildcard();
14378
14379         wxPyEndAllowThreads(__tstate);
14380         if (PyErr_Occurred()) SWIG_fail;
14381     }
14382     {
14383 #if wxUSE_UNICODE
14384         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14385 #else
14386         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14387 #endif
14388     }
14389     return resultobj;
14390     fail:
14391     return NULL;
14392 }
14393
14394
14395 static PyObject *_wrap_FileDialog_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
14396     PyObject *resultobj;
14397     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14398     long result;
14399     PyObject * obj0 = 0 ;
14400     char *kwnames[] = {
14401         (char *) "self", NULL
14402     };
14403
14404     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetStyle",kwnames,&obj0)) goto fail;
14405     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14406     if (SWIG_arg_fail(1)) SWIG_fail;
14407     {
14408         PyThreadState* __tstate = wxPyBeginAllowThreads();
14409         result = (long)((wxFileDialog const *)arg1)->GetStyle();
14410
14411         wxPyEndAllowThreads(__tstate);
14412         if (PyErr_Occurred()) SWIG_fail;
14413     }
14414     {
14415         resultobj = SWIG_From_long((long)(result));
14416     }
14417     return resultobj;
14418     fail:
14419     return NULL;
14420 }
14421
14422
14423 static PyObject *_wrap_FileDialog_GetFilterIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14424     PyObject *resultobj;
14425     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14426     int result;
14427     PyObject * obj0 = 0 ;
14428     char *kwnames[] = {
14429         (char *) "self", NULL
14430     };
14431
14432     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilterIndex",kwnames,&obj0)) goto fail;
14433     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14434     if (SWIG_arg_fail(1)) SWIG_fail;
14435     {
14436         PyThreadState* __tstate = wxPyBeginAllowThreads();
14437         result = (int)((wxFileDialog const *)arg1)->GetFilterIndex();
14438
14439         wxPyEndAllowThreads(__tstate);
14440         if (PyErr_Occurred()) SWIG_fail;
14441     }
14442     {
14443         resultobj = SWIG_From_int((int)(result));
14444     }
14445     return resultobj;
14446     fail:
14447     return NULL;
14448 }
14449
14450
14451 static PyObject *_wrap_FileDialog_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
14452     PyObject *resultobj;
14453     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14454     PyObject *result;
14455     PyObject * obj0 = 0 ;
14456     char *kwnames[] = {
14457         (char *) "self", NULL
14458     };
14459
14460     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetFilenames",kwnames,&obj0)) goto fail;
14461     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14462     if (SWIG_arg_fail(1)) SWIG_fail;
14463     {
14464         PyThreadState* __tstate = wxPyBeginAllowThreads();
14465         result = (PyObject *)wxFileDialog_GetFilenames(arg1);
14466
14467         wxPyEndAllowThreads(__tstate);
14468         if (PyErr_Occurred()) SWIG_fail;
14469     }
14470     resultobj = result;
14471     return resultobj;
14472     fail:
14473     return NULL;
14474 }
14475
14476
14477 static PyObject *_wrap_FileDialog_GetPaths(PyObject *, PyObject *args, PyObject *kwargs) {
14478     PyObject *resultobj;
14479     wxFileDialog *arg1 = (wxFileDialog *) 0 ;
14480     PyObject *result;
14481     PyObject * obj0 = 0 ;
14482     char *kwnames[] = {
14483         (char *) "self", NULL
14484     };
14485
14486     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDialog_GetPaths",kwnames,&obj0)) goto fail;
14487     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDialog, SWIG_POINTER_EXCEPTION | 0);
14488     if (SWIG_arg_fail(1)) SWIG_fail;
14489     {
14490         PyThreadState* __tstate = wxPyBeginAllowThreads();
14491         result = (PyObject *)wxFileDialog_GetPaths(arg1);
14492
14493         wxPyEndAllowThreads(__tstate);
14494         if (PyErr_Occurred()) SWIG_fail;
14495     }
14496     resultobj = result;
14497     return resultobj;
14498     fail:
14499     return NULL;
14500 }
14501
14502
14503 static PyObject * FileDialog_swigregister(PyObject *, PyObject *args) {
14504     PyObject *obj;
14505     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14506     SWIG_TypeClientData(SWIGTYPE_p_wxFileDialog, obj);
14507     Py_INCREF(obj);
14508     return Py_BuildValue((char *)"");
14509 }
14510 static PyObject *_wrap_new_MultiChoiceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14511     PyObject *resultobj;
14512     wxWindow *arg1 = (wxWindow *) 0 ;
14513     wxString *arg2 = 0 ;
14514     wxString *arg3 = 0 ;
14515     int arg4 = (int) 0 ;
14516     wxString *arg5 = (wxString *) NULL ;
14517     long arg6 = (long) wxCHOICEDLG_STYLE ;
14518     wxPoint const &arg7_defvalue = wxDefaultPosition ;
14519     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
14520     wxMultiChoiceDialog *result;
14521     bool temp2 = false ;
14522     bool temp3 = false ;
14523     wxPoint temp7 ;
14524     PyObject * obj0 = 0 ;
14525     PyObject * obj1 = 0 ;
14526     PyObject * obj2 = 0 ;
14527     PyObject * obj3 = 0 ;
14528     PyObject * obj4 = 0 ;
14529     PyObject * obj5 = 0 ;
14530     char *kwnames[] = {
14531         (char *) "parent",(char *) "message",(char *) "caption",(char *) "choices",(char *) "style",(char *) "pos", NULL
14532     };
14533
14534     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:new_MultiChoiceDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14535     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14536     if (SWIG_arg_fail(1)) SWIG_fail;
14537     {
14538         arg2 = wxString_in_helper(obj1);
14539         if (arg2 == NULL) SWIG_fail;
14540         temp2 = true;
14541     }
14542     {
14543         arg3 = wxString_in_helper(obj2);
14544         if (arg3 == NULL) SWIG_fail;
14545         temp3 = true;
14546     }
14547     if (obj3) {
14548         {
14549             arg4 = PyList_Size(obj3);
14550             arg5 = wxString_LIST_helper(obj3);
14551             if (arg5 == NULL) SWIG_fail;
14552         }
14553     }
14554     if (obj4) {
14555         {
14556             arg6 = (long)(SWIG_As_long(obj4));
14557             if (SWIG_arg_fail(6)) SWIG_fail;
14558         }
14559     }
14560     if (obj5) {
14561         {
14562             arg7 = &temp7;
14563             if ( ! wxPoint_helper(obj5, &arg7)) SWIG_fail;
14564         }
14565     }
14566     {
14567         if (!wxPyCheckForApp()) SWIG_fail;
14568         PyThreadState* __tstate = wxPyBeginAllowThreads();
14569         result = (wxMultiChoiceDialog *)new wxMultiChoiceDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,(wxPoint const &)*arg7);
14570
14571         wxPyEndAllowThreads(__tstate);
14572         if (PyErr_Occurred()) SWIG_fail;
14573     }
14574     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMultiChoiceDialog, 1);
14575     {
14576         if (temp2)
14577         delete arg2;
14578     }
14579     {
14580         if (temp3)
14581         delete arg3;
14582     }
14583     {
14584         if (arg5) delete [] arg5;
14585     }
14586     return resultobj;
14587     fail:
14588     {
14589         if (temp2)
14590         delete arg2;
14591     }
14592     {
14593         if (temp3)
14594         delete arg3;
14595     }
14596     {
14597         if (arg5) delete [] arg5;
14598     }
14599     return NULL;
14600 }
14601
14602
14603 static PyObject *_wrap_MultiChoiceDialog_SetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
14604     PyObject *resultobj;
14605     wxMultiChoiceDialog *arg1 = (wxMultiChoiceDialog *) 0 ;
14606     wxArrayInt *arg2 = 0 ;
14607     bool temp2 = false ;
14608     PyObject * obj0 = 0 ;
14609     PyObject * obj1 = 0 ;
14610     char *kwnames[] = {
14611         (char *) "self",(char *) "selections", NULL
14612     };
14613
14614     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MultiChoiceDialog_SetSelections",kwnames,&obj0,&obj1)) goto fail;
14615     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMultiChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14616     if (SWIG_arg_fail(1)) SWIG_fail;
14617     {
14618         if (! PySequence_Check(obj1)) {
14619             PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
14620             SWIG_fail;
14621         }
14622         arg2 = new wxArrayInt;
14623         temp2 = true;
14624         int i, len=PySequence_Length(obj1);
14625         for (i=0; i<len; i++) {
14626             PyObject* item = PySequence_GetItem(obj1, i);
14627             PyObject* number  = PyNumber_Int(item);
14628             arg2->Add(PyInt_AS_LONG(number));
14629             Py_DECREF(item);
14630             Py_DECREF(number);
14631         }
14632     }
14633     {
14634         PyThreadState* __tstate = wxPyBeginAllowThreads();
14635         (arg1)->SetSelections((wxArrayInt const &)*arg2);
14636
14637         wxPyEndAllowThreads(__tstate);
14638         if (PyErr_Occurred()) SWIG_fail;
14639     }
14640     Py_INCREF(Py_None); resultobj = Py_None;
14641     {
14642         if (temp2) delete arg2;
14643     }
14644     return resultobj;
14645     fail:
14646     {
14647         if (temp2) delete arg2;
14648     }
14649     return NULL;
14650 }
14651
14652
14653 static PyObject *_wrap_MultiChoiceDialog_GetSelections(PyObject *, PyObject *args, PyObject *kwargs) {
14654     PyObject *resultobj;
14655     wxMultiChoiceDialog *arg1 = (wxMultiChoiceDialog *) 0 ;
14656     PyObject *result;
14657     PyObject * obj0 = 0 ;
14658     char *kwnames[] = {
14659         (char *) "self", NULL
14660     };
14661
14662     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MultiChoiceDialog_GetSelections",kwnames,&obj0)) goto fail;
14663     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMultiChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14664     if (SWIG_arg_fail(1)) SWIG_fail;
14665     {
14666         PyThreadState* __tstate = wxPyBeginAllowThreads();
14667         result = (PyObject *)wxMultiChoiceDialog_GetSelections(arg1);
14668
14669         wxPyEndAllowThreads(__tstate);
14670         if (PyErr_Occurred()) SWIG_fail;
14671     }
14672     resultobj = result;
14673     return resultobj;
14674     fail:
14675     return NULL;
14676 }
14677
14678
14679 static PyObject * MultiChoiceDialog_swigregister(PyObject *, PyObject *args) {
14680     PyObject *obj;
14681     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14682     SWIG_TypeClientData(SWIGTYPE_p_wxMultiChoiceDialog, obj);
14683     Py_INCREF(obj);
14684     return Py_BuildValue((char *)"");
14685 }
14686 static PyObject *_wrap_new_SingleChoiceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14687     PyObject *resultobj;
14688     wxWindow *arg1 = (wxWindow *) 0 ;
14689     wxString *arg2 = 0 ;
14690     wxString *arg3 = 0 ;
14691     int arg4 ;
14692     wxString *arg5 = (wxString *) 0 ;
14693     long arg6 = (long) wxCHOICEDLG_STYLE ;
14694     wxPoint const &arg7_defvalue = wxDefaultPosition ;
14695     wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
14696     wxSingleChoiceDialog *result;
14697     bool temp2 = false ;
14698     bool temp3 = false ;
14699     wxPoint temp7 ;
14700     PyObject * obj0 = 0 ;
14701     PyObject * obj1 = 0 ;
14702     PyObject * obj2 = 0 ;
14703     PyObject * obj3 = 0 ;
14704     PyObject * obj4 = 0 ;
14705     PyObject * obj5 = 0 ;
14706     char *kwnames[] = {
14707         (char *) "parent",(char *) "message",(char *) "caption",(char *) "choices",(char *) "style",(char *) "pos", NULL
14708     };
14709
14710     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:new_SingleChoiceDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14711     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14712     if (SWIG_arg_fail(1)) SWIG_fail;
14713     {
14714         arg2 = wxString_in_helper(obj1);
14715         if (arg2 == NULL) SWIG_fail;
14716         temp2 = true;
14717     }
14718     {
14719         arg3 = wxString_in_helper(obj2);
14720         if (arg3 == NULL) SWIG_fail;
14721         temp3 = true;
14722     }
14723     {
14724         arg4 = PyList_Size(obj3);
14725         arg5 = wxString_LIST_helper(obj3);
14726         if (arg5 == NULL) SWIG_fail;
14727     }
14728     if (obj4) {
14729         {
14730             arg6 = (long)(SWIG_As_long(obj4));
14731             if (SWIG_arg_fail(6)) SWIG_fail;
14732         }
14733     }
14734     if (obj5) {
14735         {
14736             arg7 = &temp7;
14737             if ( ! wxPoint_helper(obj5, &arg7)) SWIG_fail;
14738         }
14739     }
14740     {
14741         if (!wxPyCheckForApp()) SWIG_fail;
14742         PyThreadState* __tstate = wxPyBeginAllowThreads();
14743         result = (wxSingleChoiceDialog *)new_wxSingleChoiceDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,(wxPoint const &)*arg7);
14744
14745         wxPyEndAllowThreads(__tstate);
14746         if (PyErr_Occurred()) SWIG_fail;
14747     }
14748     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleChoiceDialog, 1);
14749     {
14750         if (temp2)
14751         delete arg2;
14752     }
14753     {
14754         if (temp3)
14755         delete arg3;
14756     }
14757     {
14758         if (arg5) delete [] arg5;
14759     }
14760     return resultobj;
14761     fail:
14762     {
14763         if (temp2)
14764         delete arg2;
14765     }
14766     {
14767         if (temp3)
14768         delete arg3;
14769     }
14770     {
14771         if (arg5) delete [] arg5;
14772     }
14773     return NULL;
14774 }
14775
14776
14777 static PyObject *_wrap_SingleChoiceDialog_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14778     PyObject *resultobj;
14779     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14780     int result;
14781     PyObject * obj0 = 0 ;
14782     char *kwnames[] = {
14783         (char *) "self", NULL
14784     };
14785
14786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleChoiceDialog_GetSelection",kwnames,&obj0)) goto fail;
14787     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14788     if (SWIG_arg_fail(1)) SWIG_fail;
14789     {
14790         PyThreadState* __tstate = wxPyBeginAllowThreads();
14791         result = (int)(arg1)->GetSelection();
14792
14793         wxPyEndAllowThreads(__tstate);
14794         if (PyErr_Occurred()) SWIG_fail;
14795     }
14796     {
14797         resultobj = SWIG_From_int((int)(result));
14798     }
14799     return resultobj;
14800     fail:
14801     return NULL;
14802 }
14803
14804
14805 static PyObject *_wrap_SingleChoiceDialog_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14806     PyObject *resultobj;
14807     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14808     wxString result;
14809     PyObject * obj0 = 0 ;
14810     char *kwnames[] = {
14811         (char *) "self", NULL
14812     };
14813
14814     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleChoiceDialog_GetStringSelection",kwnames,&obj0)) goto fail;
14815     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14816     if (SWIG_arg_fail(1)) SWIG_fail;
14817     {
14818         PyThreadState* __tstate = wxPyBeginAllowThreads();
14819         result = (arg1)->GetStringSelection();
14820
14821         wxPyEndAllowThreads(__tstate);
14822         if (PyErr_Occurred()) SWIG_fail;
14823     }
14824     {
14825 #if wxUSE_UNICODE
14826         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14827 #else
14828         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14829 #endif
14830     }
14831     return resultobj;
14832     fail:
14833     return NULL;
14834 }
14835
14836
14837 static PyObject *_wrap_SingleChoiceDialog_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14838     PyObject *resultobj;
14839     wxSingleChoiceDialog *arg1 = (wxSingleChoiceDialog *) 0 ;
14840     int arg2 ;
14841     PyObject * obj0 = 0 ;
14842     PyObject * obj1 = 0 ;
14843     char *kwnames[] = {
14844         (char *) "self",(char *) "sel", NULL
14845     };
14846
14847     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SingleChoiceDialog_SetSelection",kwnames,&obj0,&obj1)) goto fail;
14848     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleChoiceDialog, SWIG_POINTER_EXCEPTION | 0);
14849     if (SWIG_arg_fail(1)) SWIG_fail;
14850     {
14851         arg2 = (int)(SWIG_As_int(obj1));
14852         if (SWIG_arg_fail(2)) SWIG_fail;
14853     }
14854     {
14855         PyThreadState* __tstate = wxPyBeginAllowThreads();
14856         (arg1)->SetSelection(arg2);
14857
14858         wxPyEndAllowThreads(__tstate);
14859         if (PyErr_Occurred()) SWIG_fail;
14860     }
14861     Py_INCREF(Py_None); resultobj = Py_None;
14862     return resultobj;
14863     fail:
14864     return NULL;
14865 }
14866
14867
14868 static PyObject * SingleChoiceDialog_swigregister(PyObject *, PyObject *args) {
14869     PyObject *obj;
14870     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14871     SWIG_TypeClientData(SWIGTYPE_p_wxSingleChoiceDialog, obj);
14872     Py_INCREF(obj);
14873     return Py_BuildValue((char *)"");
14874 }
14875 static PyObject *_wrap_new_TextEntryDialog(PyObject *, PyObject *args, PyObject *kwargs) {
14876     PyObject *resultobj;
14877     wxWindow *arg1 = (wxWindow *) 0 ;
14878     wxString *arg2 = 0 ;
14879     wxString const &arg3_defvalue = wxPyGetTextFromUserPromptStr ;
14880     wxString *arg3 = (wxString *) &arg3_defvalue ;
14881     wxString const &arg4_defvalue = wxPyEmptyString ;
14882     wxString *arg4 = (wxString *) &arg4_defvalue ;
14883     long arg5 = (long) wxTextEntryDialogStyle ;
14884     wxPoint const &arg6_defvalue = wxDefaultPosition ;
14885     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
14886     wxTextEntryDialog *result;
14887     bool temp2 = false ;
14888     bool temp3 = false ;
14889     bool temp4 = false ;
14890     wxPoint temp6 ;
14891     PyObject * obj0 = 0 ;
14892     PyObject * obj1 = 0 ;
14893     PyObject * obj2 = 0 ;
14894     PyObject * obj3 = 0 ;
14895     PyObject * obj4 = 0 ;
14896     PyObject * obj5 = 0 ;
14897     char *kwnames[] = {
14898         (char *) "parent",(char *) "message",(char *) "caption",(char *) "defaultValue",(char *) "style",(char *) "pos", NULL
14899     };
14900
14901     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_TextEntryDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14902     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
14903     if (SWIG_arg_fail(1)) SWIG_fail;
14904     {
14905         arg2 = wxString_in_helper(obj1);
14906         if (arg2 == NULL) SWIG_fail;
14907         temp2 = true;
14908     }
14909     if (obj2) {
14910         {
14911             arg3 = wxString_in_helper(obj2);
14912             if (arg3 == NULL) SWIG_fail;
14913             temp3 = true;
14914         }
14915     }
14916     if (obj3) {
14917         {
14918             arg4 = wxString_in_helper(obj3);
14919             if (arg4 == NULL) SWIG_fail;
14920             temp4 = true;
14921         }
14922     }
14923     if (obj4) {
14924         {
14925             arg5 = (long)(SWIG_As_long(obj4));
14926             if (SWIG_arg_fail(5)) SWIG_fail;
14927         }
14928     }
14929     if (obj5) {
14930         {
14931             arg6 = &temp6;
14932             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
14933         }
14934     }
14935     {
14936         if (!wxPyCheckForApp()) SWIG_fail;
14937         PyThreadState* __tstate = wxPyBeginAllowThreads();
14938         result = (wxTextEntryDialog *)new wxTextEntryDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,(wxPoint const &)*arg6);
14939
14940         wxPyEndAllowThreads(__tstate);
14941         if (PyErr_Occurred()) SWIG_fail;
14942     }
14943     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextEntryDialog, 1);
14944     {
14945         if (temp2)
14946         delete arg2;
14947     }
14948     {
14949         if (temp3)
14950         delete arg3;
14951     }
14952     {
14953         if (temp4)
14954         delete arg4;
14955     }
14956     return resultobj;
14957     fail:
14958     {
14959         if (temp2)
14960         delete arg2;
14961     }
14962     {
14963         if (temp3)
14964         delete arg3;
14965     }
14966     {
14967         if (temp4)
14968         delete arg4;
14969     }
14970     return NULL;
14971 }
14972
14973
14974 static PyObject *_wrap_TextEntryDialog_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
14975     PyObject *resultobj;
14976     wxTextEntryDialog *arg1 = (wxTextEntryDialog *) 0 ;
14977     wxString result;
14978     PyObject * obj0 = 0 ;
14979     char *kwnames[] = {
14980         (char *) "self", NULL
14981     };
14982
14983     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextEntryDialog_GetValue",kwnames,&obj0)) goto fail;
14984     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextEntryDialog, SWIG_POINTER_EXCEPTION | 0);
14985     if (SWIG_arg_fail(1)) SWIG_fail;
14986     {
14987         PyThreadState* __tstate = wxPyBeginAllowThreads();
14988         result = (arg1)->GetValue();
14989
14990         wxPyEndAllowThreads(__tstate);
14991         if (PyErr_Occurred()) SWIG_fail;
14992     }
14993     {
14994 #if wxUSE_UNICODE
14995         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14996 #else
14997         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14998 #endif
14999     }
15000     return resultobj;
15001     fail:
15002     return NULL;
15003 }
15004
15005
15006 static PyObject *_wrap_TextEntryDialog_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
15007     PyObject *resultobj;
15008     wxTextEntryDialog *arg1 = (wxTextEntryDialog *) 0 ;
15009     wxString *arg2 = 0 ;
15010     bool temp2 = false ;
15011     PyObject * obj0 = 0 ;
15012     PyObject * obj1 = 0 ;
15013     char *kwnames[] = {
15014         (char *) "self",(char *) "value", NULL
15015     };
15016
15017     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextEntryDialog_SetValue",kwnames,&obj0,&obj1)) goto fail;
15018     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextEntryDialog, SWIG_POINTER_EXCEPTION | 0);
15019     if (SWIG_arg_fail(1)) SWIG_fail;
15020     {
15021         arg2 = wxString_in_helper(obj1);
15022         if (arg2 == NULL) SWIG_fail;
15023         temp2 = true;
15024     }
15025     {
15026         PyThreadState* __tstate = wxPyBeginAllowThreads();
15027         (arg1)->SetValue((wxString const &)*arg2);
15028
15029         wxPyEndAllowThreads(__tstate);
15030         if (PyErr_Occurred()) SWIG_fail;
15031     }
15032     Py_INCREF(Py_None); resultobj = Py_None;
15033     {
15034         if (temp2)
15035         delete arg2;
15036     }
15037     return resultobj;
15038     fail:
15039     {
15040         if (temp2)
15041         delete arg2;
15042     }
15043     return NULL;
15044 }
15045
15046
15047 static PyObject * TextEntryDialog_swigregister(PyObject *, PyObject *args) {
15048     PyObject *obj;
15049     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15050     SWIG_TypeClientData(SWIGTYPE_p_wxTextEntryDialog, obj);
15051     Py_INCREF(obj);
15052     return Py_BuildValue((char *)"");
15053 }
15054 static int _wrap_GetPasswordFromUserPromptStr_set(PyObject *) {
15055     PyErr_SetString(PyExc_TypeError,"Variable GetPasswordFromUserPromptStr is read-only.");
15056     return 1;
15057 }
15058
15059
15060 static PyObject *_wrap_GetPasswordFromUserPromptStr_get(void) {
15061     PyObject *pyobj;
15062
15063     {
15064 #if wxUSE_UNICODE
15065         pyobj = PyUnicode_FromWideChar((&wxPyGetPasswordFromUserPromptStr)->c_str(), (&wxPyGetPasswordFromUserPromptStr)->Len());
15066 #else
15067         pyobj = PyString_FromStringAndSize((&wxPyGetPasswordFromUserPromptStr)->c_str(), (&wxPyGetPasswordFromUserPromptStr)->Len());
15068 #endif
15069     }
15070     return pyobj;
15071 }
15072
15073
15074 static PyObject *_wrap_new_PasswordEntryDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15075     PyObject *resultobj;
15076     wxWindow *arg1 = (wxWindow *) 0 ;
15077     wxString *arg2 = 0 ;
15078     wxString const &arg3_defvalue = wxPyGetPasswordFromUserPromptStr ;
15079     wxString *arg3 = (wxString *) &arg3_defvalue ;
15080     wxString const &arg4_defvalue = wxPyEmptyString ;
15081     wxString *arg4 = (wxString *) &arg4_defvalue ;
15082     long arg5 = (long) wxTextEntryDialogStyle ;
15083     wxPoint const &arg6_defvalue = wxDefaultPosition ;
15084     wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
15085     wxPasswordEntryDialog *result;
15086     bool temp2 = false ;
15087     bool temp3 = false ;
15088     bool temp4 = false ;
15089     wxPoint temp6 ;
15090     PyObject * obj0 = 0 ;
15091     PyObject * obj1 = 0 ;
15092     PyObject * obj2 = 0 ;
15093     PyObject * obj3 = 0 ;
15094     PyObject * obj4 = 0 ;
15095     PyObject * obj5 = 0 ;
15096     char *kwnames[] = {
15097         (char *) "parent",(char *) "message",(char *) "caption",(char *) "value",(char *) "style",(char *) "pos", NULL
15098     };
15099
15100     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_PasswordEntryDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15101     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15102     if (SWIG_arg_fail(1)) SWIG_fail;
15103     {
15104         arg2 = wxString_in_helper(obj1);
15105         if (arg2 == NULL) SWIG_fail;
15106         temp2 = true;
15107     }
15108     if (obj2) {
15109         {
15110             arg3 = wxString_in_helper(obj2);
15111             if (arg3 == NULL) SWIG_fail;
15112             temp3 = true;
15113         }
15114     }
15115     if (obj3) {
15116         {
15117             arg4 = wxString_in_helper(obj3);
15118             if (arg4 == NULL) SWIG_fail;
15119             temp4 = true;
15120         }
15121     }
15122     if (obj4) {
15123         {
15124             arg5 = (long)(SWIG_As_long(obj4));
15125             if (SWIG_arg_fail(5)) SWIG_fail;
15126         }
15127     }
15128     if (obj5) {
15129         {
15130             arg6 = &temp6;
15131             if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
15132         }
15133     }
15134     {
15135         PyThreadState* __tstate = wxPyBeginAllowThreads();
15136         result = (wxPasswordEntryDialog *)new wxPasswordEntryDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,(wxPoint const &)*arg6);
15137
15138         wxPyEndAllowThreads(__tstate);
15139         if (PyErr_Occurred()) SWIG_fail;
15140     }
15141     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPasswordEntryDialog, 1);
15142     {
15143         if (temp2)
15144         delete arg2;
15145     }
15146     {
15147         if (temp3)
15148         delete arg3;
15149     }
15150     {
15151         if (temp4)
15152         delete arg4;
15153     }
15154     return resultobj;
15155     fail:
15156     {
15157         if (temp2)
15158         delete arg2;
15159     }
15160     {
15161         if (temp3)
15162         delete arg3;
15163     }
15164     {
15165         if (temp4)
15166         delete arg4;
15167     }
15168     return NULL;
15169 }
15170
15171
15172 static PyObject * PasswordEntryDialog_swigregister(PyObject *, PyObject *args) {
15173     PyObject *obj;
15174     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15175     SWIG_TypeClientData(SWIGTYPE_p_wxPasswordEntryDialog, obj);
15176     Py_INCREF(obj);
15177     return Py_BuildValue((char *)"");
15178 }
15179 static PyObject *_wrap_new_FontData(PyObject *, PyObject *args, PyObject *kwargs) {
15180     PyObject *resultobj;
15181     wxFontData *result;
15182     char *kwnames[] = {
15183         NULL
15184     };
15185
15186     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontData",kwnames)) goto fail;
15187     {
15188         PyThreadState* __tstate = wxPyBeginAllowThreads();
15189         result = (wxFontData *)new wxFontData();
15190
15191         wxPyEndAllowThreads(__tstate);
15192         if (PyErr_Occurred()) SWIG_fail;
15193     }
15194     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontData, 1);
15195     return resultobj;
15196     fail:
15197     return NULL;
15198 }
15199
15200
15201 static PyObject *_wrap_delete_FontData(PyObject *, PyObject *args, PyObject *kwargs) {
15202     PyObject *resultobj;
15203     wxFontData *arg1 = (wxFontData *) 0 ;
15204     PyObject * obj0 = 0 ;
15205     char *kwnames[] = {
15206         (char *) "self", NULL
15207     };
15208
15209     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontData",kwnames,&obj0)) goto fail;
15210     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15211     if (SWIG_arg_fail(1)) SWIG_fail;
15212     {
15213         PyThreadState* __tstate = wxPyBeginAllowThreads();
15214         delete arg1;
15215
15216         wxPyEndAllowThreads(__tstate);
15217         if (PyErr_Occurred()) SWIG_fail;
15218     }
15219     Py_INCREF(Py_None); resultobj = Py_None;
15220     return resultobj;
15221     fail:
15222     return NULL;
15223 }
15224
15225
15226 static PyObject *_wrap_FontData_EnableEffects(PyObject *, PyObject *args, PyObject *kwargs) {
15227     PyObject *resultobj;
15228     wxFontData *arg1 = (wxFontData *) 0 ;
15229     bool arg2 ;
15230     PyObject * obj0 = 0 ;
15231     PyObject * obj1 = 0 ;
15232     char *kwnames[] = {
15233         (char *) "self",(char *) "enable", NULL
15234     };
15235
15236     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_EnableEffects",kwnames,&obj0,&obj1)) goto fail;
15237     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15238     if (SWIG_arg_fail(1)) SWIG_fail;
15239     {
15240         arg2 = (bool)(SWIG_As_bool(obj1));
15241         if (SWIG_arg_fail(2)) SWIG_fail;
15242     }
15243     {
15244         PyThreadState* __tstate = wxPyBeginAllowThreads();
15245         (arg1)->EnableEffects(arg2);
15246
15247         wxPyEndAllowThreads(__tstate);
15248         if (PyErr_Occurred()) SWIG_fail;
15249     }
15250     Py_INCREF(Py_None); resultobj = Py_None;
15251     return resultobj;
15252     fail:
15253     return NULL;
15254 }
15255
15256
15257 static PyObject *_wrap_FontData_GetAllowSymbols(PyObject *, PyObject *args, PyObject *kwargs) {
15258     PyObject *resultobj;
15259     wxFontData *arg1 = (wxFontData *) 0 ;
15260     bool result;
15261     PyObject * obj0 = 0 ;
15262     char *kwnames[] = {
15263         (char *) "self", NULL
15264     };
15265
15266     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetAllowSymbols",kwnames,&obj0)) goto fail;
15267     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15268     if (SWIG_arg_fail(1)) SWIG_fail;
15269     {
15270         PyThreadState* __tstate = wxPyBeginAllowThreads();
15271         result = (bool)(arg1)->GetAllowSymbols();
15272
15273         wxPyEndAllowThreads(__tstate);
15274         if (PyErr_Occurred()) SWIG_fail;
15275     }
15276     {
15277         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15278     }
15279     return resultobj;
15280     fail:
15281     return NULL;
15282 }
15283
15284
15285 static PyObject *_wrap_FontData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
15286     PyObject *resultobj;
15287     wxFontData *arg1 = (wxFontData *) 0 ;
15288     wxColour result;
15289     PyObject * obj0 = 0 ;
15290     char *kwnames[] = {
15291         (char *) "self", NULL
15292     };
15293
15294     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetColour",kwnames,&obj0)) goto fail;
15295     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15296     if (SWIG_arg_fail(1)) SWIG_fail;
15297     {
15298         PyThreadState* __tstate = wxPyBeginAllowThreads();
15299         result = (arg1)->GetColour();
15300
15301         wxPyEndAllowThreads(__tstate);
15302         if (PyErr_Occurred()) SWIG_fail;
15303     }
15304     {
15305         wxColour * resultptr;
15306         resultptr = new wxColour((wxColour &)(result));
15307         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
15308     }
15309     return resultobj;
15310     fail:
15311     return NULL;
15312 }
15313
15314
15315 static PyObject *_wrap_FontData_GetChosenFont(PyObject *, PyObject *args, PyObject *kwargs) {
15316     PyObject *resultobj;
15317     wxFontData *arg1 = (wxFontData *) 0 ;
15318     wxFont result;
15319     PyObject * obj0 = 0 ;
15320     char *kwnames[] = {
15321         (char *) "self", NULL
15322     };
15323
15324     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetChosenFont",kwnames,&obj0)) goto fail;
15325     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15326     if (SWIG_arg_fail(1)) SWIG_fail;
15327     {
15328         PyThreadState* __tstate = wxPyBeginAllowThreads();
15329         result = (arg1)->GetChosenFont();
15330
15331         wxPyEndAllowThreads(__tstate);
15332         if (PyErr_Occurred()) SWIG_fail;
15333     }
15334     {
15335         wxFont * resultptr;
15336         resultptr = new wxFont((wxFont &)(result));
15337         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
15338     }
15339     return resultobj;
15340     fail:
15341     return NULL;
15342 }
15343
15344
15345 static PyObject *_wrap_FontData_GetEnableEffects(PyObject *, PyObject *args, PyObject *kwargs) {
15346     PyObject *resultobj;
15347     wxFontData *arg1 = (wxFontData *) 0 ;
15348     bool result;
15349     PyObject * obj0 = 0 ;
15350     char *kwnames[] = {
15351         (char *) "self", NULL
15352     };
15353
15354     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetEnableEffects",kwnames,&obj0)) goto fail;
15355     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15356     if (SWIG_arg_fail(1)) SWIG_fail;
15357     {
15358         PyThreadState* __tstate = wxPyBeginAllowThreads();
15359         result = (bool)(arg1)->GetEnableEffects();
15360
15361         wxPyEndAllowThreads(__tstate);
15362         if (PyErr_Occurred()) SWIG_fail;
15363     }
15364     {
15365         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15366     }
15367     return resultobj;
15368     fail:
15369     return NULL;
15370 }
15371
15372
15373 static PyObject *_wrap_FontData_GetInitialFont(PyObject *, PyObject *args, PyObject *kwargs) {
15374     PyObject *resultobj;
15375     wxFontData *arg1 = (wxFontData *) 0 ;
15376     wxFont result;
15377     PyObject * obj0 = 0 ;
15378     char *kwnames[] = {
15379         (char *) "self", NULL
15380     };
15381
15382     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetInitialFont",kwnames,&obj0)) goto fail;
15383     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15384     if (SWIG_arg_fail(1)) SWIG_fail;
15385     {
15386         PyThreadState* __tstate = wxPyBeginAllowThreads();
15387         result = (arg1)->GetInitialFont();
15388
15389         wxPyEndAllowThreads(__tstate);
15390         if (PyErr_Occurred()) SWIG_fail;
15391     }
15392     {
15393         wxFont * resultptr;
15394         resultptr = new wxFont((wxFont &)(result));
15395         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
15396     }
15397     return resultobj;
15398     fail:
15399     return NULL;
15400 }
15401
15402
15403 static PyObject *_wrap_FontData_GetShowHelp(PyObject *, PyObject *args, PyObject *kwargs) {
15404     PyObject *resultobj;
15405     wxFontData *arg1 = (wxFontData *) 0 ;
15406     bool result;
15407     PyObject * obj0 = 0 ;
15408     char *kwnames[] = {
15409         (char *) "self", NULL
15410     };
15411
15412     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontData_GetShowHelp",kwnames,&obj0)) goto fail;
15413     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15414     if (SWIG_arg_fail(1)) SWIG_fail;
15415     {
15416         PyThreadState* __tstate = wxPyBeginAllowThreads();
15417         result = (bool)(arg1)->GetShowHelp();
15418
15419         wxPyEndAllowThreads(__tstate);
15420         if (PyErr_Occurred()) SWIG_fail;
15421     }
15422     {
15423         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15424     }
15425     return resultobj;
15426     fail:
15427     return NULL;
15428 }
15429
15430
15431 static PyObject *_wrap_FontData_SetAllowSymbols(PyObject *, PyObject *args, PyObject *kwargs) {
15432     PyObject *resultobj;
15433     wxFontData *arg1 = (wxFontData *) 0 ;
15434     bool arg2 ;
15435     PyObject * obj0 = 0 ;
15436     PyObject * obj1 = 0 ;
15437     char *kwnames[] = {
15438         (char *) "self",(char *) "allowSymbols", NULL
15439     };
15440
15441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetAllowSymbols",kwnames,&obj0,&obj1)) goto fail;
15442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15443     if (SWIG_arg_fail(1)) SWIG_fail;
15444     {
15445         arg2 = (bool)(SWIG_As_bool(obj1));
15446         if (SWIG_arg_fail(2)) SWIG_fail;
15447     }
15448     {
15449         PyThreadState* __tstate = wxPyBeginAllowThreads();
15450         (arg1)->SetAllowSymbols(arg2);
15451
15452         wxPyEndAllowThreads(__tstate);
15453         if (PyErr_Occurred()) SWIG_fail;
15454     }
15455     Py_INCREF(Py_None); resultobj = Py_None;
15456     return resultobj;
15457     fail:
15458     return NULL;
15459 }
15460
15461
15462 static PyObject *_wrap_FontData_SetChosenFont(PyObject *, PyObject *args, PyObject *kwargs) {
15463     PyObject *resultobj;
15464     wxFontData *arg1 = (wxFontData *) 0 ;
15465     wxFont *arg2 = 0 ;
15466     PyObject * obj0 = 0 ;
15467     PyObject * obj1 = 0 ;
15468     char *kwnames[] = {
15469         (char *) "self",(char *) "font", NULL
15470     };
15471
15472     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetChosenFont",kwnames,&obj0,&obj1)) goto fail;
15473     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15474     if (SWIG_arg_fail(1)) SWIG_fail;
15475     {
15476         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15477         if (SWIG_arg_fail(2)) SWIG_fail;
15478         if (arg2 == NULL) {
15479             SWIG_null_ref("wxFont");
15480         }
15481         if (SWIG_arg_fail(2)) SWIG_fail;
15482     }
15483     {
15484         PyThreadState* __tstate = wxPyBeginAllowThreads();
15485         (arg1)->SetChosenFont((wxFont const &)*arg2);
15486
15487         wxPyEndAllowThreads(__tstate);
15488         if (PyErr_Occurred()) SWIG_fail;
15489     }
15490     Py_INCREF(Py_None); resultobj = Py_None;
15491     return resultobj;
15492     fail:
15493     return NULL;
15494 }
15495
15496
15497 static PyObject *_wrap_FontData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
15498     PyObject *resultobj;
15499     wxFontData *arg1 = (wxFontData *) 0 ;
15500     wxColour *arg2 = 0 ;
15501     wxColour temp2 ;
15502     PyObject * obj0 = 0 ;
15503     PyObject * obj1 = 0 ;
15504     char *kwnames[] = {
15505         (char *) "self",(char *) "colour", NULL
15506     };
15507
15508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetColour",kwnames,&obj0,&obj1)) goto fail;
15509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15510     if (SWIG_arg_fail(1)) SWIG_fail;
15511     {
15512         arg2 = &temp2;
15513         if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15514     }
15515     {
15516         PyThreadState* __tstate = wxPyBeginAllowThreads();
15517         (arg1)->SetColour((wxColour const &)*arg2);
15518
15519         wxPyEndAllowThreads(__tstate);
15520         if (PyErr_Occurred()) SWIG_fail;
15521     }
15522     Py_INCREF(Py_None); resultobj = Py_None;
15523     return resultobj;
15524     fail:
15525     return NULL;
15526 }
15527
15528
15529 static PyObject *_wrap_FontData_SetInitialFont(PyObject *, PyObject *args, PyObject *kwargs) {
15530     PyObject *resultobj;
15531     wxFontData *arg1 = (wxFontData *) 0 ;
15532     wxFont *arg2 = 0 ;
15533     PyObject * obj0 = 0 ;
15534     PyObject * obj1 = 0 ;
15535     char *kwnames[] = {
15536         (char *) "self",(char *) "font", NULL
15537     };
15538
15539     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetInitialFont",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         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15544         if (SWIG_arg_fail(2)) SWIG_fail;
15545         if (arg2 == NULL) {
15546             SWIG_null_ref("wxFont");
15547         }
15548         if (SWIG_arg_fail(2)) SWIG_fail;
15549     }
15550     {
15551         PyThreadState* __tstate = wxPyBeginAllowThreads();
15552         (arg1)->SetInitialFont((wxFont const &)*arg2);
15553
15554         wxPyEndAllowThreads(__tstate);
15555         if (PyErr_Occurred()) SWIG_fail;
15556     }
15557     Py_INCREF(Py_None); resultobj = Py_None;
15558     return resultobj;
15559     fail:
15560     return NULL;
15561 }
15562
15563
15564 static PyObject *_wrap_FontData_SetRange(PyObject *, PyObject *args, PyObject *kwargs) {
15565     PyObject *resultobj;
15566     wxFontData *arg1 = (wxFontData *) 0 ;
15567     int arg2 ;
15568     int arg3 ;
15569     PyObject * obj0 = 0 ;
15570     PyObject * obj1 = 0 ;
15571     PyObject * obj2 = 0 ;
15572     char *kwnames[] = {
15573         (char *) "self",(char *) "min",(char *) "max", NULL
15574     };
15575
15576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FontData_SetRange",kwnames,&obj0,&obj1,&obj2)) goto fail;
15577     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15578     if (SWIG_arg_fail(1)) SWIG_fail;
15579     {
15580         arg2 = (int)(SWIG_As_int(obj1));
15581         if (SWIG_arg_fail(2)) SWIG_fail;
15582     }
15583     {
15584         arg3 = (int)(SWIG_As_int(obj2));
15585         if (SWIG_arg_fail(3)) SWIG_fail;
15586     }
15587     {
15588         PyThreadState* __tstate = wxPyBeginAllowThreads();
15589         (arg1)->SetRange(arg2,arg3);
15590
15591         wxPyEndAllowThreads(__tstate);
15592         if (PyErr_Occurred()) SWIG_fail;
15593     }
15594     Py_INCREF(Py_None); resultobj = Py_None;
15595     return resultobj;
15596     fail:
15597     return NULL;
15598 }
15599
15600
15601 static PyObject *_wrap_FontData_SetShowHelp(PyObject *, PyObject *args, PyObject *kwargs) {
15602     PyObject *resultobj;
15603     wxFontData *arg1 = (wxFontData *) 0 ;
15604     bool arg2 ;
15605     PyObject * obj0 = 0 ;
15606     PyObject * obj1 = 0 ;
15607     char *kwnames[] = {
15608         (char *) "self",(char *) "showHelp", NULL
15609     };
15610
15611     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontData_SetShowHelp",kwnames,&obj0,&obj1)) goto fail;
15612     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15613     if (SWIG_arg_fail(1)) SWIG_fail;
15614     {
15615         arg2 = (bool)(SWIG_As_bool(obj1));
15616         if (SWIG_arg_fail(2)) SWIG_fail;
15617     }
15618     {
15619         PyThreadState* __tstate = wxPyBeginAllowThreads();
15620         (arg1)->SetShowHelp(arg2);
15621
15622         wxPyEndAllowThreads(__tstate);
15623         if (PyErr_Occurred()) SWIG_fail;
15624     }
15625     Py_INCREF(Py_None); resultobj = Py_None;
15626     return resultobj;
15627     fail:
15628     return NULL;
15629 }
15630
15631
15632 static PyObject * FontData_swigregister(PyObject *, PyObject *args) {
15633     PyObject *obj;
15634     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15635     SWIG_TypeClientData(SWIGTYPE_p_wxFontData, obj);
15636     Py_INCREF(obj);
15637     return Py_BuildValue((char *)"");
15638 }
15639 static PyObject *_wrap_new_FontDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15640     PyObject *resultobj;
15641     wxWindow *arg1 = (wxWindow *) 0 ;
15642     wxFontData *arg2 = 0 ;
15643     wxFontDialog *result;
15644     PyObject * obj0 = 0 ;
15645     PyObject * obj1 = 0 ;
15646     char *kwnames[] = {
15647         (char *) "parent",(char *) "data", NULL
15648     };
15649
15650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_FontDialog",kwnames,&obj0,&obj1)) goto fail;
15651     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15652     if (SWIG_arg_fail(1)) SWIG_fail;
15653     {
15654         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFontData, SWIG_POINTER_EXCEPTION | 0);
15655         if (SWIG_arg_fail(2)) SWIG_fail;
15656         if (arg2 == NULL) {
15657             SWIG_null_ref("wxFontData");
15658         }
15659         if (SWIG_arg_fail(2)) SWIG_fail;
15660     }
15661     {
15662         if (!wxPyCheckForApp()) SWIG_fail;
15663         PyThreadState* __tstate = wxPyBeginAllowThreads();
15664         result = (wxFontDialog *)new wxFontDialog(arg1,(wxFontData const &)*arg2);
15665
15666         wxPyEndAllowThreads(__tstate);
15667         if (PyErr_Occurred()) SWIG_fail;
15668     }
15669     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontDialog, 1);
15670     return resultobj;
15671     fail:
15672     return NULL;
15673 }
15674
15675
15676 static PyObject *_wrap_FontDialog_GetFontData(PyObject *, PyObject *args, PyObject *kwargs) {
15677     PyObject *resultobj;
15678     wxFontDialog *arg1 = (wxFontDialog *) 0 ;
15679     wxFontData *result;
15680     PyObject * obj0 = 0 ;
15681     char *kwnames[] = {
15682         (char *) "self", NULL
15683     };
15684
15685     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontDialog_GetFontData",kwnames,&obj0)) goto fail;
15686     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontDialog, SWIG_POINTER_EXCEPTION | 0);
15687     if (SWIG_arg_fail(1)) SWIG_fail;
15688     {
15689         PyThreadState* __tstate = wxPyBeginAllowThreads();
15690         {
15691             wxFontData &_result_ref = (arg1)->GetFontData();
15692             result = (wxFontData *) &_result_ref;
15693         }
15694
15695         wxPyEndAllowThreads(__tstate);
15696         if (PyErr_Occurred()) SWIG_fail;
15697     }
15698     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontData, 0);
15699     return resultobj;
15700     fail:
15701     return NULL;
15702 }
15703
15704
15705 static PyObject * FontDialog_swigregister(PyObject *, PyObject *args) {
15706     PyObject *obj;
15707     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15708     SWIG_TypeClientData(SWIGTYPE_p_wxFontDialog, obj);
15709     Py_INCREF(obj);
15710     return Py_BuildValue((char *)"");
15711 }
15712 static PyObject *_wrap_new_MessageDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15713     PyObject *resultobj;
15714     wxWindow *arg1 = (wxWindow *) 0 ;
15715     wxString *arg2 = 0 ;
15716     wxString const &arg3_defvalue = wxPyMessageBoxCaptionStr ;
15717     wxString *arg3 = (wxString *) &arg3_defvalue ;
15718     long arg4 = (long) wxOK|wxCANCEL|wxCENTRE ;
15719     wxPoint const &arg5_defvalue = wxDefaultPosition ;
15720     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
15721     wxMessageDialog *result;
15722     bool temp2 = false ;
15723     bool temp3 = false ;
15724     wxPoint temp5 ;
15725     PyObject * obj0 = 0 ;
15726     PyObject * obj1 = 0 ;
15727     PyObject * obj2 = 0 ;
15728     PyObject * obj3 = 0 ;
15729     PyObject * obj4 = 0 ;
15730     char *kwnames[] = {
15731         (char *) "parent",(char *) "message",(char *) "caption",(char *) "style",(char *) "pos", NULL
15732     };
15733
15734     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_MessageDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15735     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15736     if (SWIG_arg_fail(1)) SWIG_fail;
15737     {
15738         arg2 = wxString_in_helper(obj1);
15739         if (arg2 == NULL) SWIG_fail;
15740         temp2 = true;
15741     }
15742     if (obj2) {
15743         {
15744             arg3 = wxString_in_helper(obj2);
15745             if (arg3 == NULL) SWIG_fail;
15746             temp3 = true;
15747         }
15748     }
15749     if (obj3) {
15750         {
15751             arg4 = (long)(SWIG_As_long(obj3));
15752             if (SWIG_arg_fail(4)) SWIG_fail;
15753         }
15754     }
15755     if (obj4) {
15756         {
15757             arg5 = &temp5;
15758             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
15759         }
15760     }
15761     {
15762         if (!wxPyCheckForApp()) SWIG_fail;
15763         PyThreadState* __tstate = wxPyBeginAllowThreads();
15764         result = (wxMessageDialog *)new wxMessageDialog(arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,(wxPoint const &)*arg5);
15765
15766         wxPyEndAllowThreads(__tstate);
15767         if (PyErr_Occurred()) SWIG_fail;
15768     }
15769     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMessageDialog, 1);
15770     {
15771         if (temp2)
15772         delete arg2;
15773     }
15774     {
15775         if (temp3)
15776         delete arg3;
15777     }
15778     return resultobj;
15779     fail:
15780     {
15781         if (temp2)
15782         delete arg2;
15783     }
15784     {
15785         if (temp3)
15786         delete arg3;
15787     }
15788     return NULL;
15789 }
15790
15791
15792 static PyObject * MessageDialog_swigregister(PyObject *, PyObject *args) {
15793     PyObject *obj;
15794     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15795     SWIG_TypeClientData(SWIGTYPE_p_wxMessageDialog, obj);
15796     Py_INCREF(obj);
15797     return Py_BuildValue((char *)"");
15798 }
15799 static PyObject *_wrap_new_ProgressDialog(PyObject *, PyObject *args, PyObject *kwargs) {
15800     PyObject *resultobj;
15801     wxString *arg1 = 0 ;
15802     wxString *arg2 = 0 ;
15803     int arg3 = (int) 100 ;
15804     wxWindow *arg4 = (wxWindow *) NULL ;
15805     int arg5 = (int) wxPD_AUTO_HIDE|wxPD_APP_MODAL ;
15806     wxProgressDialog *result;
15807     bool temp1 = false ;
15808     bool temp2 = false ;
15809     PyObject * obj0 = 0 ;
15810     PyObject * obj1 = 0 ;
15811     PyObject * obj2 = 0 ;
15812     PyObject * obj3 = 0 ;
15813     PyObject * obj4 = 0 ;
15814     char *kwnames[] = {
15815         (char *) "title",(char *) "message",(char *) "maximum",(char *) "parent",(char *) "style", NULL
15816     };
15817
15818     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_ProgressDialog",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15819     {
15820         arg1 = wxString_in_helper(obj0);
15821         if (arg1 == NULL) SWIG_fail;
15822         temp1 = true;
15823     }
15824     {
15825         arg2 = wxString_in_helper(obj1);
15826         if (arg2 == NULL) SWIG_fail;
15827         temp2 = true;
15828     }
15829     if (obj2) {
15830         {
15831             arg3 = (int)(SWIG_As_int(obj2));
15832             if (SWIG_arg_fail(3)) SWIG_fail;
15833         }
15834     }
15835     if (obj3) {
15836         SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
15837         if (SWIG_arg_fail(4)) SWIG_fail;
15838     }
15839     if (obj4) {
15840         {
15841             arg5 = (int)(SWIG_As_int(obj4));
15842             if (SWIG_arg_fail(5)) SWIG_fail;
15843         }
15844     }
15845     {
15846         if (!wxPyCheckForApp()) SWIG_fail;
15847         PyThreadState* __tstate = wxPyBeginAllowThreads();
15848         result = (wxProgressDialog *)new wxProgressDialog((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5);
15849
15850         wxPyEndAllowThreads(__tstate);
15851         if (PyErr_Occurred()) SWIG_fail;
15852     }
15853     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProgressDialog, 1);
15854     {
15855         if (temp1)
15856         delete arg1;
15857     }
15858     {
15859         if (temp2)
15860         delete arg2;
15861     }
15862     return resultobj;
15863     fail:
15864     {
15865         if (temp1)
15866         delete arg1;
15867     }
15868     {
15869         if (temp2)
15870         delete arg2;
15871     }
15872     return NULL;
15873 }
15874
15875
15876 static PyObject *_wrap_ProgressDialog_Update(PyObject *, PyObject *args, PyObject *kwargs) {
15877     PyObject *resultobj;
15878     wxProgressDialog *arg1 = (wxProgressDialog *) 0 ;
15879     int arg2 ;
15880     wxString const &arg3_defvalue = wxPyEmptyString ;
15881     wxString *arg3 = (wxString *) &arg3_defvalue ;
15882     bool result;
15883     bool temp3 = false ;
15884     PyObject * obj0 = 0 ;
15885     PyObject * obj1 = 0 ;
15886     PyObject * obj2 = 0 ;
15887     char *kwnames[] = {
15888         (char *) "self",(char *) "value",(char *) "newmsg", NULL
15889     };
15890
15891     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ProgressDialog_Update",kwnames,&obj0,&obj1,&obj2)) goto fail;
15892     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProgressDialog, SWIG_POINTER_EXCEPTION | 0);
15893     if (SWIG_arg_fail(1)) SWIG_fail;
15894     {
15895         arg2 = (int)(SWIG_As_int(obj1));
15896         if (SWIG_arg_fail(2)) SWIG_fail;
15897     }
15898     if (obj2) {
15899         {
15900             arg3 = wxString_in_helper(obj2);
15901             if (arg3 == NULL) SWIG_fail;
15902             temp3 = true;
15903         }
15904     }
15905     {
15906         PyThreadState* __tstate = wxPyBeginAllowThreads();
15907         result = (bool)(arg1)->Update(arg2,(wxString const &)*arg3);
15908
15909         wxPyEndAllowThreads(__tstate);
15910         if (PyErr_Occurred()) SWIG_fail;
15911     }
15912     {
15913         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15914     }
15915     {
15916         if (temp3)
15917         delete arg3;
15918     }
15919     return resultobj;
15920     fail:
15921     {
15922         if (temp3)
15923         delete arg3;
15924     }
15925     return NULL;
15926 }
15927
15928
15929 static PyObject *_wrap_ProgressDialog_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
15930     PyObject *resultobj;
15931     wxProgressDialog *arg1 = (wxProgressDialog *) 0 ;
15932     PyObject * obj0 = 0 ;
15933     char *kwnames[] = {
15934         (char *) "self", NULL
15935     };
15936
15937     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProgressDialog_Resume",kwnames,&obj0)) goto fail;
15938     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProgressDialog, SWIG_POINTER_EXCEPTION | 0);
15939     if (SWIG_arg_fail(1)) SWIG_fail;
15940     {
15941         PyThreadState* __tstate = wxPyBeginAllowThreads();
15942         (arg1)->Resume();
15943
15944         wxPyEndAllowThreads(__tstate);
15945         if (PyErr_Occurred()) SWIG_fail;
15946     }
15947     Py_INCREF(Py_None); resultobj = Py_None;
15948     return resultobj;
15949     fail:
15950     return NULL;
15951 }
15952
15953
15954 static PyObject * ProgressDialog_swigregister(PyObject *, PyObject *args) {
15955     PyObject *obj;
15956     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15957     SWIG_TypeClientData(SWIGTYPE_p_wxProgressDialog, obj);
15958     Py_INCREF(obj);
15959     return Py_BuildValue((char *)"");
15960 }
15961 static PyObject *_wrap_new_FindDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15962     PyObject *resultobj;
15963     wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15964     int arg2 = (int) 0 ;
15965     wxFindDialogEvent *result;
15966     PyObject * obj0 = 0 ;
15967     PyObject * obj1 = 0 ;
15968     char *kwnames[] = {
15969         (char *) "commandType",(char *) "id", NULL
15970     };
15971
15972     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FindDialogEvent",kwnames,&obj0,&obj1)) goto fail;
15973     if (obj0) {
15974         {
15975             arg1 = (wxEventType)(SWIG_As_int(obj0));
15976             if (SWIG_arg_fail(1)) SWIG_fail;
15977         }
15978     }
15979     if (obj1) {
15980         {
15981             arg2 = (int)(SWIG_As_int(obj1));
15982             if (SWIG_arg_fail(2)) SWIG_fail;
15983         }
15984     }
15985     {
15986         PyThreadState* __tstate = wxPyBeginAllowThreads();
15987         result = (wxFindDialogEvent *)new wxFindDialogEvent(arg1,arg2);
15988
15989         wxPyEndAllowThreads(__tstate);
15990         if (PyErr_Occurred()) SWIG_fail;
15991     }
15992     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindDialogEvent, 1);
15993     return resultobj;
15994     fail:
15995     return NULL;
15996 }
15997
15998
15999 static PyObject *_wrap_FindDialogEvent_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16000     PyObject *resultobj;
16001     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16002     int result;
16003     PyObject * obj0 = 0 ;
16004     char *kwnames[] = {
16005         (char *) "self", NULL
16006     };
16007
16008     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetFlags",kwnames,&obj0)) goto fail;
16009     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16010     if (SWIG_arg_fail(1)) SWIG_fail;
16011     {
16012         PyThreadState* __tstate = wxPyBeginAllowThreads();
16013         result = (int)(arg1)->GetFlags();
16014
16015         wxPyEndAllowThreads(__tstate);
16016         if (PyErr_Occurred()) SWIG_fail;
16017     }
16018     {
16019         resultobj = SWIG_From_int((int)(result));
16020     }
16021     return resultobj;
16022     fail:
16023     return NULL;
16024 }
16025
16026
16027 static PyObject *_wrap_FindDialogEvent_GetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16028     PyObject *resultobj;
16029     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16030     wxString *result;
16031     PyObject * obj0 = 0 ;
16032     char *kwnames[] = {
16033         (char *) "self", NULL
16034     };
16035
16036     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetFindString",kwnames,&obj0)) goto fail;
16037     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16038     if (SWIG_arg_fail(1)) SWIG_fail;
16039     {
16040         PyThreadState* __tstate = wxPyBeginAllowThreads();
16041         {
16042             wxString const &_result_ref = (arg1)->GetFindString();
16043             result = (wxString *) &_result_ref;
16044         }
16045
16046         wxPyEndAllowThreads(__tstate);
16047         if (PyErr_Occurred()) SWIG_fail;
16048     }
16049     {
16050 #if wxUSE_UNICODE
16051         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16052 #else
16053         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16054 #endif
16055     }
16056     return resultobj;
16057     fail:
16058     return NULL;
16059 }
16060
16061
16062 static PyObject *_wrap_FindDialogEvent_GetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16063     PyObject *resultobj;
16064     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16065     wxString *result;
16066     PyObject * obj0 = 0 ;
16067     char *kwnames[] = {
16068         (char *) "self", NULL
16069     };
16070
16071     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetReplaceString",kwnames,&obj0)) goto fail;
16072     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16073     if (SWIG_arg_fail(1)) SWIG_fail;
16074     {
16075         PyThreadState* __tstate = wxPyBeginAllowThreads();
16076         {
16077             wxString const &_result_ref = (arg1)->GetReplaceString();
16078             result = (wxString *) &_result_ref;
16079         }
16080
16081         wxPyEndAllowThreads(__tstate);
16082         if (PyErr_Occurred()) SWIG_fail;
16083     }
16084     {
16085 #if wxUSE_UNICODE
16086         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16087 #else
16088         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16089 #endif
16090     }
16091     return resultobj;
16092     fail:
16093     return NULL;
16094 }
16095
16096
16097 static PyObject *_wrap_FindDialogEvent_GetDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16098     PyObject *resultobj;
16099     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16100     wxFindReplaceDialog *result;
16101     PyObject * obj0 = 0 ;
16102     char *kwnames[] = {
16103         (char *) "self", NULL
16104     };
16105
16106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindDialogEvent_GetDialog",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 = (wxFindReplaceDialog *)(arg1)->GetDialog();
16112
16113         wxPyEndAllowThreads(__tstate);
16114         if (PyErr_Occurred()) SWIG_fail;
16115     }
16116     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 0);
16117     return resultobj;
16118     fail:
16119     return NULL;
16120 }
16121
16122
16123 static PyObject *_wrap_FindDialogEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16124     PyObject *resultobj;
16125     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16126     int arg2 ;
16127     PyObject * obj0 = 0 ;
16128     PyObject * obj1 = 0 ;
16129     char *kwnames[] = {
16130         (char *) "self",(char *) "flags", NULL
16131     };
16132
16133     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
16134     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16135     if (SWIG_arg_fail(1)) SWIG_fail;
16136     {
16137         arg2 = (int)(SWIG_As_int(obj1));
16138         if (SWIG_arg_fail(2)) SWIG_fail;
16139     }
16140     {
16141         PyThreadState* __tstate = wxPyBeginAllowThreads();
16142         (arg1)->SetFlags(arg2);
16143
16144         wxPyEndAllowThreads(__tstate);
16145         if (PyErr_Occurred()) SWIG_fail;
16146     }
16147     Py_INCREF(Py_None); resultobj = Py_None;
16148     return resultobj;
16149     fail:
16150     return NULL;
16151 }
16152
16153
16154 static PyObject *_wrap_FindDialogEvent_SetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16155     PyObject *resultobj;
16156     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16157     wxString *arg2 = 0 ;
16158     bool temp2 = false ;
16159     PyObject * obj0 = 0 ;
16160     PyObject * obj1 = 0 ;
16161     char *kwnames[] = {
16162         (char *) "self",(char *) "str", NULL
16163     };
16164
16165     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetFindString",kwnames,&obj0,&obj1)) goto fail;
16166     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16167     if (SWIG_arg_fail(1)) SWIG_fail;
16168     {
16169         arg2 = wxString_in_helper(obj1);
16170         if (arg2 == NULL) SWIG_fail;
16171         temp2 = true;
16172     }
16173     {
16174         PyThreadState* __tstate = wxPyBeginAllowThreads();
16175         (arg1)->SetFindString((wxString const &)*arg2);
16176
16177         wxPyEndAllowThreads(__tstate);
16178         if (PyErr_Occurred()) SWIG_fail;
16179     }
16180     Py_INCREF(Py_None); resultobj = Py_None;
16181     {
16182         if (temp2)
16183         delete arg2;
16184     }
16185     return resultobj;
16186     fail:
16187     {
16188         if (temp2)
16189         delete arg2;
16190     }
16191     return NULL;
16192 }
16193
16194
16195 static PyObject *_wrap_FindDialogEvent_SetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16196     PyObject *resultobj;
16197     wxFindDialogEvent *arg1 = (wxFindDialogEvent *) 0 ;
16198     wxString *arg2 = 0 ;
16199     bool temp2 = false ;
16200     PyObject * obj0 = 0 ;
16201     PyObject * obj1 = 0 ;
16202     char *kwnames[] = {
16203         (char *) "self",(char *) "str", NULL
16204     };
16205
16206     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindDialogEvent_SetReplaceString",kwnames,&obj0,&obj1)) goto fail;
16207     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindDialogEvent, SWIG_POINTER_EXCEPTION | 0);
16208     if (SWIG_arg_fail(1)) SWIG_fail;
16209     {
16210         arg2 = wxString_in_helper(obj1);
16211         if (arg2 == NULL) SWIG_fail;
16212         temp2 = true;
16213     }
16214     {
16215         PyThreadState* __tstate = wxPyBeginAllowThreads();
16216         (arg1)->SetReplaceString((wxString const &)*arg2);
16217
16218         wxPyEndAllowThreads(__tstate);
16219         if (PyErr_Occurred()) SWIG_fail;
16220     }
16221     Py_INCREF(Py_None); resultobj = Py_None;
16222     {
16223         if (temp2)
16224         delete arg2;
16225     }
16226     return resultobj;
16227     fail:
16228     {
16229         if (temp2)
16230         delete arg2;
16231     }
16232     return NULL;
16233 }
16234
16235
16236 static PyObject * FindDialogEvent_swigregister(PyObject *, PyObject *args) {
16237     PyObject *obj;
16238     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16239     SWIG_TypeClientData(SWIGTYPE_p_wxFindDialogEvent, obj);
16240     Py_INCREF(obj);
16241     return Py_BuildValue((char *)"");
16242 }
16243 static PyObject *_wrap_new_FindReplaceData(PyObject *, PyObject *args, PyObject *kwargs) {
16244     PyObject *resultobj;
16245     int arg1 = (int) 0 ;
16246     wxFindReplaceData *result;
16247     PyObject * obj0 = 0 ;
16248     char *kwnames[] = {
16249         (char *) "flags", NULL
16250     };
16251
16252     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_FindReplaceData",kwnames,&obj0)) goto fail;
16253     if (obj0) {
16254         {
16255             arg1 = (int)(SWIG_As_int(obj0));
16256             if (SWIG_arg_fail(1)) SWIG_fail;
16257         }
16258     }
16259     {
16260         PyThreadState* __tstate = wxPyBeginAllowThreads();
16261         result = (wxFindReplaceData *)new wxFindReplaceData(arg1);
16262
16263         wxPyEndAllowThreads(__tstate);
16264         if (PyErr_Occurred()) SWIG_fail;
16265     }
16266     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceData, 1);
16267     return resultobj;
16268     fail:
16269     return NULL;
16270 }
16271
16272
16273 static PyObject *_wrap_delete_FindReplaceData(PyObject *, PyObject *args, PyObject *kwargs) {
16274     PyObject *resultobj;
16275     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16276     PyObject * obj0 = 0 ;
16277     char *kwnames[] = {
16278         (char *) "self", NULL
16279     };
16280
16281     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FindReplaceData",kwnames,&obj0)) goto fail;
16282     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16283     if (SWIG_arg_fail(1)) SWIG_fail;
16284     {
16285         PyThreadState* __tstate = wxPyBeginAllowThreads();
16286         delete arg1;
16287
16288         wxPyEndAllowThreads(__tstate);
16289         if (PyErr_Occurred()) SWIG_fail;
16290     }
16291     Py_INCREF(Py_None); resultobj = Py_None;
16292     return resultobj;
16293     fail:
16294     return NULL;
16295 }
16296
16297
16298 static PyObject *_wrap_FindReplaceData_GetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16299     PyObject *resultobj;
16300     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16301     wxString *result;
16302     PyObject * obj0 = 0 ;
16303     char *kwnames[] = {
16304         (char *) "self", NULL
16305     };
16306
16307     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetFindString",kwnames,&obj0)) goto fail;
16308     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16309     if (SWIG_arg_fail(1)) SWIG_fail;
16310     {
16311         PyThreadState* __tstate = wxPyBeginAllowThreads();
16312         {
16313             wxString const &_result_ref = (arg1)->GetFindString();
16314             result = (wxString *) &_result_ref;
16315         }
16316
16317         wxPyEndAllowThreads(__tstate);
16318         if (PyErr_Occurred()) SWIG_fail;
16319     }
16320     {
16321 #if wxUSE_UNICODE
16322         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16323 #else
16324         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16325 #endif
16326     }
16327     return resultobj;
16328     fail:
16329     return NULL;
16330 }
16331
16332
16333 static PyObject *_wrap_FindReplaceData_GetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16334     PyObject *resultobj;
16335     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16336     wxString *result;
16337     PyObject * obj0 = 0 ;
16338     char *kwnames[] = {
16339         (char *) "self", NULL
16340     };
16341
16342     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetReplaceString",kwnames,&obj0)) goto fail;
16343     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16344     if (SWIG_arg_fail(1)) SWIG_fail;
16345     {
16346         PyThreadState* __tstate = wxPyBeginAllowThreads();
16347         {
16348             wxString const &_result_ref = (arg1)->GetReplaceString();
16349             result = (wxString *) &_result_ref;
16350         }
16351
16352         wxPyEndAllowThreads(__tstate);
16353         if (PyErr_Occurred()) SWIG_fail;
16354     }
16355     {
16356 #if wxUSE_UNICODE
16357         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16358 #else
16359         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16360 #endif
16361     }
16362     return resultobj;
16363     fail:
16364     return NULL;
16365 }
16366
16367
16368 static PyObject *_wrap_FindReplaceData_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16369     PyObject *resultobj;
16370     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16371     int result;
16372     PyObject * obj0 = 0 ;
16373     char *kwnames[] = {
16374         (char *) "self", NULL
16375     };
16376
16377     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceData_GetFlags",kwnames,&obj0)) goto fail;
16378     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16379     if (SWIG_arg_fail(1)) SWIG_fail;
16380     {
16381         PyThreadState* __tstate = wxPyBeginAllowThreads();
16382         result = (int)(arg1)->GetFlags();
16383
16384         wxPyEndAllowThreads(__tstate);
16385         if (PyErr_Occurred()) SWIG_fail;
16386     }
16387     {
16388         resultobj = SWIG_From_int((int)(result));
16389     }
16390     return resultobj;
16391     fail:
16392     return NULL;
16393 }
16394
16395
16396 static PyObject *_wrap_FindReplaceData_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
16397     PyObject *resultobj;
16398     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16399     int arg2 ;
16400     PyObject * obj0 = 0 ;
16401     PyObject * obj1 = 0 ;
16402     char *kwnames[] = {
16403         (char *) "self",(char *) "flags", NULL
16404     };
16405
16406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetFlags",kwnames,&obj0,&obj1)) goto fail;
16407     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16408     if (SWIG_arg_fail(1)) SWIG_fail;
16409     {
16410         arg2 = (int)(SWIG_As_int(obj1));
16411         if (SWIG_arg_fail(2)) SWIG_fail;
16412     }
16413     {
16414         PyThreadState* __tstate = wxPyBeginAllowThreads();
16415         (arg1)->SetFlags(arg2);
16416
16417         wxPyEndAllowThreads(__tstate);
16418         if (PyErr_Occurred()) SWIG_fail;
16419     }
16420     Py_INCREF(Py_None); resultobj = Py_None;
16421     return resultobj;
16422     fail:
16423     return NULL;
16424 }
16425
16426
16427 static PyObject *_wrap_FindReplaceData_SetFindString(PyObject *, PyObject *args, PyObject *kwargs) {
16428     PyObject *resultobj;
16429     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16430     wxString *arg2 = 0 ;
16431     bool temp2 = false ;
16432     PyObject * obj0 = 0 ;
16433     PyObject * obj1 = 0 ;
16434     char *kwnames[] = {
16435         (char *) "self",(char *) "str", NULL
16436     };
16437
16438     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetFindString",kwnames,&obj0,&obj1)) goto fail;
16439     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16440     if (SWIG_arg_fail(1)) SWIG_fail;
16441     {
16442         arg2 = wxString_in_helper(obj1);
16443         if (arg2 == NULL) SWIG_fail;
16444         temp2 = true;
16445     }
16446     {
16447         PyThreadState* __tstate = wxPyBeginAllowThreads();
16448         (arg1)->SetFindString((wxString const &)*arg2);
16449
16450         wxPyEndAllowThreads(__tstate);
16451         if (PyErr_Occurred()) SWIG_fail;
16452     }
16453     Py_INCREF(Py_None); resultobj = Py_None;
16454     {
16455         if (temp2)
16456         delete arg2;
16457     }
16458     return resultobj;
16459     fail:
16460     {
16461         if (temp2)
16462         delete arg2;
16463     }
16464     return NULL;
16465 }
16466
16467
16468 static PyObject *_wrap_FindReplaceData_SetReplaceString(PyObject *, PyObject *args, PyObject *kwargs) {
16469     PyObject *resultobj;
16470     wxFindReplaceData *arg1 = (wxFindReplaceData *) 0 ;
16471     wxString *arg2 = 0 ;
16472     bool temp2 = false ;
16473     PyObject * obj0 = 0 ;
16474     PyObject * obj1 = 0 ;
16475     char *kwnames[] = {
16476         (char *) "self",(char *) "str", NULL
16477     };
16478
16479     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceData_SetReplaceString",kwnames,&obj0,&obj1)) goto fail;
16480     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16481     if (SWIG_arg_fail(1)) SWIG_fail;
16482     {
16483         arg2 = wxString_in_helper(obj1);
16484         if (arg2 == NULL) SWIG_fail;
16485         temp2 = true;
16486     }
16487     {
16488         PyThreadState* __tstate = wxPyBeginAllowThreads();
16489         (arg1)->SetReplaceString((wxString const &)*arg2);
16490
16491         wxPyEndAllowThreads(__tstate);
16492         if (PyErr_Occurred()) SWIG_fail;
16493     }
16494     Py_INCREF(Py_None); resultobj = Py_None;
16495     {
16496         if (temp2)
16497         delete arg2;
16498     }
16499     return resultobj;
16500     fail:
16501     {
16502         if (temp2)
16503         delete arg2;
16504     }
16505     return NULL;
16506 }
16507
16508
16509 static PyObject * FindReplaceData_swigregister(PyObject *, PyObject *args) {
16510     PyObject *obj;
16511     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16512     SWIG_TypeClientData(SWIGTYPE_p_wxFindReplaceData, obj);
16513     Py_INCREF(obj);
16514     return Py_BuildValue((char *)"");
16515 }
16516 static PyObject *_wrap_new_FindReplaceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16517     PyObject *resultobj;
16518     wxWindow *arg1 = (wxWindow *) 0 ;
16519     wxFindReplaceData *arg2 = (wxFindReplaceData *) 0 ;
16520     wxString *arg3 = 0 ;
16521     int arg4 = (int) 0 ;
16522     wxFindReplaceDialog *result;
16523     bool temp3 = false ;
16524     PyObject * obj0 = 0 ;
16525     PyObject * obj1 = 0 ;
16526     PyObject * obj2 = 0 ;
16527     PyObject * obj3 = 0 ;
16528     char *kwnames[] = {
16529         (char *) "parent",(char *) "data",(char *) "title",(char *) "style", NULL
16530     };
16531
16532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_FindReplaceDialog",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16533     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16534     if (SWIG_arg_fail(1)) SWIG_fail;
16535     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16536     if (SWIG_arg_fail(2)) SWIG_fail;
16537     {
16538         arg3 = wxString_in_helper(obj2);
16539         if (arg3 == NULL) SWIG_fail;
16540         temp3 = true;
16541     }
16542     if (obj3) {
16543         {
16544             arg4 = (int)(SWIG_As_int(obj3));
16545             if (SWIG_arg_fail(4)) SWIG_fail;
16546         }
16547     }
16548     {
16549         if (!wxPyCheckForApp()) SWIG_fail;
16550         PyThreadState* __tstate = wxPyBeginAllowThreads();
16551         result = (wxFindReplaceDialog *)new wxFindReplaceDialog(arg1,arg2,(wxString const &)*arg3,arg4);
16552
16553         wxPyEndAllowThreads(__tstate);
16554         if (PyErr_Occurred()) SWIG_fail;
16555     }
16556     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 1);
16557     {
16558         if (temp3)
16559         delete arg3;
16560     }
16561     return resultobj;
16562     fail:
16563     {
16564         if (temp3)
16565         delete arg3;
16566     }
16567     return NULL;
16568 }
16569
16570
16571 static PyObject *_wrap_new_PreFindReplaceDialog(PyObject *, PyObject *args, PyObject *kwargs) {
16572     PyObject *resultobj;
16573     wxFindReplaceDialog *result;
16574     char *kwnames[] = {
16575         NULL
16576     };
16577
16578     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreFindReplaceDialog",kwnames)) goto fail;
16579     {
16580         if (!wxPyCheckForApp()) SWIG_fail;
16581         PyThreadState* __tstate = wxPyBeginAllowThreads();
16582         result = (wxFindReplaceDialog *)new wxFindReplaceDialog();
16583
16584         wxPyEndAllowThreads(__tstate);
16585         if (PyErr_Occurred()) SWIG_fail;
16586     }
16587     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceDialog, 1);
16588     return resultobj;
16589     fail:
16590     return NULL;
16591 }
16592
16593
16594 static PyObject *_wrap_FindReplaceDialog_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16595     PyObject *resultobj;
16596     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16597     wxWindow *arg2 = (wxWindow *) 0 ;
16598     wxFindReplaceData *arg3 = (wxFindReplaceData *) 0 ;
16599     wxString *arg4 = 0 ;
16600     int arg5 = (int) 0 ;
16601     bool result;
16602     bool temp4 = false ;
16603     PyObject * obj0 = 0 ;
16604     PyObject * obj1 = 0 ;
16605     PyObject * obj2 = 0 ;
16606     PyObject * obj3 = 0 ;
16607     PyObject * obj4 = 0 ;
16608     char *kwnames[] = {
16609         (char *) "self",(char *) "parent",(char *) "data",(char *) "title",(char *) "style", NULL
16610     };
16611
16612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:FindReplaceDialog_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
16613     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16614     if (SWIG_arg_fail(1)) SWIG_fail;
16615     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16616     if (SWIG_arg_fail(2)) SWIG_fail;
16617     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16618     if (SWIG_arg_fail(3)) SWIG_fail;
16619     {
16620         arg4 = wxString_in_helper(obj3);
16621         if (arg4 == NULL) SWIG_fail;
16622         temp4 = true;
16623     }
16624     if (obj4) {
16625         {
16626             arg5 = (int)(SWIG_As_int(obj4));
16627             if (SWIG_arg_fail(5)) SWIG_fail;
16628         }
16629     }
16630     {
16631         PyThreadState* __tstate = wxPyBeginAllowThreads();
16632         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,arg5);
16633
16634         wxPyEndAllowThreads(__tstate);
16635         if (PyErr_Occurred()) SWIG_fail;
16636     }
16637     {
16638         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16639     }
16640     {
16641         if (temp4)
16642         delete arg4;
16643     }
16644     return resultobj;
16645     fail:
16646     {
16647         if (temp4)
16648         delete arg4;
16649     }
16650     return NULL;
16651 }
16652
16653
16654 static PyObject *_wrap_FindReplaceDialog_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
16655     PyObject *resultobj;
16656     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16657     wxFindReplaceData *result;
16658     PyObject * obj0 = 0 ;
16659     char *kwnames[] = {
16660         (char *) "self", NULL
16661     };
16662
16663     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindReplaceDialog_GetData",kwnames,&obj0)) goto fail;
16664     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16665     if (SWIG_arg_fail(1)) SWIG_fail;
16666     {
16667         PyThreadState* __tstate = wxPyBeginAllowThreads();
16668         result = (wxFindReplaceData *)(arg1)->GetData();
16669
16670         wxPyEndAllowThreads(__tstate);
16671         if (PyErr_Occurred()) SWIG_fail;
16672     }
16673     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFindReplaceData, 0);
16674     return resultobj;
16675     fail:
16676     return NULL;
16677 }
16678
16679
16680 static PyObject *_wrap_FindReplaceDialog_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
16681     PyObject *resultobj;
16682     wxFindReplaceDialog *arg1 = (wxFindReplaceDialog *) 0 ;
16683     wxFindReplaceData *arg2 = (wxFindReplaceData *) 0 ;
16684     PyObject * obj0 = 0 ;
16685     PyObject * obj1 = 0 ;
16686     char *kwnames[] = {
16687         (char *) "self",(char *) "data", NULL
16688     };
16689
16690     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FindReplaceDialog_SetData",kwnames,&obj0,&obj1)) goto fail;
16691     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFindReplaceDialog, SWIG_POINTER_EXCEPTION | 0);
16692     if (SWIG_arg_fail(1)) SWIG_fail;
16693     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFindReplaceData, SWIG_POINTER_EXCEPTION | 0);
16694     if (SWIG_arg_fail(2)) SWIG_fail;
16695     {
16696         PyThreadState* __tstate = wxPyBeginAllowThreads();
16697         (arg1)->SetData(arg2);
16698
16699         wxPyEndAllowThreads(__tstate);
16700         if (PyErr_Occurred()) SWIG_fail;
16701     }
16702     Py_INCREF(Py_None); resultobj = Py_None;
16703     return resultobj;
16704     fail:
16705     return NULL;
16706 }
16707
16708
16709 static PyObject * FindReplaceDialog_swigregister(PyObject *, PyObject *args) {
16710     PyObject *obj;
16711     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16712     SWIG_TypeClientData(SWIGTYPE_p_wxFindReplaceDialog, obj);
16713     Py_INCREF(obj);
16714     return Py_BuildValue((char *)"");
16715 }
16716 static PyObject *_wrap_new_MDIParentFrame(PyObject *, PyObject *args, PyObject *kwargs) {
16717     PyObject *resultobj;
16718     wxWindow *arg1 = (wxWindow *) 0 ;
16719     int arg2 = (int) (int)-1 ;
16720     wxString const &arg3_defvalue = wxPyEmptyString ;
16721     wxString *arg3 = (wxString *) &arg3_defvalue ;
16722     wxPoint const &arg4_defvalue = wxDefaultPosition ;
16723     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
16724     wxSize const &arg5_defvalue = wxDefaultSize ;
16725     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
16726     long arg6 = (long) wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL ;
16727     wxString const &arg7_defvalue = wxPyFrameNameStr ;
16728     wxString *arg7 = (wxString *) &arg7_defvalue ;
16729     wxMDIParentFrame *result;
16730     bool temp3 = false ;
16731     wxPoint temp4 ;
16732     wxSize temp5 ;
16733     bool temp7 = false ;
16734     PyObject * obj0 = 0 ;
16735     PyObject * obj1 = 0 ;
16736     PyObject * obj2 = 0 ;
16737     PyObject * obj3 = 0 ;
16738     PyObject * obj4 = 0 ;
16739     PyObject * obj5 = 0 ;
16740     PyObject * obj6 = 0 ;
16741     char *kwnames[] = {
16742         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
16743     };
16744
16745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MDIParentFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
16746     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16747     if (SWIG_arg_fail(1)) SWIG_fail;
16748     if (obj1) {
16749         {
16750             arg2 = (int const)(SWIG_As_int(obj1));
16751             if (SWIG_arg_fail(2)) SWIG_fail;
16752         }
16753     }
16754     if (obj2) {
16755         {
16756             arg3 = wxString_in_helper(obj2);
16757             if (arg3 == NULL) SWIG_fail;
16758             temp3 = true;
16759         }
16760     }
16761     if (obj3) {
16762         {
16763             arg4 = &temp4;
16764             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
16765         }
16766     }
16767     if (obj4) {
16768         {
16769             arg5 = &temp5;
16770             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
16771         }
16772     }
16773     if (obj5) {
16774         {
16775             arg6 = (long)(SWIG_As_long(obj5));
16776             if (SWIG_arg_fail(6)) SWIG_fail;
16777         }
16778     }
16779     if (obj6) {
16780         {
16781             arg7 = wxString_in_helper(obj6);
16782             if (arg7 == NULL) SWIG_fail;
16783             temp7 = true;
16784         }
16785     }
16786     {
16787         if (!wxPyCheckForApp()) SWIG_fail;
16788         PyThreadState* __tstate = wxPyBeginAllowThreads();
16789         result = (wxMDIParentFrame *)new wxMDIParentFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
16790
16791         wxPyEndAllowThreads(__tstate);
16792         if (PyErr_Occurred()) SWIG_fail;
16793     }
16794     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIParentFrame, 1);
16795     {
16796         if (temp3)
16797         delete arg3;
16798     }
16799     {
16800         if (temp7)
16801         delete arg7;
16802     }
16803     return resultobj;
16804     fail:
16805     {
16806         if (temp3)
16807         delete arg3;
16808     }
16809     {
16810         if (temp7)
16811         delete arg7;
16812     }
16813     return NULL;
16814 }
16815
16816
16817 static PyObject *_wrap_new_PreMDIParentFrame(PyObject *, PyObject *args, PyObject *kwargs) {
16818     PyObject *resultobj;
16819     wxMDIParentFrame *result;
16820     char *kwnames[] = {
16821         NULL
16822     };
16823
16824     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIParentFrame",kwnames)) goto fail;
16825     {
16826         if (!wxPyCheckForApp()) SWIG_fail;
16827         PyThreadState* __tstate = wxPyBeginAllowThreads();
16828         result = (wxMDIParentFrame *)new wxMDIParentFrame();
16829
16830         wxPyEndAllowThreads(__tstate);
16831         if (PyErr_Occurred()) SWIG_fail;
16832     }
16833     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIParentFrame, 1);
16834     return resultobj;
16835     fail:
16836     return NULL;
16837 }
16838
16839
16840 static PyObject *_wrap_MDIParentFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16841     PyObject *resultobj;
16842     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
16843     wxWindow *arg2 = (wxWindow *) 0 ;
16844     int arg3 = (int) (int)-1 ;
16845     wxString const &arg4_defvalue = wxPyEmptyString ;
16846     wxString *arg4 = (wxString *) &arg4_defvalue ;
16847     wxPoint const &arg5_defvalue = wxDefaultPosition ;
16848     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
16849     wxSize const &arg6_defvalue = wxDefaultSize ;
16850     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
16851     long arg7 = (long) wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL ;
16852     wxString const &arg8_defvalue = wxPyFrameNameStr ;
16853     wxString *arg8 = (wxString *) &arg8_defvalue ;
16854     bool result;
16855     bool temp4 = false ;
16856     wxPoint temp5 ;
16857     wxSize temp6 ;
16858     bool temp8 = false ;
16859     PyObject * obj0 = 0 ;
16860     PyObject * obj1 = 0 ;
16861     PyObject * obj2 = 0 ;
16862     PyObject * obj3 = 0 ;
16863     PyObject * obj4 = 0 ;
16864     PyObject * obj5 = 0 ;
16865     PyObject * obj6 = 0 ;
16866     PyObject * obj7 = 0 ;
16867     char *kwnames[] = {
16868         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
16869     };
16870
16871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MDIParentFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
16872     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
16873     if (SWIG_arg_fail(1)) SWIG_fail;
16874     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
16875     if (SWIG_arg_fail(2)) SWIG_fail;
16876     if (obj2) {
16877         {
16878             arg3 = (int const)(SWIG_As_int(obj2));
16879             if (SWIG_arg_fail(3)) SWIG_fail;
16880         }
16881     }
16882     if (obj3) {
16883         {
16884             arg4 = wxString_in_helper(obj3);
16885             if (arg4 == NULL) SWIG_fail;
16886             temp4 = true;
16887         }
16888     }
16889     if (obj4) {
16890         {
16891             arg5 = &temp5;
16892             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
16893         }
16894     }
16895     if (obj5) {
16896         {
16897             arg6 = &temp6;
16898             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
16899         }
16900     }
16901     if (obj6) {
16902         {
16903             arg7 = (long)(SWIG_As_long(obj6));
16904             if (SWIG_arg_fail(7)) SWIG_fail;
16905         }
16906     }
16907     if (obj7) {
16908         {
16909             arg8 = wxString_in_helper(obj7);
16910             if (arg8 == NULL) SWIG_fail;
16911             temp8 = true;
16912         }
16913     }
16914     {
16915         PyThreadState* __tstate = wxPyBeginAllowThreads();
16916         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
16917
16918         wxPyEndAllowThreads(__tstate);
16919         if (PyErr_Occurred()) SWIG_fail;
16920     }
16921     {
16922         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16923     }
16924     {
16925         if (temp4)
16926         delete arg4;
16927     }
16928     {
16929         if (temp8)
16930         delete arg8;
16931     }
16932     return resultobj;
16933     fail:
16934     {
16935         if (temp4)
16936         delete arg4;
16937     }
16938     {
16939         if (temp8)
16940         delete arg8;
16941     }
16942     return NULL;
16943 }
16944
16945
16946 static PyObject *_wrap_MDIParentFrame_ActivateNext(PyObject *, PyObject *args, PyObject *kwargs) {
16947     PyObject *resultobj;
16948     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
16949     PyObject * obj0 = 0 ;
16950     char *kwnames[] = {
16951         (char *) "self", NULL
16952     };
16953
16954     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ActivateNext",kwnames,&obj0)) goto fail;
16955     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
16956     if (SWIG_arg_fail(1)) SWIG_fail;
16957     {
16958         PyThreadState* __tstate = wxPyBeginAllowThreads();
16959         (arg1)->ActivateNext();
16960
16961         wxPyEndAllowThreads(__tstate);
16962         if (PyErr_Occurred()) SWIG_fail;
16963     }
16964     Py_INCREF(Py_None); resultobj = Py_None;
16965     return resultobj;
16966     fail:
16967     return NULL;
16968 }
16969
16970
16971 static PyObject *_wrap_MDIParentFrame_ActivatePrevious(PyObject *, PyObject *args, PyObject *kwargs) {
16972     PyObject *resultobj;
16973     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
16974     PyObject * obj0 = 0 ;
16975     char *kwnames[] = {
16976         (char *) "self", NULL
16977     };
16978
16979     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ActivatePrevious",kwnames,&obj0)) goto fail;
16980     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
16981     if (SWIG_arg_fail(1)) SWIG_fail;
16982     {
16983         PyThreadState* __tstate = wxPyBeginAllowThreads();
16984         (arg1)->ActivatePrevious();
16985
16986         wxPyEndAllowThreads(__tstate);
16987         if (PyErr_Occurred()) SWIG_fail;
16988     }
16989     Py_INCREF(Py_None); resultobj = Py_None;
16990     return resultobj;
16991     fail:
16992     return NULL;
16993 }
16994
16995
16996 static PyObject *_wrap_MDIParentFrame_ArrangeIcons(PyObject *, PyObject *args, PyObject *kwargs) {
16997     PyObject *resultobj;
16998     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
16999     PyObject * obj0 = 0 ;
17000     char *kwnames[] = {
17001         (char *) "self", NULL
17002     };
17003
17004     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_ArrangeIcons",kwnames,&obj0)) goto fail;
17005     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17006     if (SWIG_arg_fail(1)) SWIG_fail;
17007     {
17008         PyThreadState* __tstate = wxPyBeginAllowThreads();
17009         (arg1)->ArrangeIcons();
17010
17011         wxPyEndAllowThreads(__tstate);
17012         if (PyErr_Occurred()) SWIG_fail;
17013     }
17014     Py_INCREF(Py_None); resultobj = Py_None;
17015     return resultobj;
17016     fail:
17017     return NULL;
17018 }
17019
17020
17021 static PyObject *_wrap_MDIParentFrame_Cascade(PyObject *, PyObject *args, PyObject *kwargs) {
17022     PyObject *resultobj;
17023     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17024     PyObject * obj0 = 0 ;
17025     char *kwnames[] = {
17026         (char *) "self", NULL
17027     };
17028
17029     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_Cascade",kwnames,&obj0)) goto fail;
17030     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17031     if (SWIG_arg_fail(1)) SWIG_fail;
17032     {
17033         PyThreadState* __tstate = wxPyBeginAllowThreads();
17034         (arg1)->Cascade();
17035
17036         wxPyEndAllowThreads(__tstate);
17037         if (PyErr_Occurred()) SWIG_fail;
17038     }
17039     Py_INCREF(Py_None); resultobj = Py_None;
17040     return resultobj;
17041     fail:
17042     return NULL;
17043 }
17044
17045
17046 static PyObject *_wrap_MDIParentFrame_GetActiveChild(PyObject *, PyObject *args, PyObject *kwargs) {
17047     PyObject *resultobj;
17048     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17049     wxMDIChildFrame *result;
17050     PyObject * obj0 = 0 ;
17051     char *kwnames[] = {
17052         (char *) "self", NULL
17053     };
17054
17055     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetActiveChild",kwnames,&obj0)) goto fail;
17056     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17057     if (SWIG_arg_fail(1)) SWIG_fail;
17058     {
17059         PyThreadState* __tstate = wxPyBeginAllowThreads();
17060         result = (wxMDIChildFrame *)(arg1)->GetActiveChild();
17061
17062         wxPyEndAllowThreads(__tstate);
17063         if (PyErr_Occurred()) SWIG_fail;
17064     }
17065     {
17066         resultobj = wxPyMake_wxObject(result, 0);
17067     }
17068     return resultobj;
17069     fail:
17070     return NULL;
17071 }
17072
17073
17074 static PyObject *_wrap_MDIParentFrame_GetClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17075     PyObject *resultobj;
17076     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17077     wxMDIClientWindow *result;
17078     PyObject * obj0 = 0 ;
17079     char *kwnames[] = {
17080         (char *) "self", NULL
17081     };
17082
17083     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetClientWindow",kwnames,&obj0)) goto fail;
17084     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17085     if (SWIG_arg_fail(1)) SWIG_fail;
17086     {
17087         PyThreadState* __tstate = wxPyBeginAllowThreads();
17088         result = (wxMDIClientWindow *)(arg1)->GetClientWindow();
17089
17090         wxPyEndAllowThreads(__tstate);
17091         if (PyErr_Occurred()) SWIG_fail;
17092     }
17093     {
17094         resultobj = wxPyMake_wxObject(result, 0);
17095     }
17096     return resultobj;
17097     fail:
17098     return NULL;
17099 }
17100
17101
17102 static PyObject *_wrap_MDIParentFrame_GetToolBar(PyObject *, PyObject *args, PyObject *kwargs) {
17103     PyObject *resultobj;
17104     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17105     wxWindow *result;
17106     PyObject * obj0 = 0 ;
17107     char *kwnames[] = {
17108         (char *) "self", NULL
17109     };
17110
17111     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIParentFrame_GetToolBar",kwnames,&obj0)) goto fail;
17112     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17113     if (SWIG_arg_fail(1)) SWIG_fail;
17114     {
17115         PyThreadState* __tstate = wxPyBeginAllowThreads();
17116         result = (wxWindow *)(arg1)->GetToolBar();
17117
17118         wxPyEndAllowThreads(__tstate);
17119         if (PyErr_Occurred()) SWIG_fail;
17120     }
17121     {
17122         resultobj = wxPyMake_wxObject(result, 0);
17123     }
17124     return resultobj;
17125     fail:
17126     return NULL;
17127 }
17128
17129
17130 static PyObject *_wrap_MDIParentFrame_Tile(PyObject *, PyObject *args, PyObject *kwargs) {
17131     PyObject *resultobj;
17132     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17133     wxOrientation arg2 = (wxOrientation) wxHORIZONTAL ;
17134     PyObject * obj0 = 0 ;
17135     PyObject * obj1 = 0 ;
17136     char *kwnames[] = {
17137         (char *) "self",(char *) "orient", NULL
17138     };
17139
17140     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MDIParentFrame_Tile",kwnames,&obj0,&obj1)) goto fail;
17141     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17142     if (SWIG_arg_fail(1)) SWIG_fail;
17143     if (obj1) {
17144         {
17145             arg2 = (wxOrientation)(SWIG_As_int(obj1));
17146             if (SWIG_arg_fail(2)) SWIG_fail;
17147         }
17148     }
17149     {
17150         PyThreadState* __tstate = wxPyBeginAllowThreads();
17151         (arg1)->Tile((wxOrientation )arg2);
17152
17153         wxPyEndAllowThreads(__tstate);
17154         if (PyErr_Occurred()) SWIG_fail;
17155     }
17156     Py_INCREF(Py_None); resultobj = Py_None;
17157     return resultobj;
17158     fail:
17159     return NULL;
17160 }
17161
17162
17163 static PyObject * MDIParentFrame_swigregister(PyObject *, PyObject *args) {
17164     PyObject *obj;
17165     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17166     SWIG_TypeClientData(SWIGTYPE_p_wxMDIParentFrame, obj);
17167     Py_INCREF(obj);
17168     return Py_BuildValue((char *)"");
17169 }
17170 static PyObject *_wrap_new_MDIChildFrame(PyObject *, PyObject *args, PyObject *kwargs) {
17171     PyObject *resultobj;
17172     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17173     int arg2 = (int) (int)-1 ;
17174     wxString const &arg3_defvalue = wxPyEmptyString ;
17175     wxString *arg3 = (wxString *) &arg3_defvalue ;
17176     wxPoint const &arg4_defvalue = wxDefaultPosition ;
17177     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
17178     wxSize const &arg5_defvalue = wxDefaultSize ;
17179     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
17180     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
17181     wxString const &arg7_defvalue = wxPyFrameNameStr ;
17182     wxString *arg7 = (wxString *) &arg7_defvalue ;
17183     wxMDIChildFrame *result;
17184     bool temp3 = false ;
17185     wxPoint temp4 ;
17186     wxSize temp5 ;
17187     bool temp7 = false ;
17188     PyObject * obj0 = 0 ;
17189     PyObject * obj1 = 0 ;
17190     PyObject * obj2 = 0 ;
17191     PyObject * obj3 = 0 ;
17192     PyObject * obj4 = 0 ;
17193     PyObject * obj5 = 0 ;
17194     PyObject * obj6 = 0 ;
17195     char *kwnames[] = {
17196         (char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17197     };
17198
17199     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_MDIChildFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
17200     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17201     if (SWIG_arg_fail(1)) SWIG_fail;
17202     if (obj1) {
17203         {
17204             arg2 = (int const)(SWIG_As_int(obj1));
17205             if (SWIG_arg_fail(2)) SWIG_fail;
17206         }
17207     }
17208     if (obj2) {
17209         {
17210             arg3 = wxString_in_helper(obj2);
17211             if (arg3 == NULL) SWIG_fail;
17212             temp3 = true;
17213         }
17214     }
17215     if (obj3) {
17216         {
17217             arg4 = &temp4;
17218             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17219         }
17220     }
17221     if (obj4) {
17222         {
17223             arg5 = &temp5;
17224             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
17225         }
17226     }
17227     if (obj5) {
17228         {
17229             arg6 = (long)(SWIG_As_long(obj5));
17230             if (SWIG_arg_fail(6)) SWIG_fail;
17231         }
17232     }
17233     if (obj6) {
17234         {
17235             arg7 = wxString_in_helper(obj6);
17236             if (arg7 == NULL) SWIG_fail;
17237             temp7 = true;
17238         }
17239     }
17240     {
17241         if (!wxPyCheckForApp()) SWIG_fail;
17242         PyThreadState* __tstate = wxPyBeginAllowThreads();
17243         result = (wxMDIChildFrame *)new wxMDIChildFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
17244
17245         wxPyEndAllowThreads(__tstate);
17246         if (PyErr_Occurred()) SWIG_fail;
17247     }
17248     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIChildFrame, 1);
17249     {
17250         if (temp3)
17251         delete arg3;
17252     }
17253     {
17254         if (temp7)
17255         delete arg7;
17256     }
17257     return resultobj;
17258     fail:
17259     {
17260         if (temp3)
17261         delete arg3;
17262     }
17263     {
17264         if (temp7)
17265         delete arg7;
17266     }
17267     return NULL;
17268 }
17269
17270
17271 static PyObject *_wrap_new_PreMDIChildFrame(PyObject *, PyObject *args, PyObject *kwargs) {
17272     PyObject *resultobj;
17273     wxMDIChildFrame *result;
17274     char *kwnames[] = {
17275         NULL
17276     };
17277
17278     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIChildFrame",kwnames)) goto fail;
17279     {
17280         if (!wxPyCheckForApp()) SWIG_fail;
17281         PyThreadState* __tstate = wxPyBeginAllowThreads();
17282         result = (wxMDIChildFrame *)new wxMDIChildFrame();
17283
17284         wxPyEndAllowThreads(__tstate);
17285         if (PyErr_Occurred()) SWIG_fail;
17286     }
17287     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIChildFrame, 1);
17288     return resultobj;
17289     fail:
17290     return NULL;
17291 }
17292
17293
17294 static PyObject *_wrap_MDIChildFrame_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17295     PyObject *resultobj;
17296     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17297     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
17298     int arg3 = (int) (int)-1 ;
17299     wxString const &arg4_defvalue = wxPyEmptyString ;
17300     wxString *arg4 = (wxString *) &arg4_defvalue ;
17301     wxPoint const &arg5_defvalue = wxDefaultPosition ;
17302     wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
17303     wxSize const &arg6_defvalue = wxDefaultSize ;
17304     wxSize *arg6 = (wxSize *) &arg6_defvalue ;
17305     long arg7 = (long) wxDEFAULT_FRAME_STYLE ;
17306     wxString const &arg8_defvalue = wxPyFrameNameStr ;
17307     wxString *arg8 = (wxString *) &arg8_defvalue ;
17308     bool result;
17309     bool temp4 = false ;
17310     wxPoint temp5 ;
17311     wxSize temp6 ;
17312     bool temp8 = false ;
17313     PyObject * obj0 = 0 ;
17314     PyObject * obj1 = 0 ;
17315     PyObject * obj2 = 0 ;
17316     PyObject * obj3 = 0 ;
17317     PyObject * obj4 = 0 ;
17318     PyObject * obj5 = 0 ;
17319     PyObject * obj6 = 0 ;
17320     PyObject * obj7 = 0 ;
17321     char *kwnames[] = {
17322         (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17323     };
17324
17325     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:MDIChildFrame_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
17326     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17327     if (SWIG_arg_fail(1)) SWIG_fail;
17328     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17329     if (SWIG_arg_fail(2)) SWIG_fail;
17330     if (obj2) {
17331         {
17332             arg3 = (int const)(SWIG_As_int(obj2));
17333             if (SWIG_arg_fail(3)) SWIG_fail;
17334         }
17335     }
17336     if (obj3) {
17337         {
17338             arg4 = wxString_in_helper(obj3);
17339             if (arg4 == NULL) SWIG_fail;
17340             temp4 = true;
17341         }
17342     }
17343     if (obj4) {
17344         {
17345             arg5 = &temp5;
17346             if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
17347         }
17348     }
17349     if (obj5) {
17350         {
17351             arg6 = &temp6;
17352             if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
17353         }
17354     }
17355     if (obj6) {
17356         {
17357             arg7 = (long)(SWIG_As_long(obj6));
17358             if (SWIG_arg_fail(7)) SWIG_fail;
17359         }
17360     }
17361     if (obj7) {
17362         {
17363             arg8 = wxString_in_helper(obj7);
17364             if (arg8 == NULL) SWIG_fail;
17365             temp8 = true;
17366         }
17367     }
17368     {
17369         PyThreadState* __tstate = wxPyBeginAllowThreads();
17370         result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
17371
17372         wxPyEndAllowThreads(__tstate);
17373         if (PyErr_Occurred()) SWIG_fail;
17374     }
17375     {
17376         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17377     }
17378     {
17379         if (temp4)
17380         delete arg4;
17381     }
17382     {
17383         if (temp8)
17384         delete arg8;
17385     }
17386     return resultobj;
17387     fail:
17388     {
17389         if (temp4)
17390         delete arg4;
17391     }
17392     {
17393         if (temp8)
17394         delete arg8;
17395     }
17396     return NULL;
17397 }
17398
17399
17400 static PyObject *_wrap_MDIChildFrame_Activate(PyObject *, PyObject *args, PyObject *kwargs) {
17401     PyObject *resultobj;
17402     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17403     PyObject * obj0 = 0 ;
17404     char *kwnames[] = {
17405         (char *) "self", NULL
17406     };
17407
17408     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIChildFrame_Activate",kwnames,&obj0)) goto fail;
17409     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17410     if (SWIG_arg_fail(1)) SWIG_fail;
17411     {
17412         PyThreadState* __tstate = wxPyBeginAllowThreads();
17413         (arg1)->Activate();
17414
17415         wxPyEndAllowThreads(__tstate);
17416         if (PyErr_Occurred()) SWIG_fail;
17417     }
17418     Py_INCREF(Py_None); resultobj = Py_None;
17419     return resultobj;
17420     fail:
17421     return NULL;
17422 }
17423
17424
17425 static PyObject *_wrap_MDIChildFrame_Maximize(PyObject *, PyObject *args, PyObject *kwargs) {
17426     PyObject *resultobj;
17427     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17428     bool arg2 = (bool) true ;
17429     PyObject * obj0 = 0 ;
17430     PyObject * obj1 = 0 ;
17431     char *kwnames[] = {
17432         (char *) "self",(char *) "maximize", NULL
17433     };
17434
17435     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MDIChildFrame_Maximize",kwnames,&obj0,&obj1)) goto fail;
17436     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17437     if (SWIG_arg_fail(1)) SWIG_fail;
17438     if (obj1) {
17439         {
17440             arg2 = (bool)(SWIG_As_bool(obj1));
17441             if (SWIG_arg_fail(2)) SWIG_fail;
17442         }
17443     }
17444     {
17445         PyThreadState* __tstate = wxPyBeginAllowThreads();
17446         (arg1)->Maximize(arg2);
17447
17448         wxPyEndAllowThreads(__tstate);
17449         if (PyErr_Occurred()) SWIG_fail;
17450     }
17451     Py_INCREF(Py_None); resultobj = Py_None;
17452     return resultobj;
17453     fail:
17454     return NULL;
17455 }
17456
17457
17458 static PyObject *_wrap_MDIChildFrame_Restore(PyObject *, PyObject *args, PyObject *kwargs) {
17459     PyObject *resultobj;
17460     wxMDIChildFrame *arg1 = (wxMDIChildFrame *) 0 ;
17461     PyObject * obj0 = 0 ;
17462     char *kwnames[] = {
17463         (char *) "self", NULL
17464     };
17465
17466     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MDIChildFrame_Restore",kwnames,&obj0)) goto fail;
17467     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIChildFrame, SWIG_POINTER_EXCEPTION | 0);
17468     if (SWIG_arg_fail(1)) SWIG_fail;
17469     {
17470         PyThreadState* __tstate = wxPyBeginAllowThreads();
17471         (arg1)->Restore();
17472
17473         wxPyEndAllowThreads(__tstate);
17474         if (PyErr_Occurred()) SWIG_fail;
17475     }
17476     Py_INCREF(Py_None); resultobj = Py_None;
17477     return resultobj;
17478     fail:
17479     return NULL;
17480 }
17481
17482
17483 static PyObject * MDIChildFrame_swigregister(PyObject *, PyObject *args) {
17484     PyObject *obj;
17485     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17486     SWIG_TypeClientData(SWIGTYPE_p_wxMDIChildFrame, obj);
17487     Py_INCREF(obj);
17488     return Py_BuildValue((char *)"");
17489 }
17490 static PyObject *_wrap_new_MDIClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17491     PyObject *resultobj;
17492     wxMDIParentFrame *arg1 = (wxMDIParentFrame *) 0 ;
17493     long arg2 = (long) 0 ;
17494     wxMDIClientWindow *result;
17495     PyObject * obj0 = 0 ;
17496     PyObject * obj1 = 0 ;
17497     char *kwnames[] = {
17498         (char *) "parent",(char *) "style", NULL
17499     };
17500
17501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_MDIClientWindow",kwnames,&obj0,&obj1)) goto fail;
17502     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17503     if (SWIG_arg_fail(1)) SWIG_fail;
17504     if (obj1) {
17505         {
17506             arg2 = (long)(SWIG_As_long(obj1));
17507             if (SWIG_arg_fail(2)) SWIG_fail;
17508         }
17509     }
17510     {
17511         if (!wxPyCheckForApp()) SWIG_fail;
17512         PyThreadState* __tstate = wxPyBeginAllowThreads();
17513         result = (wxMDIClientWindow *)new wxMDIClientWindow(arg1,arg2);
17514
17515         wxPyEndAllowThreads(__tstate);
17516         if (PyErr_Occurred()) SWIG_fail;
17517     }
17518     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIClientWindow, 1);
17519     return resultobj;
17520     fail:
17521     return NULL;
17522 }
17523
17524
17525 static PyObject *_wrap_new_PreMDIClientWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17526     PyObject *resultobj;
17527     wxMDIClientWindow *result;
17528     char *kwnames[] = {
17529         NULL
17530     };
17531
17532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreMDIClientWindow",kwnames)) goto fail;
17533     {
17534         if (!wxPyCheckForApp()) SWIG_fail;
17535         PyThreadState* __tstate = wxPyBeginAllowThreads();
17536         result = (wxMDIClientWindow *)new wxMDIClientWindow();
17537
17538         wxPyEndAllowThreads(__tstate);
17539         if (PyErr_Occurred()) SWIG_fail;
17540     }
17541     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMDIClientWindow, 1);
17542     return resultobj;
17543     fail:
17544     return NULL;
17545 }
17546
17547
17548 static PyObject *_wrap_MDIClientWindow_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17549     PyObject *resultobj;
17550     wxMDIClientWindow *arg1 = (wxMDIClientWindow *) 0 ;
17551     wxMDIParentFrame *arg2 = (wxMDIParentFrame *) 0 ;
17552     long arg3 = (long) 0 ;
17553     bool result;
17554     PyObject * obj0 = 0 ;
17555     PyObject * obj1 = 0 ;
17556     PyObject * obj2 = 0 ;
17557     char *kwnames[] = {
17558         (char *) "self",(char *) "parent",(char *) "style", NULL
17559     };
17560
17561     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MDIClientWindow_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
17562     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMDIClientWindow, SWIG_POINTER_EXCEPTION | 0);
17563     if (SWIG_arg_fail(1)) SWIG_fail;
17564     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMDIParentFrame, SWIG_POINTER_EXCEPTION | 0);
17565     if (SWIG_arg_fail(2)) SWIG_fail;
17566     if (obj2) {
17567         {
17568             arg3 = (long)(SWIG_As_long(obj2));
17569             if (SWIG_arg_fail(3)) SWIG_fail;
17570         }
17571     }
17572     {
17573         PyThreadState* __tstate = wxPyBeginAllowThreads();
17574         result = (bool)(arg1)->Create(arg2,arg3);
17575
17576         wxPyEndAllowThreads(__tstate);
17577         if (PyErr_Occurred()) SWIG_fail;
17578     }
17579     {
17580         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17581     }
17582     return resultobj;
17583     fail:
17584     return NULL;
17585 }
17586
17587
17588 static PyObject * MDIClientWindow_swigregister(PyObject *, PyObject *args) {
17589     PyObject *obj;
17590     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17591     SWIG_TypeClientData(SWIGTYPE_p_wxMDIClientWindow, obj);
17592     Py_INCREF(obj);
17593     return Py_BuildValue((char *)"");
17594 }
17595 static PyObject *_wrap_new_PyWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17596     PyObject *resultobj;
17597     wxWindow *arg1 = (wxWindow *) 0 ;
17598     int arg2 = (int) (int)-1 ;
17599     wxPoint const &arg3_defvalue = wxDefaultPosition ;
17600     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
17601     wxSize const &arg4_defvalue = wxDefaultSize ;
17602     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
17603     long arg5 = (long) 0 ;
17604     wxString const &arg6_defvalue = wxPyPanelNameStr ;
17605     wxString *arg6 = (wxString *) &arg6_defvalue ;
17606     wxPyWindow *result;
17607     wxPoint temp3 ;
17608     wxSize temp4 ;
17609     bool temp6 = false ;
17610     PyObject * obj0 = 0 ;
17611     PyObject * obj1 = 0 ;
17612     PyObject * obj2 = 0 ;
17613     PyObject * obj3 = 0 ;
17614     PyObject * obj4 = 0 ;
17615     PyObject * obj5 = 0 ;
17616     char *kwnames[] = {
17617         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
17618     };
17619
17620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17621     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17622     if (SWIG_arg_fail(1)) SWIG_fail;
17623     if (obj1) {
17624         {
17625             arg2 = (int const)(SWIG_As_int(obj1));
17626             if (SWIG_arg_fail(2)) SWIG_fail;
17627         }
17628     }
17629     if (obj2) {
17630         {
17631             arg3 = &temp3;
17632             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17633         }
17634     }
17635     if (obj3) {
17636         {
17637             arg4 = &temp4;
17638             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
17639         }
17640     }
17641     if (obj4) {
17642         {
17643             arg5 = (long)(SWIG_As_long(obj4));
17644             if (SWIG_arg_fail(5)) SWIG_fail;
17645         }
17646     }
17647     if (obj5) {
17648         {
17649             arg6 = wxString_in_helper(obj5);
17650             if (arg6 == NULL) SWIG_fail;
17651             temp6 = true;
17652         }
17653     }
17654     {
17655         if (!wxPyCheckForApp()) SWIG_fail;
17656         PyThreadState* __tstate = wxPyBeginAllowThreads();
17657         result = (wxPyWindow *)new wxPyWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
17658
17659         wxPyEndAllowThreads(__tstate);
17660         if (PyErr_Occurred()) SWIG_fail;
17661     }
17662     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyWindow, 1);
17663     {
17664         if (temp6)
17665         delete arg6;
17666     }
17667     return resultobj;
17668     fail:
17669     {
17670         if (temp6)
17671         delete arg6;
17672     }
17673     return NULL;
17674 }
17675
17676
17677 static PyObject *_wrap_new_PrePyWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17678     PyObject *resultobj;
17679     wxPyWindow *result;
17680     char *kwnames[] = {
17681         NULL
17682     };
17683
17684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyWindow",kwnames)) goto fail;
17685     {
17686         if (!wxPyCheckForApp()) SWIG_fail;
17687         PyThreadState* __tstate = wxPyBeginAllowThreads();
17688         result = (wxPyWindow *)new wxPyWindow();
17689
17690         wxPyEndAllowThreads(__tstate);
17691         if (PyErr_Occurred()) SWIG_fail;
17692     }
17693     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyWindow, 1);
17694     return resultobj;
17695     fail:
17696     return NULL;
17697 }
17698
17699
17700 static PyObject *_wrap_PyWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
17701     PyObject *resultobj;
17702     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17703     PyObject *arg2 = (PyObject *) 0 ;
17704     PyObject *arg3 = (PyObject *) 0 ;
17705     PyObject * obj0 = 0 ;
17706     PyObject * obj1 = 0 ;
17707     PyObject * obj2 = 0 ;
17708     char *kwnames[] = {
17709         (char *) "self",(char *) "self",(char *) "_class", NULL
17710     };
17711
17712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
17713     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17714     if (SWIG_arg_fail(1)) SWIG_fail;
17715     arg2 = obj1;
17716     arg3 = obj2;
17717     {
17718         PyThreadState* __tstate = wxPyBeginAllowThreads();
17719         (arg1)->_setCallbackInfo(arg2,arg3);
17720
17721         wxPyEndAllowThreads(__tstate);
17722         if (PyErr_Occurred()) SWIG_fail;
17723     }
17724     Py_INCREF(Py_None); resultobj = Py_None;
17725     return resultobj;
17726     fail:
17727     return NULL;
17728 }
17729
17730
17731 static PyObject *_wrap_PyWindow_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
17732     PyObject *resultobj;
17733     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17734     wxSize *arg2 = 0 ;
17735     wxSize temp2 ;
17736     PyObject * obj0 = 0 ;
17737     PyObject * obj1 = 0 ;
17738     char *kwnames[] = {
17739         (char *) "self",(char *) "size", NULL
17740     };
17741
17742     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
17743     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17744     if (SWIG_arg_fail(1)) SWIG_fail;
17745     {
17746         arg2 = &temp2;
17747         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17748     }
17749     {
17750         PyThreadState* __tstate = wxPyBeginAllowThreads();
17751         (arg1)->SetBestSize((wxSize const &)*arg2);
17752
17753         wxPyEndAllowThreads(__tstate);
17754         if (PyErr_Occurred()) SWIG_fail;
17755     }
17756     Py_INCREF(Py_None); resultobj = Py_None;
17757     return resultobj;
17758     fail:
17759     return NULL;
17760 }
17761
17762
17763 static PyObject *_wrap_PyWindow_DoEraseBackground(PyObject *, PyObject *args, PyObject *kwargs) {
17764     PyObject *resultobj;
17765     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17766     wxDC *arg2 = (wxDC *) 0 ;
17767     bool result;
17768     PyObject * obj0 = 0 ;
17769     PyObject * obj1 = 0 ;
17770     char *kwnames[] = {
17771         (char *) "self",(char *) "dc", NULL
17772     };
17773
17774     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_DoEraseBackground",kwnames,&obj0,&obj1)) goto fail;
17775     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17776     if (SWIG_arg_fail(1)) SWIG_fail;
17777     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17778     if (SWIG_arg_fail(2)) SWIG_fail;
17779     {
17780         PyThreadState* __tstate = wxPyBeginAllowThreads();
17781         result = (bool)(arg1)->DoEraseBackground(arg2);
17782
17783         wxPyEndAllowThreads(__tstate);
17784         if (PyErr_Occurred()) SWIG_fail;
17785     }
17786     {
17787         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17788     }
17789     return resultobj;
17790     fail:
17791     return NULL;
17792 }
17793
17794
17795 static PyObject *_wrap_PyWindow_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
17796     PyObject *resultobj;
17797     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17798     int arg2 ;
17799     int arg3 ;
17800     int arg4 ;
17801     int arg5 ;
17802     PyObject * obj0 = 0 ;
17803     PyObject * obj1 = 0 ;
17804     PyObject * obj2 = 0 ;
17805     PyObject * obj3 = 0 ;
17806     PyObject * obj4 = 0 ;
17807     char *kwnames[] = {
17808         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
17809     };
17810
17811     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyWindow_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17812     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17813     if (SWIG_arg_fail(1)) SWIG_fail;
17814     {
17815         arg2 = (int)(SWIG_As_int(obj1));
17816         if (SWIG_arg_fail(2)) SWIG_fail;
17817     }
17818     {
17819         arg3 = (int)(SWIG_As_int(obj2));
17820         if (SWIG_arg_fail(3)) SWIG_fail;
17821     }
17822     {
17823         arg4 = (int)(SWIG_As_int(obj3));
17824         if (SWIG_arg_fail(4)) SWIG_fail;
17825     }
17826     {
17827         arg5 = (int)(SWIG_As_int(obj4));
17828         if (SWIG_arg_fail(5)) SWIG_fail;
17829     }
17830     {
17831         PyThreadState* __tstate = wxPyBeginAllowThreads();
17832         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
17833
17834         wxPyEndAllowThreads(__tstate);
17835         if (PyErr_Occurred()) SWIG_fail;
17836     }
17837     Py_INCREF(Py_None); resultobj = Py_None;
17838     return resultobj;
17839     fail:
17840     return NULL;
17841 }
17842
17843
17844 static PyObject *_wrap_PyWindow_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
17845     PyObject *resultobj;
17846     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17847     int arg2 ;
17848     int arg3 ;
17849     int arg4 ;
17850     int arg5 ;
17851     int arg6 = (int) wxSIZE_AUTO ;
17852     PyObject * obj0 = 0 ;
17853     PyObject * obj1 = 0 ;
17854     PyObject * obj2 = 0 ;
17855     PyObject * obj3 = 0 ;
17856     PyObject * obj4 = 0 ;
17857     PyObject * obj5 = 0 ;
17858     char *kwnames[] = {
17859         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
17860     };
17861
17862     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyWindow_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17863     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17864     if (SWIG_arg_fail(1)) SWIG_fail;
17865     {
17866         arg2 = (int)(SWIG_As_int(obj1));
17867         if (SWIG_arg_fail(2)) SWIG_fail;
17868     }
17869     {
17870         arg3 = (int)(SWIG_As_int(obj2));
17871         if (SWIG_arg_fail(3)) SWIG_fail;
17872     }
17873     {
17874         arg4 = (int)(SWIG_As_int(obj3));
17875         if (SWIG_arg_fail(4)) SWIG_fail;
17876     }
17877     {
17878         arg5 = (int)(SWIG_As_int(obj4));
17879         if (SWIG_arg_fail(5)) SWIG_fail;
17880     }
17881     if (obj5) {
17882         {
17883             arg6 = (int)(SWIG_As_int(obj5));
17884             if (SWIG_arg_fail(6)) SWIG_fail;
17885         }
17886     }
17887     {
17888         PyThreadState* __tstate = wxPyBeginAllowThreads();
17889         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
17890
17891         wxPyEndAllowThreads(__tstate);
17892         if (PyErr_Occurred()) SWIG_fail;
17893     }
17894     Py_INCREF(Py_None); resultobj = Py_None;
17895     return resultobj;
17896     fail:
17897     return NULL;
17898 }
17899
17900
17901 static PyObject *_wrap_PyWindow_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
17902     PyObject *resultobj;
17903     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17904     int arg2 ;
17905     int arg3 ;
17906     PyObject * obj0 = 0 ;
17907     PyObject * obj1 = 0 ;
17908     PyObject * obj2 = 0 ;
17909     char *kwnames[] = {
17910         (char *) "self",(char *) "width",(char *) "height", NULL
17911     };
17912
17913     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
17914     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17915     if (SWIG_arg_fail(1)) SWIG_fail;
17916     {
17917         arg2 = (int)(SWIG_As_int(obj1));
17918         if (SWIG_arg_fail(2)) SWIG_fail;
17919     }
17920     {
17921         arg3 = (int)(SWIG_As_int(obj2));
17922         if (SWIG_arg_fail(3)) SWIG_fail;
17923     }
17924     {
17925         PyThreadState* __tstate = wxPyBeginAllowThreads();
17926         (arg1)->base_DoSetClientSize(arg2,arg3);
17927
17928         wxPyEndAllowThreads(__tstate);
17929         if (PyErr_Occurred()) SWIG_fail;
17930     }
17931     Py_INCREF(Py_None); resultobj = Py_None;
17932     return resultobj;
17933     fail:
17934     return NULL;
17935 }
17936
17937
17938 static PyObject *_wrap_PyWindow_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
17939     PyObject *resultobj;
17940     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17941     int arg2 ;
17942     int arg3 ;
17943     PyObject * obj0 = 0 ;
17944     PyObject * obj1 = 0 ;
17945     PyObject * obj2 = 0 ;
17946     char *kwnames[] = {
17947         (char *) "self",(char *) "x",(char *) "y", NULL
17948     };
17949
17950     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWindow_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
17951     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17952     if (SWIG_arg_fail(1)) SWIG_fail;
17953     {
17954         arg2 = (int)(SWIG_As_int(obj1));
17955         if (SWIG_arg_fail(2)) SWIG_fail;
17956     }
17957     {
17958         arg3 = (int)(SWIG_As_int(obj2));
17959         if (SWIG_arg_fail(3)) SWIG_fail;
17960     }
17961     {
17962         PyThreadState* __tstate = wxPyBeginAllowThreads();
17963         (arg1)->base_DoSetVirtualSize(arg2,arg3);
17964
17965         wxPyEndAllowThreads(__tstate);
17966         if (PyErr_Occurred()) SWIG_fail;
17967     }
17968     Py_INCREF(Py_None); resultobj = Py_None;
17969     return resultobj;
17970     fail:
17971     return NULL;
17972 }
17973
17974
17975 static PyObject *_wrap_PyWindow_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
17976     PyObject *resultobj;
17977     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
17978     int *arg2 = (int *) 0 ;
17979     int *arg3 = (int *) 0 ;
17980     int temp2 ;
17981     int res2 = 0 ;
17982     int temp3 ;
17983     int res3 = 0 ;
17984     PyObject * obj0 = 0 ;
17985     char *kwnames[] = {
17986         (char *) "self", NULL
17987     };
17988
17989     arg2 = &temp2; res2 = SWIG_NEWOBJ;
17990     arg3 = &temp3; res3 = SWIG_NEWOBJ;
17991     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetSize",kwnames,&obj0)) goto fail;
17992     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
17993     if (SWIG_arg_fail(1)) SWIG_fail;
17994     {
17995         PyThreadState* __tstate = wxPyBeginAllowThreads();
17996         ((wxPyWindow const *)arg1)->base_DoGetSize(arg2,arg3);
17997
17998         wxPyEndAllowThreads(__tstate);
17999         if (PyErr_Occurred()) SWIG_fail;
18000     }
18001     Py_INCREF(Py_None); resultobj = Py_None;
18002     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18003     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18004     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18005     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18006     return resultobj;
18007     fail:
18008     return NULL;
18009 }
18010
18011
18012 static PyObject *_wrap_PyWindow_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18013     PyObject *resultobj;
18014     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18015     int *arg2 = (int *) 0 ;
18016     int *arg3 = (int *) 0 ;
18017     int temp2 ;
18018     int res2 = 0 ;
18019     int temp3 ;
18020     int res3 = 0 ;
18021     PyObject * obj0 = 0 ;
18022     char *kwnames[] = {
18023         (char *) "self", NULL
18024     };
18025
18026     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18027     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18028     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetClientSize",kwnames,&obj0)) goto fail;
18029     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18030     if (SWIG_arg_fail(1)) SWIG_fail;
18031     {
18032         PyThreadState* __tstate = wxPyBeginAllowThreads();
18033         ((wxPyWindow const *)arg1)->base_DoGetClientSize(arg2,arg3);
18034
18035         wxPyEndAllowThreads(__tstate);
18036         if (PyErr_Occurred()) SWIG_fail;
18037     }
18038     Py_INCREF(Py_None); resultobj = Py_None;
18039     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18040     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18041     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18042     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18043     return resultobj;
18044     fail:
18045     return NULL;
18046 }
18047
18048
18049 static PyObject *_wrap_PyWindow_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18050     PyObject *resultobj;
18051     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18052     int *arg2 = (int *) 0 ;
18053     int *arg3 = (int *) 0 ;
18054     int temp2 ;
18055     int res2 = 0 ;
18056     int temp3 ;
18057     int res3 = 0 ;
18058     PyObject * obj0 = 0 ;
18059     char *kwnames[] = {
18060         (char *) "self", NULL
18061     };
18062
18063     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18064     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetPosition",kwnames,&obj0)) goto fail;
18066     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18067     if (SWIG_arg_fail(1)) SWIG_fail;
18068     {
18069         PyThreadState* __tstate = wxPyBeginAllowThreads();
18070         ((wxPyWindow const *)arg1)->base_DoGetPosition(arg2,arg3);
18071
18072         wxPyEndAllowThreads(__tstate);
18073         if (PyErr_Occurred()) SWIG_fail;
18074     }
18075     Py_INCREF(Py_None); resultobj = Py_None;
18076     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18077     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18078     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18079     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18080     return resultobj;
18081     fail:
18082     return NULL;
18083 }
18084
18085
18086 static PyObject *_wrap_PyWindow_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18087     PyObject *resultobj;
18088     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18089     wxSize result;
18090     PyObject * obj0 = 0 ;
18091     char *kwnames[] = {
18092         (char *) "self", NULL
18093     };
18094
18095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
18096     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18097     if (SWIG_arg_fail(1)) SWIG_fail;
18098     {
18099         PyThreadState* __tstate = wxPyBeginAllowThreads();
18100         result = ((wxPyWindow const *)arg1)->base_DoGetVirtualSize();
18101
18102         wxPyEndAllowThreads(__tstate);
18103         if (PyErr_Occurred()) SWIG_fail;
18104     }
18105     {
18106         wxSize * resultptr;
18107         resultptr = new wxSize((wxSize &)(result));
18108         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18109     }
18110     return resultobj;
18111     fail:
18112     return NULL;
18113 }
18114
18115
18116 static PyObject *_wrap_PyWindow_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18117     PyObject *resultobj;
18118     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18119     wxSize result;
18120     PyObject * obj0 = 0 ;
18121     char *kwnames[] = {
18122         (char *) "self", NULL
18123     };
18124
18125     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_DoGetBestSize",kwnames,&obj0)) goto fail;
18126     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18127     if (SWIG_arg_fail(1)) SWIG_fail;
18128     {
18129         PyThreadState* __tstate = wxPyBeginAllowThreads();
18130         result = ((wxPyWindow const *)arg1)->base_DoGetBestSize();
18131
18132         wxPyEndAllowThreads(__tstate);
18133         if (PyErr_Occurred()) SWIG_fail;
18134     }
18135     {
18136         wxSize * resultptr;
18137         resultptr = new wxSize((wxSize &)(result));
18138         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18139     }
18140     return resultobj;
18141     fail:
18142     return NULL;
18143 }
18144
18145
18146 static PyObject *_wrap_PyWindow_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
18147     PyObject *resultobj;
18148     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18149     PyObject * obj0 = 0 ;
18150     char *kwnames[] = {
18151         (char *) "self", NULL
18152     };
18153
18154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_InitDialog",kwnames,&obj0)) goto fail;
18155     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18156     if (SWIG_arg_fail(1)) SWIG_fail;
18157     {
18158         PyThreadState* __tstate = wxPyBeginAllowThreads();
18159         (arg1)->base_InitDialog();
18160
18161         wxPyEndAllowThreads(__tstate);
18162         if (PyErr_Occurred()) SWIG_fail;
18163     }
18164     Py_INCREF(Py_None); resultobj = Py_None;
18165     return resultobj;
18166     fail:
18167     return NULL;
18168 }
18169
18170
18171 static PyObject *_wrap_PyWindow_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18172     PyObject *resultobj;
18173     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18174     bool result;
18175     PyObject * obj0 = 0 ;
18176     char *kwnames[] = {
18177         (char *) "self", NULL
18178     };
18179
18180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
18181     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18182     if (SWIG_arg_fail(1)) SWIG_fail;
18183     {
18184         PyThreadState* __tstate = wxPyBeginAllowThreads();
18185         result = (bool)(arg1)->base_TransferDataToWindow();
18186
18187         wxPyEndAllowThreads(__tstate);
18188         if (PyErr_Occurred()) SWIG_fail;
18189     }
18190     {
18191         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18192     }
18193     return resultobj;
18194     fail:
18195     return NULL;
18196 }
18197
18198
18199 static PyObject *_wrap_PyWindow_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18200     PyObject *resultobj;
18201     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18202     bool result;
18203     PyObject * obj0 = 0 ;
18204     char *kwnames[] = {
18205         (char *) "self", NULL
18206     };
18207
18208     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
18209     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18210     if (SWIG_arg_fail(1)) SWIG_fail;
18211     {
18212         PyThreadState* __tstate = wxPyBeginAllowThreads();
18213         result = (bool)(arg1)->base_TransferDataFromWindow();
18214
18215         wxPyEndAllowThreads(__tstate);
18216         if (PyErr_Occurred()) SWIG_fail;
18217     }
18218     {
18219         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18220     }
18221     return resultobj;
18222     fail:
18223     return NULL;
18224 }
18225
18226
18227 static PyObject *_wrap_PyWindow_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
18228     PyObject *resultobj;
18229     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18230     bool result;
18231     PyObject * obj0 = 0 ;
18232     char *kwnames[] = {
18233         (char *) "self", NULL
18234     };
18235
18236     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_Validate",kwnames,&obj0)) goto fail;
18237     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18238     if (SWIG_arg_fail(1)) SWIG_fail;
18239     {
18240         PyThreadState* __tstate = wxPyBeginAllowThreads();
18241         result = (bool)(arg1)->base_Validate();
18242
18243         wxPyEndAllowThreads(__tstate);
18244         if (PyErr_Occurred()) SWIG_fail;
18245     }
18246     {
18247         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18248     }
18249     return resultobj;
18250     fail:
18251     return NULL;
18252 }
18253
18254
18255 static PyObject *_wrap_PyWindow_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
18256     PyObject *resultobj;
18257     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18258     bool result;
18259     PyObject * obj0 = 0 ;
18260     char *kwnames[] = {
18261         (char *) "self", NULL
18262     };
18263
18264     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_AcceptsFocus",kwnames,&obj0)) goto fail;
18265     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18266     if (SWIG_arg_fail(1)) SWIG_fail;
18267     {
18268         PyThreadState* __tstate = wxPyBeginAllowThreads();
18269         result = (bool)((wxPyWindow const *)arg1)->base_AcceptsFocus();
18270
18271         wxPyEndAllowThreads(__tstate);
18272         if (PyErr_Occurred()) SWIG_fail;
18273     }
18274     {
18275         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18276     }
18277     return resultobj;
18278     fail:
18279     return NULL;
18280 }
18281
18282
18283 static PyObject *_wrap_PyWindow_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
18284     PyObject *resultobj;
18285     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18286     bool result;
18287     PyObject * obj0 = 0 ;
18288     char *kwnames[] = {
18289         (char *) "self", NULL
18290     };
18291
18292     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
18293     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18294     if (SWIG_arg_fail(1)) SWIG_fail;
18295     {
18296         PyThreadState* __tstate = wxPyBeginAllowThreads();
18297         result = (bool)((wxPyWindow const *)arg1)->base_AcceptsFocusFromKeyboard();
18298
18299         wxPyEndAllowThreads(__tstate);
18300         if (PyErr_Occurred()) SWIG_fail;
18301     }
18302     {
18303         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18304     }
18305     return resultobj;
18306     fail:
18307     return NULL;
18308 }
18309
18310
18311 static PyObject *_wrap_PyWindow_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
18312     PyObject *resultobj;
18313     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18314     wxSize result;
18315     PyObject * obj0 = 0 ;
18316     char *kwnames[] = {
18317         (char *) "self", NULL
18318     };
18319
18320     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_GetMaxSize",kwnames,&obj0)) goto fail;
18321     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18322     if (SWIG_arg_fail(1)) SWIG_fail;
18323     {
18324         PyThreadState* __tstate = wxPyBeginAllowThreads();
18325         result = ((wxPyWindow const *)arg1)->base_GetMaxSize();
18326
18327         wxPyEndAllowThreads(__tstate);
18328         if (PyErr_Occurred()) SWIG_fail;
18329     }
18330     {
18331         wxSize * resultptr;
18332         resultptr = new wxSize((wxSize &)(result));
18333         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18334     }
18335     return resultobj;
18336     fail:
18337     return NULL;
18338 }
18339
18340
18341 static PyObject *_wrap_PyWindow_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
18342     PyObject *resultobj;
18343     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18344     wxWindow *arg2 = (wxWindow *) 0 ;
18345     PyObject * obj0 = 0 ;
18346     PyObject * obj1 = 0 ;
18347     char *kwnames[] = {
18348         (char *) "self",(char *) "child", NULL
18349     };
18350
18351     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
18352     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyWindow, SWIG_POINTER_EXCEPTION | 0);
18353     if (SWIG_arg_fail(1)) SWIG_fail;
18354     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18355     if (SWIG_arg_fail(2)) SWIG_fail;
18356     {
18357         PyThreadState* __tstate = wxPyBeginAllowThreads();
18358         (arg1)->base_AddChild(arg2);
18359
18360         wxPyEndAllowThreads(__tstate);
18361         if (PyErr_Occurred()) SWIG_fail;
18362     }
18363     Py_INCREF(Py_None); resultobj = Py_None;
18364     return resultobj;
18365     fail:
18366     return NULL;
18367 }
18368
18369
18370 static PyObject *_wrap_PyWindow_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
18371     PyObject *resultobj;
18372     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18373     wxWindow *arg2 = (wxWindow *) 0 ;
18374     PyObject * obj0 = 0 ;
18375     PyObject * obj1 = 0 ;
18376     char *kwnames[] = {
18377         (char *) "self",(char *) "child", NULL
18378     };
18379
18380     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyWindow_base_RemoveChild",kwnames,&obj0,&obj1)) 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     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18384     if (SWIG_arg_fail(2)) SWIG_fail;
18385     {
18386         PyThreadState* __tstate = wxPyBeginAllowThreads();
18387         (arg1)->base_RemoveChild(arg2);
18388
18389         wxPyEndAllowThreads(__tstate);
18390         if (PyErr_Occurred()) SWIG_fail;
18391     }
18392     Py_INCREF(Py_None); resultobj = Py_None;
18393     return resultobj;
18394     fail:
18395     return NULL;
18396 }
18397
18398
18399 static PyObject *_wrap_PyWindow_base_ShouldInheritColours(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_ShouldInheritColours",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_ShouldInheritColours();
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_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
18428     PyObject *resultobj;
18429     wxPyWindow *arg1 = (wxPyWindow *) 0 ;
18430     wxVisualAttributes result;
18431     PyObject * obj0 = 0 ;
18432     char *kwnames[] = {
18433         (char *) "self", NULL
18434     };
18435
18436     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyWindow_base_GetDefaultAttributes",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 = (arg1)->base_GetDefaultAttributes();
18442
18443         wxPyEndAllowThreads(__tstate);
18444         if (PyErr_Occurred()) SWIG_fail;
18445     }
18446     {
18447         wxVisualAttributes * resultptr;
18448         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
18449         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
18450     }
18451     return resultobj;
18452     fail:
18453     return NULL;
18454 }
18455
18456
18457 static PyObject * PyWindow_swigregister(PyObject *, PyObject *args) {
18458     PyObject *obj;
18459     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18460     SWIG_TypeClientData(SWIGTYPE_p_wxPyWindow, obj);
18461     Py_INCREF(obj);
18462     return Py_BuildValue((char *)"");
18463 }
18464 static PyObject *_wrap_new_PyPanel(PyObject *, PyObject *args, PyObject *kwargs) {
18465     PyObject *resultobj;
18466     wxWindow *arg1 = (wxWindow *) 0 ;
18467     int arg2 = (int) (int)-1 ;
18468     wxPoint const &arg3_defvalue = wxDefaultPosition ;
18469     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
18470     wxSize const &arg4_defvalue = wxDefaultSize ;
18471     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
18472     long arg5 = (long) 0 ;
18473     wxString const &arg6_defvalue = wxPyPanelNameStr ;
18474     wxString *arg6 = (wxString *) &arg6_defvalue ;
18475     wxPyPanel *result;
18476     wxPoint temp3 ;
18477     wxSize temp4 ;
18478     bool temp6 = false ;
18479     PyObject * obj0 = 0 ;
18480     PyObject * obj1 = 0 ;
18481     PyObject * obj2 = 0 ;
18482     PyObject * obj3 = 0 ;
18483     PyObject * obj4 = 0 ;
18484     PyObject * obj5 = 0 ;
18485     char *kwnames[] = {
18486         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
18487     };
18488
18489     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyPanel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18490     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18491     if (SWIG_arg_fail(1)) SWIG_fail;
18492     if (obj1) {
18493         {
18494             arg2 = (int const)(SWIG_As_int(obj1));
18495             if (SWIG_arg_fail(2)) SWIG_fail;
18496         }
18497     }
18498     if (obj2) {
18499         {
18500             arg3 = &temp3;
18501             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18502         }
18503     }
18504     if (obj3) {
18505         {
18506             arg4 = &temp4;
18507             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
18508         }
18509     }
18510     if (obj4) {
18511         {
18512             arg5 = (long)(SWIG_As_long(obj4));
18513             if (SWIG_arg_fail(5)) SWIG_fail;
18514         }
18515     }
18516     if (obj5) {
18517         {
18518             arg6 = wxString_in_helper(obj5);
18519             if (arg6 == NULL) SWIG_fail;
18520             temp6 = true;
18521         }
18522     }
18523     {
18524         if (!wxPyCheckForApp()) SWIG_fail;
18525         PyThreadState* __tstate = wxPyBeginAllowThreads();
18526         result = (wxPyPanel *)new wxPyPanel(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
18527
18528         wxPyEndAllowThreads(__tstate);
18529         if (PyErr_Occurred()) SWIG_fail;
18530     }
18531     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPanel, 1);
18532     {
18533         if (temp6)
18534         delete arg6;
18535     }
18536     return resultobj;
18537     fail:
18538     {
18539         if (temp6)
18540         delete arg6;
18541     }
18542     return NULL;
18543 }
18544
18545
18546 static PyObject *_wrap_new_PrePyPanel(PyObject *, PyObject *args, PyObject *kwargs) {
18547     PyObject *resultobj;
18548     wxPyPanel *result;
18549     char *kwnames[] = {
18550         NULL
18551     };
18552
18553     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyPanel",kwnames)) goto fail;
18554     {
18555         if (!wxPyCheckForApp()) SWIG_fail;
18556         PyThreadState* __tstate = wxPyBeginAllowThreads();
18557         result = (wxPyPanel *)new wxPyPanel();
18558
18559         wxPyEndAllowThreads(__tstate);
18560         if (PyErr_Occurred()) SWIG_fail;
18561     }
18562     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPanel, 1);
18563     return resultobj;
18564     fail:
18565     return NULL;
18566 }
18567
18568
18569 static PyObject *_wrap_PyPanel__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
18570     PyObject *resultobj;
18571     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18572     PyObject *arg2 = (PyObject *) 0 ;
18573     PyObject *arg3 = (PyObject *) 0 ;
18574     PyObject * obj0 = 0 ;
18575     PyObject * obj1 = 0 ;
18576     PyObject * obj2 = 0 ;
18577     char *kwnames[] = {
18578         (char *) "self",(char *) "self",(char *) "_class", NULL
18579     };
18580
18581     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
18582     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18583     if (SWIG_arg_fail(1)) SWIG_fail;
18584     arg2 = obj1;
18585     arg3 = obj2;
18586     {
18587         PyThreadState* __tstate = wxPyBeginAllowThreads();
18588         (arg1)->_setCallbackInfo(arg2,arg3);
18589
18590         wxPyEndAllowThreads(__tstate);
18591         if (PyErr_Occurred()) SWIG_fail;
18592     }
18593     Py_INCREF(Py_None); resultobj = Py_None;
18594     return resultobj;
18595     fail:
18596     return NULL;
18597 }
18598
18599
18600 static PyObject *_wrap_PyPanel_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18601     PyObject *resultobj;
18602     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18603     wxSize *arg2 = 0 ;
18604     wxSize temp2 ;
18605     PyObject * obj0 = 0 ;
18606     PyObject * obj1 = 0 ;
18607     char *kwnames[] = {
18608         (char *) "self",(char *) "size", NULL
18609     };
18610
18611     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
18612     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18613     if (SWIG_arg_fail(1)) SWIG_fail;
18614     {
18615         arg2 = &temp2;
18616         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18617     }
18618     {
18619         PyThreadState* __tstate = wxPyBeginAllowThreads();
18620         (arg1)->SetBestSize((wxSize const &)*arg2);
18621
18622         wxPyEndAllowThreads(__tstate);
18623         if (PyErr_Occurred()) SWIG_fail;
18624     }
18625     Py_INCREF(Py_None); resultobj = Py_None;
18626     return resultobj;
18627     fail:
18628     return NULL;
18629 }
18630
18631
18632 static PyObject *_wrap_PyPanel_DoEraseBackground(PyObject *, PyObject *args, PyObject *kwargs) {
18633     PyObject *resultobj;
18634     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18635     wxDC *arg2 = (wxDC *) 0 ;
18636     bool result;
18637     PyObject * obj0 = 0 ;
18638     PyObject * obj1 = 0 ;
18639     char *kwnames[] = {
18640         (char *) "self",(char *) "dc", NULL
18641     };
18642
18643     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_DoEraseBackground",kwnames,&obj0,&obj1)) goto fail;
18644     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18645     if (SWIG_arg_fail(1)) SWIG_fail;
18646     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18647     if (SWIG_arg_fail(2)) SWIG_fail;
18648     {
18649         PyThreadState* __tstate = wxPyBeginAllowThreads();
18650         result = (bool)(arg1)->DoEraseBackground(arg2);
18651
18652         wxPyEndAllowThreads(__tstate);
18653         if (PyErr_Occurred()) SWIG_fail;
18654     }
18655     {
18656         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18657     }
18658     return resultobj;
18659     fail:
18660     return NULL;
18661 }
18662
18663
18664 static PyObject *_wrap_PyPanel_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
18665     PyObject *resultobj;
18666     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18667     int arg2 ;
18668     int arg3 ;
18669     int arg4 ;
18670     int arg5 ;
18671     PyObject * obj0 = 0 ;
18672     PyObject * obj1 = 0 ;
18673     PyObject * obj2 = 0 ;
18674     PyObject * obj3 = 0 ;
18675     PyObject * obj4 = 0 ;
18676     char *kwnames[] = {
18677         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18678     };
18679
18680     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyPanel_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18681     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18682     if (SWIG_arg_fail(1)) SWIG_fail;
18683     {
18684         arg2 = (int)(SWIG_As_int(obj1));
18685         if (SWIG_arg_fail(2)) SWIG_fail;
18686     }
18687     {
18688         arg3 = (int)(SWIG_As_int(obj2));
18689         if (SWIG_arg_fail(3)) SWIG_fail;
18690     }
18691     {
18692         arg4 = (int)(SWIG_As_int(obj3));
18693         if (SWIG_arg_fail(4)) SWIG_fail;
18694     }
18695     {
18696         arg5 = (int)(SWIG_As_int(obj4));
18697         if (SWIG_arg_fail(5)) SWIG_fail;
18698     }
18699     {
18700         PyThreadState* __tstate = wxPyBeginAllowThreads();
18701         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
18702
18703         wxPyEndAllowThreads(__tstate);
18704         if (PyErr_Occurred()) SWIG_fail;
18705     }
18706     Py_INCREF(Py_None); resultobj = Py_None;
18707     return resultobj;
18708     fail:
18709     return NULL;
18710 }
18711
18712
18713 static PyObject *_wrap_PyPanel_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18714     PyObject *resultobj;
18715     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18716     int arg2 ;
18717     int arg3 ;
18718     int arg4 ;
18719     int arg5 ;
18720     int arg6 = (int) wxSIZE_AUTO ;
18721     PyObject * obj0 = 0 ;
18722     PyObject * obj1 = 0 ;
18723     PyObject * obj2 = 0 ;
18724     PyObject * obj3 = 0 ;
18725     PyObject * obj4 = 0 ;
18726     PyObject * obj5 = 0 ;
18727     char *kwnames[] = {
18728         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
18729     };
18730
18731     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyPanel_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
18732     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18733     if (SWIG_arg_fail(1)) SWIG_fail;
18734     {
18735         arg2 = (int)(SWIG_As_int(obj1));
18736         if (SWIG_arg_fail(2)) SWIG_fail;
18737     }
18738     {
18739         arg3 = (int)(SWIG_As_int(obj2));
18740         if (SWIG_arg_fail(3)) SWIG_fail;
18741     }
18742     {
18743         arg4 = (int)(SWIG_As_int(obj3));
18744         if (SWIG_arg_fail(4)) SWIG_fail;
18745     }
18746     {
18747         arg5 = (int)(SWIG_As_int(obj4));
18748         if (SWIG_arg_fail(5)) SWIG_fail;
18749     }
18750     if (obj5) {
18751         {
18752             arg6 = (int)(SWIG_As_int(obj5));
18753             if (SWIG_arg_fail(6)) SWIG_fail;
18754         }
18755     }
18756     {
18757         PyThreadState* __tstate = wxPyBeginAllowThreads();
18758         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
18759
18760         wxPyEndAllowThreads(__tstate);
18761         if (PyErr_Occurred()) SWIG_fail;
18762     }
18763     Py_INCREF(Py_None); resultobj = Py_None;
18764     return resultobj;
18765     fail:
18766     return NULL;
18767 }
18768
18769
18770 static PyObject *_wrap_PyPanel_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18771     PyObject *resultobj;
18772     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18773     int arg2 ;
18774     int arg3 ;
18775     PyObject * obj0 = 0 ;
18776     PyObject * obj1 = 0 ;
18777     PyObject * obj2 = 0 ;
18778     char *kwnames[] = {
18779         (char *) "self",(char *) "width",(char *) "height", NULL
18780     };
18781
18782     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18783     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18784     if (SWIG_arg_fail(1)) SWIG_fail;
18785     {
18786         arg2 = (int)(SWIG_As_int(obj1));
18787         if (SWIG_arg_fail(2)) SWIG_fail;
18788     }
18789     {
18790         arg3 = (int)(SWIG_As_int(obj2));
18791         if (SWIG_arg_fail(3)) SWIG_fail;
18792     }
18793     {
18794         PyThreadState* __tstate = wxPyBeginAllowThreads();
18795         (arg1)->base_DoSetClientSize(arg2,arg3);
18796
18797         wxPyEndAllowThreads(__tstate);
18798         if (PyErr_Occurred()) SWIG_fail;
18799     }
18800     Py_INCREF(Py_None); resultobj = Py_None;
18801     return resultobj;
18802     fail:
18803     return NULL;
18804 }
18805
18806
18807 static PyObject *_wrap_PyPanel_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18808     PyObject *resultobj;
18809     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18810     int arg2 ;
18811     int arg3 ;
18812     PyObject * obj0 = 0 ;
18813     PyObject * obj1 = 0 ;
18814     PyObject * obj2 = 0 ;
18815     char *kwnames[] = {
18816         (char *) "self",(char *) "x",(char *) "y", NULL
18817     };
18818
18819     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPanel_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
18820     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18821     if (SWIG_arg_fail(1)) SWIG_fail;
18822     {
18823         arg2 = (int)(SWIG_As_int(obj1));
18824         if (SWIG_arg_fail(2)) SWIG_fail;
18825     }
18826     {
18827         arg3 = (int)(SWIG_As_int(obj2));
18828         if (SWIG_arg_fail(3)) SWIG_fail;
18829     }
18830     {
18831         PyThreadState* __tstate = wxPyBeginAllowThreads();
18832         (arg1)->base_DoSetVirtualSize(arg2,arg3);
18833
18834         wxPyEndAllowThreads(__tstate);
18835         if (PyErr_Occurred()) SWIG_fail;
18836     }
18837     Py_INCREF(Py_None); resultobj = Py_None;
18838     return resultobj;
18839     fail:
18840     return NULL;
18841 }
18842
18843
18844 static PyObject *_wrap_PyPanel_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18845     PyObject *resultobj;
18846     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18847     int *arg2 = (int *) 0 ;
18848     int *arg3 = (int *) 0 ;
18849     int temp2 ;
18850     int res2 = 0 ;
18851     int temp3 ;
18852     int res3 = 0 ;
18853     PyObject * obj0 = 0 ;
18854     char *kwnames[] = {
18855         (char *) "self", NULL
18856     };
18857
18858     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18859     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18860     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetSize",kwnames,&obj0)) goto fail;
18861     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18862     if (SWIG_arg_fail(1)) SWIG_fail;
18863     {
18864         PyThreadState* __tstate = wxPyBeginAllowThreads();
18865         ((wxPyPanel const *)arg1)->base_DoGetSize(arg2,arg3);
18866
18867         wxPyEndAllowThreads(__tstate);
18868         if (PyErr_Occurred()) SWIG_fail;
18869     }
18870     Py_INCREF(Py_None); resultobj = Py_None;
18871     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18872     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18873     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18874     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18875     return resultobj;
18876     fail:
18877     return NULL;
18878 }
18879
18880
18881 static PyObject *_wrap_PyPanel_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
18882     PyObject *resultobj;
18883     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18884     int *arg2 = (int *) 0 ;
18885     int *arg3 = (int *) 0 ;
18886     int temp2 ;
18887     int res2 = 0 ;
18888     int temp3 ;
18889     int res3 = 0 ;
18890     PyObject * obj0 = 0 ;
18891     char *kwnames[] = {
18892         (char *) "self", NULL
18893     };
18894
18895     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18896     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18897     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetClientSize",kwnames,&obj0)) goto fail;
18898     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18899     if (SWIG_arg_fail(1)) SWIG_fail;
18900     {
18901         PyThreadState* __tstate = wxPyBeginAllowThreads();
18902         ((wxPyPanel const *)arg1)->base_DoGetClientSize(arg2,arg3);
18903
18904         wxPyEndAllowThreads(__tstate);
18905         if (PyErr_Occurred()) SWIG_fail;
18906     }
18907     Py_INCREF(Py_None); resultobj = Py_None;
18908     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18909     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18910     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18911     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18912     return resultobj;
18913     fail:
18914     return NULL;
18915 }
18916
18917
18918 static PyObject *_wrap_PyPanel_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18919     PyObject *resultobj;
18920     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18921     int *arg2 = (int *) 0 ;
18922     int *arg3 = (int *) 0 ;
18923     int temp2 ;
18924     int res2 = 0 ;
18925     int temp3 ;
18926     int res3 = 0 ;
18927     PyObject * obj0 = 0 ;
18928     char *kwnames[] = {
18929         (char *) "self", NULL
18930     };
18931
18932     arg2 = &temp2; res2 = SWIG_NEWOBJ;
18933     arg3 = &temp3; res3 = SWIG_NEWOBJ;
18934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetPosition",kwnames,&obj0)) goto fail;
18935     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18936     if (SWIG_arg_fail(1)) SWIG_fail;
18937     {
18938         PyThreadState* __tstate = wxPyBeginAllowThreads();
18939         ((wxPyPanel const *)arg1)->base_DoGetPosition(arg2,arg3);
18940
18941         wxPyEndAllowThreads(__tstate);
18942         if (PyErr_Occurred()) SWIG_fail;
18943     }
18944     Py_INCREF(Py_None); resultobj = Py_None;
18945     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18946     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
18947     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18948     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18949     return resultobj;
18950     fail:
18951     return NULL;
18952 }
18953
18954
18955 static PyObject *_wrap_PyPanel_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
18956     PyObject *resultobj;
18957     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18958     wxSize result;
18959     PyObject * obj0 = 0 ;
18960     char *kwnames[] = {
18961         (char *) "self", NULL
18962     };
18963
18964     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
18965     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18966     if (SWIG_arg_fail(1)) SWIG_fail;
18967     {
18968         PyThreadState* __tstate = wxPyBeginAllowThreads();
18969         result = ((wxPyPanel const *)arg1)->base_DoGetVirtualSize();
18970
18971         wxPyEndAllowThreads(__tstate);
18972         if (PyErr_Occurred()) SWIG_fail;
18973     }
18974     {
18975         wxSize * resultptr;
18976         resultptr = new wxSize((wxSize &)(result));
18977         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18978     }
18979     return resultobj;
18980     fail:
18981     return NULL;
18982 }
18983
18984
18985 static PyObject *_wrap_PyPanel_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
18986     PyObject *resultobj;
18987     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
18988     wxSize result;
18989     PyObject * obj0 = 0 ;
18990     char *kwnames[] = {
18991         (char *) "self", NULL
18992     };
18993
18994     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_DoGetBestSize",kwnames,&obj0)) goto fail;
18995     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
18996     if (SWIG_arg_fail(1)) SWIG_fail;
18997     {
18998         PyThreadState* __tstate = wxPyBeginAllowThreads();
18999         result = ((wxPyPanel const *)arg1)->base_DoGetBestSize();
19000
19001         wxPyEndAllowThreads(__tstate);
19002         if (PyErr_Occurred()) SWIG_fail;
19003     }
19004     {
19005         wxSize * resultptr;
19006         resultptr = new wxSize((wxSize &)(result));
19007         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19008     }
19009     return resultobj;
19010     fail:
19011     return NULL;
19012 }
19013
19014
19015 static PyObject *_wrap_PyPanel_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
19016     PyObject *resultobj;
19017     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19018     PyObject * obj0 = 0 ;
19019     char *kwnames[] = {
19020         (char *) "self", NULL
19021     };
19022
19023     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_InitDialog",kwnames,&obj0)) goto fail;
19024     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19025     if (SWIG_arg_fail(1)) SWIG_fail;
19026     {
19027         PyThreadState* __tstate = wxPyBeginAllowThreads();
19028         (arg1)->base_InitDialog();
19029
19030         wxPyEndAllowThreads(__tstate);
19031         if (PyErr_Occurred()) SWIG_fail;
19032     }
19033     Py_INCREF(Py_None); resultobj = Py_None;
19034     return resultobj;
19035     fail:
19036     return NULL;
19037 }
19038
19039
19040 static PyObject *_wrap_PyPanel_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19041     PyObject *resultobj;
19042     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19043     bool result;
19044     PyObject * obj0 = 0 ;
19045     char *kwnames[] = {
19046         (char *) "self", NULL
19047     };
19048
19049     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
19050     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19051     if (SWIG_arg_fail(1)) SWIG_fail;
19052     {
19053         PyThreadState* __tstate = wxPyBeginAllowThreads();
19054         result = (bool)(arg1)->base_TransferDataToWindow();
19055
19056         wxPyEndAllowThreads(__tstate);
19057         if (PyErr_Occurred()) SWIG_fail;
19058     }
19059     {
19060         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19061     }
19062     return resultobj;
19063     fail:
19064     return NULL;
19065 }
19066
19067
19068 static PyObject *_wrap_PyPanel_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19069     PyObject *resultobj;
19070     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19071     bool result;
19072     PyObject * obj0 = 0 ;
19073     char *kwnames[] = {
19074         (char *) "self", NULL
19075     };
19076
19077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
19078     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19079     if (SWIG_arg_fail(1)) SWIG_fail;
19080     {
19081         PyThreadState* __tstate = wxPyBeginAllowThreads();
19082         result = (bool)(arg1)->base_TransferDataFromWindow();
19083
19084         wxPyEndAllowThreads(__tstate);
19085         if (PyErr_Occurred()) SWIG_fail;
19086     }
19087     {
19088         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19089     }
19090     return resultobj;
19091     fail:
19092     return NULL;
19093 }
19094
19095
19096 static PyObject *_wrap_PyPanel_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
19097     PyObject *resultobj;
19098     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19099     bool result;
19100     PyObject * obj0 = 0 ;
19101     char *kwnames[] = {
19102         (char *) "self", NULL
19103     };
19104
19105     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_Validate",kwnames,&obj0)) goto fail;
19106     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19107     if (SWIG_arg_fail(1)) SWIG_fail;
19108     {
19109         PyThreadState* __tstate = wxPyBeginAllowThreads();
19110         result = (bool)(arg1)->base_Validate();
19111
19112         wxPyEndAllowThreads(__tstate);
19113         if (PyErr_Occurred()) SWIG_fail;
19114     }
19115     {
19116         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19117     }
19118     return resultobj;
19119     fail:
19120     return NULL;
19121 }
19122
19123
19124 static PyObject *_wrap_PyPanel_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
19125     PyObject *resultobj;
19126     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19127     bool result;
19128     PyObject * obj0 = 0 ;
19129     char *kwnames[] = {
19130         (char *) "self", NULL
19131     };
19132
19133     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_AcceptsFocus",kwnames,&obj0)) goto fail;
19134     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19135     if (SWIG_arg_fail(1)) SWIG_fail;
19136     {
19137         PyThreadState* __tstate = wxPyBeginAllowThreads();
19138         result = (bool)((wxPyPanel const *)arg1)->base_AcceptsFocus();
19139
19140         wxPyEndAllowThreads(__tstate);
19141         if (PyErr_Occurred()) SWIG_fail;
19142     }
19143     {
19144         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19145     }
19146     return resultobj;
19147     fail:
19148     return NULL;
19149 }
19150
19151
19152 static PyObject *_wrap_PyPanel_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
19153     PyObject *resultobj;
19154     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19155     bool result;
19156     PyObject * obj0 = 0 ;
19157     char *kwnames[] = {
19158         (char *) "self", NULL
19159     };
19160
19161     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
19162     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19163     if (SWIG_arg_fail(1)) SWIG_fail;
19164     {
19165         PyThreadState* __tstate = wxPyBeginAllowThreads();
19166         result = (bool)((wxPyPanel const *)arg1)->base_AcceptsFocusFromKeyboard();
19167
19168         wxPyEndAllowThreads(__tstate);
19169         if (PyErr_Occurred()) SWIG_fail;
19170     }
19171     {
19172         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19173     }
19174     return resultobj;
19175     fail:
19176     return NULL;
19177 }
19178
19179
19180 static PyObject *_wrap_PyPanel_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
19181     PyObject *resultobj;
19182     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19183     wxSize result;
19184     PyObject * obj0 = 0 ;
19185     char *kwnames[] = {
19186         (char *) "self", NULL
19187     };
19188
19189     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_GetMaxSize",kwnames,&obj0)) goto fail;
19190     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19191     if (SWIG_arg_fail(1)) SWIG_fail;
19192     {
19193         PyThreadState* __tstate = wxPyBeginAllowThreads();
19194         result = ((wxPyPanel const *)arg1)->base_GetMaxSize();
19195
19196         wxPyEndAllowThreads(__tstate);
19197         if (PyErr_Occurred()) SWIG_fail;
19198     }
19199     {
19200         wxSize * resultptr;
19201         resultptr = new wxSize((wxSize &)(result));
19202         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19203     }
19204     return resultobj;
19205     fail:
19206     return NULL;
19207 }
19208
19209
19210 static PyObject *_wrap_PyPanel_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
19211     PyObject *resultobj;
19212     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19213     wxWindow *arg2 = (wxWindow *) 0 ;
19214     PyObject * obj0 = 0 ;
19215     PyObject * obj1 = 0 ;
19216     char *kwnames[] = {
19217         (char *) "self",(char *) "child", NULL
19218     };
19219
19220     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
19221     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPanel, SWIG_POINTER_EXCEPTION | 0);
19222     if (SWIG_arg_fail(1)) SWIG_fail;
19223     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19224     if (SWIG_arg_fail(2)) SWIG_fail;
19225     {
19226         PyThreadState* __tstate = wxPyBeginAllowThreads();
19227         (arg1)->base_AddChild(arg2);
19228
19229         wxPyEndAllowThreads(__tstate);
19230         if (PyErr_Occurred()) SWIG_fail;
19231     }
19232     Py_INCREF(Py_None); resultobj = Py_None;
19233     return resultobj;
19234     fail:
19235     return NULL;
19236 }
19237
19238
19239 static PyObject *_wrap_PyPanel_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
19240     PyObject *resultobj;
19241     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19242     wxWindow *arg2 = (wxWindow *) 0 ;
19243     PyObject * obj0 = 0 ;
19244     PyObject * obj1 = 0 ;
19245     char *kwnames[] = {
19246         (char *) "self",(char *) "child", NULL
19247     };
19248
19249     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPanel_base_RemoveChild",kwnames,&obj0,&obj1)) 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     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19253     if (SWIG_arg_fail(2)) SWIG_fail;
19254     {
19255         PyThreadState* __tstate = wxPyBeginAllowThreads();
19256         (arg1)->base_RemoveChild(arg2);
19257
19258         wxPyEndAllowThreads(__tstate);
19259         if (PyErr_Occurred()) SWIG_fail;
19260     }
19261     Py_INCREF(Py_None); resultobj = Py_None;
19262     return resultobj;
19263     fail:
19264     return NULL;
19265 }
19266
19267
19268 static PyObject *_wrap_PyPanel_base_ShouldInheritColours(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_ShouldInheritColours",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_ShouldInheritColours();
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_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
19297     PyObject *resultobj;
19298     wxPyPanel *arg1 = (wxPyPanel *) 0 ;
19299     wxVisualAttributes result;
19300     PyObject * obj0 = 0 ;
19301     char *kwnames[] = {
19302         (char *) "self", NULL
19303     };
19304
19305     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPanel_base_GetDefaultAttributes",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 = (arg1)->base_GetDefaultAttributes();
19311
19312         wxPyEndAllowThreads(__tstate);
19313         if (PyErr_Occurred()) SWIG_fail;
19314     }
19315     {
19316         wxVisualAttributes * resultptr;
19317         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
19318         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
19319     }
19320     return resultobj;
19321     fail:
19322     return NULL;
19323 }
19324
19325
19326 static PyObject * PyPanel_swigregister(PyObject *, PyObject *args) {
19327     PyObject *obj;
19328     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19329     SWIG_TypeClientData(SWIGTYPE_p_wxPyPanel, obj);
19330     Py_INCREF(obj);
19331     return Py_BuildValue((char *)"");
19332 }
19333 static PyObject *_wrap_new_PyScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19334     PyObject *resultobj;
19335     wxWindow *arg1 = (wxWindow *) 0 ;
19336     int arg2 = (int) (int)-1 ;
19337     wxPoint const &arg3_defvalue = wxDefaultPosition ;
19338     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
19339     wxSize const &arg4_defvalue = wxDefaultSize ;
19340     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
19341     long arg5 = (long) 0 ;
19342     wxString const &arg6_defvalue = wxPyPanelNameStr ;
19343     wxString *arg6 = (wxString *) &arg6_defvalue ;
19344     wxPyScrolledWindow *result;
19345     wxPoint temp3 ;
19346     wxSize temp4 ;
19347     bool temp6 = false ;
19348     PyObject * obj0 = 0 ;
19349     PyObject * obj1 = 0 ;
19350     PyObject * obj2 = 0 ;
19351     PyObject * obj3 = 0 ;
19352     PyObject * obj4 = 0 ;
19353     PyObject * obj5 = 0 ;
19354     char *kwnames[] = {
19355         (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
19356     };
19357
19358     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_PyScrolledWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19359     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19360     if (SWIG_arg_fail(1)) SWIG_fail;
19361     if (obj1) {
19362         {
19363             arg2 = (int const)(SWIG_As_int(obj1));
19364             if (SWIG_arg_fail(2)) SWIG_fail;
19365         }
19366     }
19367     if (obj2) {
19368         {
19369             arg3 = &temp3;
19370             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19371         }
19372     }
19373     if (obj3) {
19374         {
19375             arg4 = &temp4;
19376             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
19377         }
19378     }
19379     if (obj4) {
19380         {
19381             arg5 = (long)(SWIG_As_long(obj4));
19382             if (SWIG_arg_fail(5)) SWIG_fail;
19383         }
19384     }
19385     if (obj5) {
19386         {
19387             arg6 = wxString_in_helper(obj5);
19388             if (arg6 == NULL) SWIG_fail;
19389             temp6 = true;
19390         }
19391     }
19392     {
19393         if (!wxPyCheckForApp()) SWIG_fail;
19394         PyThreadState* __tstate = wxPyBeginAllowThreads();
19395         result = (wxPyScrolledWindow *)new wxPyScrolledWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
19396
19397         wxPyEndAllowThreads(__tstate);
19398         if (PyErr_Occurred()) SWIG_fail;
19399     }
19400     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyScrolledWindow, 1);
19401     {
19402         if (temp6)
19403         delete arg6;
19404     }
19405     return resultobj;
19406     fail:
19407     {
19408         if (temp6)
19409         delete arg6;
19410     }
19411     return NULL;
19412 }
19413
19414
19415 static PyObject *_wrap_new_PrePyScrolledWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19416     PyObject *resultobj;
19417     wxPyScrolledWindow *result;
19418     char *kwnames[] = {
19419         NULL
19420     };
19421
19422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PrePyScrolledWindow",kwnames)) goto fail;
19423     {
19424         if (!wxPyCheckForApp()) SWIG_fail;
19425         PyThreadState* __tstate = wxPyBeginAllowThreads();
19426         result = (wxPyScrolledWindow *)new wxPyScrolledWindow();
19427
19428         wxPyEndAllowThreads(__tstate);
19429         if (PyErr_Occurred()) SWIG_fail;
19430     }
19431     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyScrolledWindow, 1);
19432     return resultobj;
19433     fail:
19434     return NULL;
19435 }
19436
19437
19438 static PyObject *_wrap_PyScrolledWindow__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
19439     PyObject *resultobj;
19440     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19441     PyObject *arg2 = (PyObject *) 0 ;
19442     PyObject *arg3 = (PyObject *) 0 ;
19443     PyObject * obj0 = 0 ;
19444     PyObject * obj1 = 0 ;
19445     PyObject * obj2 = 0 ;
19446     char *kwnames[] = {
19447         (char *) "self",(char *) "self",(char *) "_class", NULL
19448     };
19449
19450     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
19451     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19452     if (SWIG_arg_fail(1)) SWIG_fail;
19453     arg2 = obj1;
19454     arg3 = obj2;
19455     {
19456         PyThreadState* __tstate = wxPyBeginAllowThreads();
19457         (arg1)->_setCallbackInfo(arg2,arg3);
19458
19459         wxPyEndAllowThreads(__tstate);
19460         if (PyErr_Occurred()) SWIG_fail;
19461     }
19462     Py_INCREF(Py_None); resultobj = Py_None;
19463     return resultobj;
19464     fail:
19465     return NULL;
19466 }
19467
19468
19469 static PyObject *_wrap_PyScrolledWindow_SetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19470     PyObject *resultobj;
19471     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19472     wxSize *arg2 = 0 ;
19473     wxSize temp2 ;
19474     PyObject * obj0 = 0 ;
19475     PyObject * obj1 = 0 ;
19476     char *kwnames[] = {
19477         (char *) "self",(char *) "size", NULL
19478     };
19479
19480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_SetBestSize",kwnames,&obj0,&obj1)) goto fail;
19481     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19482     if (SWIG_arg_fail(1)) SWIG_fail;
19483     {
19484         arg2 = &temp2;
19485         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
19486     }
19487     {
19488         PyThreadState* __tstate = wxPyBeginAllowThreads();
19489         (arg1)->SetBestSize((wxSize const &)*arg2);
19490
19491         wxPyEndAllowThreads(__tstate);
19492         if (PyErr_Occurred()) SWIG_fail;
19493     }
19494     Py_INCREF(Py_None); resultobj = Py_None;
19495     return resultobj;
19496     fail:
19497     return NULL;
19498 }
19499
19500
19501 static PyObject *_wrap_PyScrolledWindow_DoEraseBackground(PyObject *, PyObject *args, PyObject *kwargs) {
19502     PyObject *resultobj;
19503     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19504     wxDC *arg2 = (wxDC *) 0 ;
19505     bool result;
19506     PyObject * obj0 = 0 ;
19507     PyObject * obj1 = 0 ;
19508     char *kwnames[] = {
19509         (char *) "self",(char *) "dc", NULL
19510     };
19511
19512     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_DoEraseBackground",kwnames,&obj0,&obj1)) goto fail;
19513     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19514     if (SWIG_arg_fail(1)) SWIG_fail;
19515     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19516     if (SWIG_arg_fail(2)) SWIG_fail;
19517     {
19518         PyThreadState* __tstate = wxPyBeginAllowThreads();
19519         result = (bool)(arg1)->DoEraseBackground(arg2);
19520
19521         wxPyEndAllowThreads(__tstate);
19522         if (PyErr_Occurred()) SWIG_fail;
19523     }
19524     {
19525         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19526     }
19527     return resultobj;
19528     fail:
19529     return NULL;
19530 }
19531
19532
19533 static PyObject *_wrap_PyScrolledWindow_base_DoMoveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19534     PyObject *resultobj;
19535     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19536     int arg2 ;
19537     int arg3 ;
19538     int arg4 ;
19539     int arg5 ;
19540     PyObject * obj0 = 0 ;
19541     PyObject * obj1 = 0 ;
19542     PyObject * obj2 = 0 ;
19543     PyObject * obj3 = 0 ;
19544     PyObject * obj4 = 0 ;
19545     char *kwnames[] = {
19546         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
19547     };
19548
19549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyScrolledWindow_base_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19551     if (SWIG_arg_fail(1)) SWIG_fail;
19552     {
19553         arg2 = (int)(SWIG_As_int(obj1));
19554         if (SWIG_arg_fail(2)) SWIG_fail;
19555     }
19556     {
19557         arg3 = (int)(SWIG_As_int(obj2));
19558         if (SWIG_arg_fail(3)) SWIG_fail;
19559     }
19560     {
19561         arg4 = (int)(SWIG_As_int(obj3));
19562         if (SWIG_arg_fail(4)) SWIG_fail;
19563     }
19564     {
19565         arg5 = (int)(SWIG_As_int(obj4));
19566         if (SWIG_arg_fail(5)) SWIG_fail;
19567     }
19568     {
19569         PyThreadState* __tstate = wxPyBeginAllowThreads();
19570         (arg1)->base_DoMoveWindow(arg2,arg3,arg4,arg5);
19571
19572         wxPyEndAllowThreads(__tstate);
19573         if (PyErr_Occurred()) SWIG_fail;
19574     }
19575     Py_INCREF(Py_None); resultobj = Py_None;
19576     return resultobj;
19577     fail:
19578     return NULL;
19579 }
19580
19581
19582 static PyObject *_wrap_PyScrolledWindow_base_DoSetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19583     PyObject *resultobj;
19584     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19585     int arg2 ;
19586     int arg3 ;
19587     int arg4 ;
19588     int arg5 ;
19589     int arg6 = (int) wxSIZE_AUTO ;
19590     PyObject * obj0 = 0 ;
19591     PyObject * obj1 = 0 ;
19592     PyObject * obj2 = 0 ;
19593     PyObject * obj3 = 0 ;
19594     PyObject * obj4 = 0 ;
19595     PyObject * obj5 = 0 ;
19596     char *kwnames[] = {
19597         (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
19598     };
19599
19600     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyScrolledWindow_base_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19601     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19602     if (SWIG_arg_fail(1)) SWIG_fail;
19603     {
19604         arg2 = (int)(SWIG_As_int(obj1));
19605         if (SWIG_arg_fail(2)) SWIG_fail;
19606     }
19607     {
19608         arg3 = (int)(SWIG_As_int(obj2));
19609         if (SWIG_arg_fail(3)) SWIG_fail;
19610     }
19611     {
19612         arg4 = (int)(SWIG_As_int(obj3));
19613         if (SWIG_arg_fail(4)) SWIG_fail;
19614     }
19615     {
19616         arg5 = (int)(SWIG_As_int(obj4));
19617         if (SWIG_arg_fail(5)) SWIG_fail;
19618     }
19619     if (obj5) {
19620         {
19621             arg6 = (int)(SWIG_As_int(obj5));
19622             if (SWIG_arg_fail(6)) SWIG_fail;
19623         }
19624     }
19625     {
19626         PyThreadState* __tstate = wxPyBeginAllowThreads();
19627         (arg1)->base_DoSetSize(arg2,arg3,arg4,arg5,arg6);
19628
19629         wxPyEndAllowThreads(__tstate);
19630         if (PyErr_Occurred()) SWIG_fail;
19631     }
19632     Py_INCREF(Py_None); resultobj = Py_None;
19633     return resultobj;
19634     fail:
19635     return NULL;
19636 }
19637
19638
19639 static PyObject *_wrap_PyScrolledWindow_base_DoSetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19640     PyObject *resultobj;
19641     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19642     int arg2 ;
19643     int arg3 ;
19644     PyObject * obj0 = 0 ;
19645     PyObject * obj1 = 0 ;
19646     PyObject * obj2 = 0 ;
19647     char *kwnames[] = {
19648         (char *) "self",(char *) "width",(char *) "height", NULL
19649     };
19650
19651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow_base_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
19652     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19653     if (SWIG_arg_fail(1)) SWIG_fail;
19654     {
19655         arg2 = (int)(SWIG_As_int(obj1));
19656         if (SWIG_arg_fail(2)) SWIG_fail;
19657     }
19658     {
19659         arg3 = (int)(SWIG_As_int(obj2));
19660         if (SWIG_arg_fail(3)) SWIG_fail;
19661     }
19662     {
19663         PyThreadState* __tstate = wxPyBeginAllowThreads();
19664         (arg1)->base_DoSetClientSize(arg2,arg3);
19665
19666         wxPyEndAllowThreads(__tstate);
19667         if (PyErr_Occurred()) SWIG_fail;
19668     }
19669     Py_INCREF(Py_None); resultobj = Py_None;
19670     return resultobj;
19671     fail:
19672     return NULL;
19673 }
19674
19675
19676 static PyObject *_wrap_PyScrolledWindow_base_DoSetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19677     PyObject *resultobj;
19678     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19679     int arg2 ;
19680     int arg3 ;
19681     PyObject * obj0 = 0 ;
19682     PyObject * obj1 = 0 ;
19683     PyObject * obj2 = 0 ;
19684     char *kwnames[] = {
19685         (char *) "self",(char *) "x",(char *) "y", NULL
19686     };
19687
19688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyScrolledWindow_base_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
19689     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19690     if (SWIG_arg_fail(1)) SWIG_fail;
19691     {
19692         arg2 = (int)(SWIG_As_int(obj1));
19693         if (SWIG_arg_fail(2)) SWIG_fail;
19694     }
19695     {
19696         arg3 = (int)(SWIG_As_int(obj2));
19697         if (SWIG_arg_fail(3)) SWIG_fail;
19698     }
19699     {
19700         PyThreadState* __tstate = wxPyBeginAllowThreads();
19701         (arg1)->base_DoSetVirtualSize(arg2,arg3);
19702
19703         wxPyEndAllowThreads(__tstate);
19704         if (PyErr_Occurred()) SWIG_fail;
19705     }
19706     Py_INCREF(Py_None); resultobj = Py_None;
19707     return resultobj;
19708     fail:
19709     return NULL;
19710 }
19711
19712
19713 static PyObject *_wrap_PyScrolledWindow_base_DoGetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19714     PyObject *resultobj;
19715     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19716     int *arg2 = (int *) 0 ;
19717     int *arg3 = (int *) 0 ;
19718     int temp2 ;
19719     int res2 = 0 ;
19720     int temp3 ;
19721     int res3 = 0 ;
19722     PyObject * obj0 = 0 ;
19723     char *kwnames[] = {
19724         (char *) "self", NULL
19725     };
19726
19727     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19728     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19729     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetSize",kwnames,&obj0)) goto fail;
19730     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19731     if (SWIG_arg_fail(1)) SWIG_fail;
19732     {
19733         PyThreadState* __tstate = wxPyBeginAllowThreads();
19734         ((wxPyScrolledWindow const *)arg1)->base_DoGetSize(arg2,arg3);
19735
19736         wxPyEndAllowThreads(__tstate);
19737         if (PyErr_Occurred()) SWIG_fail;
19738     }
19739     Py_INCREF(Py_None); resultobj = Py_None;
19740     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19741     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19742     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19743     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19744     return resultobj;
19745     fail:
19746     return NULL;
19747 }
19748
19749
19750 static PyObject *_wrap_PyScrolledWindow_base_DoGetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
19751     PyObject *resultobj;
19752     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19753     int *arg2 = (int *) 0 ;
19754     int *arg3 = (int *) 0 ;
19755     int temp2 ;
19756     int res2 = 0 ;
19757     int temp3 ;
19758     int res3 = 0 ;
19759     PyObject * obj0 = 0 ;
19760     char *kwnames[] = {
19761         (char *) "self", NULL
19762     };
19763
19764     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19765     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19766     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetClientSize",kwnames,&obj0)) goto fail;
19767     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19768     if (SWIG_arg_fail(1)) SWIG_fail;
19769     {
19770         PyThreadState* __tstate = wxPyBeginAllowThreads();
19771         ((wxPyScrolledWindow const *)arg1)->base_DoGetClientSize(arg2,arg3);
19772
19773         wxPyEndAllowThreads(__tstate);
19774         if (PyErr_Occurred()) SWIG_fail;
19775     }
19776     Py_INCREF(Py_None); resultobj = Py_None;
19777     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19778     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19779     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19780     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19781     return resultobj;
19782     fail:
19783     return NULL;
19784 }
19785
19786
19787 static PyObject *_wrap_PyScrolledWindow_base_DoGetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19788     PyObject *resultobj;
19789     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19790     int *arg2 = (int *) 0 ;
19791     int *arg3 = (int *) 0 ;
19792     int temp2 ;
19793     int res2 = 0 ;
19794     int temp3 ;
19795     int res3 = 0 ;
19796     PyObject * obj0 = 0 ;
19797     char *kwnames[] = {
19798         (char *) "self", NULL
19799     };
19800
19801     arg2 = &temp2; res2 = SWIG_NEWOBJ;
19802     arg3 = &temp3; res3 = SWIG_NEWOBJ;
19803     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetPosition",kwnames,&obj0)) goto fail;
19804     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19805     if (SWIG_arg_fail(1)) SWIG_fail;
19806     {
19807         PyThreadState* __tstate = wxPyBeginAllowThreads();
19808         ((wxPyScrolledWindow const *)arg1)->base_DoGetPosition(arg2,arg3);
19809
19810         wxPyEndAllowThreads(__tstate);
19811         if (PyErr_Occurred()) SWIG_fail;
19812     }
19813     Py_INCREF(Py_None); resultobj = Py_None;
19814     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19815     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
19816     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19817     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19818     return resultobj;
19819     fail:
19820     return NULL;
19821 }
19822
19823
19824 static PyObject *_wrap_PyScrolledWindow_base_DoGetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
19825     PyObject *resultobj;
19826     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19827     wxSize result;
19828     PyObject * obj0 = 0 ;
19829     char *kwnames[] = {
19830         (char *) "self", NULL
19831     };
19832
19833     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetVirtualSize",kwnames,&obj0)) goto fail;
19834     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19835     if (SWIG_arg_fail(1)) SWIG_fail;
19836     {
19837         PyThreadState* __tstate = wxPyBeginAllowThreads();
19838         result = ((wxPyScrolledWindow const *)arg1)->base_DoGetVirtualSize();
19839
19840         wxPyEndAllowThreads(__tstate);
19841         if (PyErr_Occurred()) SWIG_fail;
19842     }
19843     {
19844         wxSize * resultptr;
19845         resultptr = new wxSize((wxSize &)(result));
19846         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19847     }
19848     return resultobj;
19849     fail:
19850     return NULL;
19851 }
19852
19853
19854 static PyObject *_wrap_PyScrolledWindow_base_DoGetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
19855     PyObject *resultobj;
19856     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19857     wxSize result;
19858     PyObject * obj0 = 0 ;
19859     char *kwnames[] = {
19860         (char *) "self", NULL
19861     };
19862
19863     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_DoGetBestSize",kwnames,&obj0)) goto fail;
19864     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19865     if (SWIG_arg_fail(1)) SWIG_fail;
19866     {
19867         PyThreadState* __tstate = wxPyBeginAllowThreads();
19868         result = ((wxPyScrolledWindow const *)arg1)->base_DoGetBestSize();
19869
19870         wxPyEndAllowThreads(__tstate);
19871         if (PyErr_Occurred()) SWIG_fail;
19872     }
19873     {
19874         wxSize * resultptr;
19875         resultptr = new wxSize((wxSize &)(result));
19876         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19877     }
19878     return resultobj;
19879     fail:
19880     return NULL;
19881 }
19882
19883
19884 static PyObject *_wrap_PyScrolledWindow_base_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
19885     PyObject *resultobj;
19886     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19887     PyObject * obj0 = 0 ;
19888     char *kwnames[] = {
19889         (char *) "self", NULL
19890     };
19891
19892     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_InitDialog",kwnames,&obj0)) goto fail;
19893     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19894     if (SWIG_arg_fail(1)) SWIG_fail;
19895     {
19896         PyThreadState* __tstate = wxPyBeginAllowThreads();
19897         (arg1)->base_InitDialog();
19898
19899         wxPyEndAllowThreads(__tstate);
19900         if (PyErr_Occurred()) SWIG_fail;
19901     }
19902     Py_INCREF(Py_None); resultobj = Py_None;
19903     return resultobj;
19904     fail:
19905     return NULL;
19906 }
19907
19908
19909 static PyObject *_wrap_PyScrolledWindow_base_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19910     PyObject *resultobj;
19911     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19912     bool result;
19913     PyObject * obj0 = 0 ;
19914     char *kwnames[] = {
19915         (char *) "self", NULL
19916     };
19917
19918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_TransferDataToWindow",kwnames,&obj0)) goto fail;
19919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19920     if (SWIG_arg_fail(1)) SWIG_fail;
19921     {
19922         PyThreadState* __tstate = wxPyBeginAllowThreads();
19923         result = (bool)(arg1)->base_TransferDataToWindow();
19924
19925         wxPyEndAllowThreads(__tstate);
19926         if (PyErr_Occurred()) SWIG_fail;
19927     }
19928     {
19929         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19930     }
19931     return resultobj;
19932     fail:
19933     return NULL;
19934 }
19935
19936
19937 static PyObject *_wrap_PyScrolledWindow_base_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19938     PyObject *resultobj;
19939     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19940     bool result;
19941     PyObject * obj0 = 0 ;
19942     char *kwnames[] = {
19943         (char *) "self", NULL
19944     };
19945
19946     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_TransferDataFromWindow",kwnames,&obj0)) goto fail;
19947     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19948     if (SWIG_arg_fail(1)) SWIG_fail;
19949     {
19950         PyThreadState* __tstate = wxPyBeginAllowThreads();
19951         result = (bool)(arg1)->base_TransferDataFromWindow();
19952
19953         wxPyEndAllowThreads(__tstate);
19954         if (PyErr_Occurred()) SWIG_fail;
19955     }
19956     {
19957         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19958     }
19959     return resultobj;
19960     fail:
19961     return NULL;
19962 }
19963
19964
19965 static PyObject *_wrap_PyScrolledWindow_base_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
19966     PyObject *resultobj;
19967     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19968     bool result;
19969     PyObject * obj0 = 0 ;
19970     char *kwnames[] = {
19971         (char *) "self", NULL
19972     };
19973
19974     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_Validate",kwnames,&obj0)) goto fail;
19975     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
19976     if (SWIG_arg_fail(1)) SWIG_fail;
19977     {
19978         PyThreadState* __tstate = wxPyBeginAllowThreads();
19979         result = (bool)(arg1)->base_Validate();
19980
19981         wxPyEndAllowThreads(__tstate);
19982         if (PyErr_Occurred()) SWIG_fail;
19983     }
19984     {
19985         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19986     }
19987     return resultobj;
19988     fail:
19989     return NULL;
19990 }
19991
19992
19993 static PyObject *_wrap_PyScrolledWindow_base_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
19994     PyObject *resultobj;
19995     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
19996     bool result;
19997     PyObject * obj0 = 0 ;
19998     char *kwnames[] = {
19999         (char *) "self", NULL
20000     };
20001
20002     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_AcceptsFocus",kwnames,&obj0)) goto fail;
20003     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20004     if (SWIG_arg_fail(1)) SWIG_fail;
20005     {
20006         PyThreadState* __tstate = wxPyBeginAllowThreads();
20007         result = (bool)((wxPyScrolledWindow const *)arg1)->base_AcceptsFocus();
20008
20009         wxPyEndAllowThreads(__tstate);
20010         if (PyErr_Occurred()) SWIG_fail;
20011     }
20012     {
20013         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20014     }
20015     return resultobj;
20016     fail:
20017     return NULL;
20018 }
20019
20020
20021 static PyObject *_wrap_PyScrolledWindow_base_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
20022     PyObject *resultobj;
20023     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20024     bool result;
20025     PyObject * obj0 = 0 ;
20026     char *kwnames[] = {
20027         (char *) "self", NULL
20028     };
20029
20030     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
20031     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20032     if (SWIG_arg_fail(1)) SWIG_fail;
20033     {
20034         PyThreadState* __tstate = wxPyBeginAllowThreads();
20035         result = (bool)((wxPyScrolledWindow const *)arg1)->base_AcceptsFocusFromKeyboard();
20036
20037         wxPyEndAllowThreads(__tstate);
20038         if (PyErr_Occurred()) SWIG_fail;
20039     }
20040     {
20041         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20042     }
20043     return resultobj;
20044     fail:
20045     return NULL;
20046 }
20047
20048
20049 static PyObject *_wrap_PyScrolledWindow_base_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
20050     PyObject *resultobj;
20051     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20052     wxSize result;
20053     PyObject * obj0 = 0 ;
20054     char *kwnames[] = {
20055         (char *) "self", NULL
20056     };
20057
20058     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_GetMaxSize",kwnames,&obj0)) goto fail;
20059     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20060     if (SWIG_arg_fail(1)) SWIG_fail;
20061     {
20062         PyThreadState* __tstate = wxPyBeginAllowThreads();
20063         result = ((wxPyScrolledWindow const *)arg1)->base_GetMaxSize();
20064
20065         wxPyEndAllowThreads(__tstate);
20066         if (PyErr_Occurred()) SWIG_fail;
20067     }
20068     {
20069         wxSize * resultptr;
20070         resultptr = new wxSize((wxSize &)(result));
20071         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20072     }
20073     return resultobj;
20074     fail:
20075     return NULL;
20076 }
20077
20078
20079 static PyObject *_wrap_PyScrolledWindow_base_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
20080     PyObject *resultobj;
20081     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20082     wxWindow *arg2 = (wxWindow *) 0 ;
20083     PyObject * obj0 = 0 ;
20084     PyObject * obj1 = 0 ;
20085     char *kwnames[] = {
20086         (char *) "self",(char *) "child", NULL
20087     };
20088
20089     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_AddChild",kwnames,&obj0,&obj1)) goto fail;
20090     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyScrolledWindow, SWIG_POINTER_EXCEPTION | 0);
20091     if (SWIG_arg_fail(1)) SWIG_fail;
20092     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20093     if (SWIG_arg_fail(2)) SWIG_fail;
20094     {
20095         PyThreadState* __tstate = wxPyBeginAllowThreads();
20096         (arg1)->base_AddChild(arg2);
20097
20098         wxPyEndAllowThreads(__tstate);
20099         if (PyErr_Occurred()) SWIG_fail;
20100     }
20101     Py_INCREF(Py_None); resultobj = Py_None;
20102     return resultobj;
20103     fail:
20104     return NULL;
20105 }
20106
20107
20108 static PyObject *_wrap_PyScrolledWindow_base_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
20109     PyObject *resultobj;
20110     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20111     wxWindow *arg2 = (wxWindow *) 0 ;
20112     PyObject * obj0 = 0 ;
20113     PyObject * obj1 = 0 ;
20114     char *kwnames[] = {
20115         (char *) "self",(char *) "child", NULL
20116     };
20117
20118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyScrolledWindow_base_RemoveChild",kwnames,&obj0,&obj1)) 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     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20122     if (SWIG_arg_fail(2)) SWIG_fail;
20123     {
20124         PyThreadState* __tstate = wxPyBeginAllowThreads();
20125         (arg1)->base_RemoveChild(arg2);
20126
20127         wxPyEndAllowThreads(__tstate);
20128         if (PyErr_Occurred()) SWIG_fail;
20129     }
20130     Py_INCREF(Py_None); resultobj = Py_None;
20131     return resultobj;
20132     fail:
20133     return NULL;
20134 }
20135
20136
20137 static PyObject *_wrap_PyScrolledWindow_base_ShouldInheritColours(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_ShouldInheritColours",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_ShouldInheritColours();
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_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
20166     PyObject *resultobj;
20167     wxPyScrolledWindow *arg1 = (wxPyScrolledWindow *) 0 ;
20168     wxVisualAttributes result;
20169     PyObject * obj0 = 0 ;
20170     char *kwnames[] = {
20171         (char *) "self", NULL
20172     };
20173
20174     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyScrolledWindow_base_GetDefaultAttributes",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 = (arg1)->base_GetDefaultAttributes();
20180
20181         wxPyEndAllowThreads(__tstate);
20182         if (PyErr_Occurred()) SWIG_fail;
20183     }
20184     {
20185         wxVisualAttributes * resultptr;
20186         resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
20187         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
20188     }
20189     return resultobj;
20190     fail:
20191     return NULL;
20192 }
20193
20194
20195 static PyObject * PyScrolledWindow_swigregister(PyObject *, PyObject *args) {
20196     PyObject *obj;
20197     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20198     SWIG_TypeClientData(SWIGTYPE_p_wxPyScrolledWindow, obj);
20199     Py_INCREF(obj);
20200     return Py_BuildValue((char *)"");
20201 }
20202 static int _wrap_PrintoutTitleStr_set(PyObject *) {
20203     PyErr_SetString(PyExc_TypeError,"Variable PrintoutTitleStr is read-only.");
20204     return 1;
20205 }
20206
20207
20208 static PyObject *_wrap_PrintoutTitleStr_get(void) {
20209     PyObject *pyobj;
20210
20211     {
20212 #if wxUSE_UNICODE
20213         pyobj = PyUnicode_FromWideChar((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
20214 #else
20215         pyobj = PyString_FromStringAndSize((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
20216 #endif
20217     }
20218     return pyobj;
20219 }
20220
20221
20222 static int _wrap_PreviewCanvasNameStr_set(PyObject *) {
20223     PyErr_SetString(PyExc_TypeError,"Variable PreviewCanvasNameStr is read-only.");
20224     return 1;
20225 }
20226
20227
20228 static PyObject *_wrap_PreviewCanvasNameStr_get(void) {
20229     PyObject *pyobj;
20230
20231     {
20232 #if wxUSE_UNICODE
20233         pyobj = PyUnicode_FromWideChar((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
20234 #else
20235         pyobj = PyString_FromStringAndSize((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
20236 #endif
20237     }
20238     return pyobj;
20239 }
20240
20241
20242 static PyObject *_wrap_new_PrintData__SWIG_0(PyObject *, PyObject *args) {
20243     PyObject *resultobj;
20244     wxPrintData *result;
20245
20246     if(!PyArg_ParseTuple(args,(char *)":new_PrintData")) goto fail;
20247     {
20248         PyThreadState* __tstate = wxPyBeginAllowThreads();
20249         result = (wxPrintData *)new wxPrintData();
20250
20251         wxPyEndAllowThreads(__tstate);
20252         if (PyErr_Occurred()) SWIG_fail;
20253     }
20254     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 1);
20255     return resultobj;
20256     fail:
20257     return NULL;
20258 }
20259
20260
20261 static PyObject *_wrap_new_PrintData__SWIG_1(PyObject *, PyObject *args) {
20262     PyObject *resultobj;
20263     wxPrintData *arg1 = 0 ;
20264     wxPrintData *result;
20265     PyObject * obj0 = 0 ;
20266
20267     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintData",&obj0)) goto fail;
20268     {
20269         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20270         if (SWIG_arg_fail(1)) SWIG_fail;
20271         if (arg1 == NULL) {
20272             SWIG_null_ref("wxPrintData");
20273         }
20274         if (SWIG_arg_fail(1)) SWIG_fail;
20275     }
20276     {
20277         PyThreadState* __tstate = wxPyBeginAllowThreads();
20278         result = (wxPrintData *)new wxPrintData((wxPrintData const &)*arg1);
20279
20280         wxPyEndAllowThreads(__tstate);
20281         if (PyErr_Occurred()) SWIG_fail;
20282     }
20283     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 1);
20284     return resultobj;
20285     fail:
20286     return NULL;
20287 }
20288
20289
20290 static PyObject *_wrap_new_PrintData(PyObject *self, PyObject *args) {
20291     int argc;
20292     PyObject *argv[2];
20293     int ii;
20294
20295     argc = PyObject_Length(args);
20296     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
20297         argv[ii] = PyTuple_GetItem(args,ii);
20298     }
20299     if (argc == 0) {
20300         return _wrap_new_PrintData__SWIG_0(self,args);
20301     }
20302     if (argc == 1) {
20303         int _v;
20304         {
20305             void *ptr = 0;
20306             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
20307                 _v = 0;
20308                 PyErr_Clear();
20309             } else {
20310                 _v = (ptr != 0);
20311             }
20312         }
20313         if (_v) {
20314             return _wrap_new_PrintData__SWIG_1(self,args);
20315         }
20316     }
20317
20318     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintData'");
20319     return NULL;
20320 }
20321
20322
20323 static PyObject *_wrap_delete_PrintData(PyObject *, PyObject *args, PyObject *kwargs) {
20324     PyObject *resultobj;
20325     wxPrintData *arg1 = (wxPrintData *) 0 ;
20326     PyObject * obj0 = 0 ;
20327     char *kwnames[] = {
20328         (char *) "self", NULL
20329     };
20330
20331     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PrintData",kwnames,&obj0)) goto fail;
20332     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20333     if (SWIG_arg_fail(1)) SWIG_fail;
20334     {
20335         PyThreadState* __tstate = wxPyBeginAllowThreads();
20336         delete arg1;
20337
20338         wxPyEndAllowThreads(__tstate);
20339         if (PyErr_Occurred()) SWIG_fail;
20340     }
20341     Py_INCREF(Py_None); resultobj = Py_None;
20342     return resultobj;
20343     fail:
20344     return NULL;
20345 }
20346
20347
20348 static PyObject *_wrap_PrintData_GetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
20349     PyObject *resultobj;
20350     wxPrintData *arg1 = (wxPrintData *) 0 ;
20351     int result;
20352     PyObject * obj0 = 0 ;
20353     char *kwnames[] = {
20354         (char *) "self", NULL
20355     };
20356
20357     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetNoCopies",kwnames,&obj0)) goto fail;
20358     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20359     if (SWIG_arg_fail(1)) SWIG_fail;
20360     {
20361         PyThreadState* __tstate = wxPyBeginAllowThreads();
20362         result = (int)(arg1)->GetNoCopies();
20363
20364         wxPyEndAllowThreads(__tstate);
20365         if (PyErr_Occurred()) SWIG_fail;
20366     }
20367     {
20368         resultobj = SWIG_From_int((int)(result));
20369     }
20370     return resultobj;
20371     fail:
20372     return NULL;
20373 }
20374
20375
20376 static PyObject *_wrap_PrintData_GetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
20377     PyObject *resultobj;
20378     wxPrintData *arg1 = (wxPrintData *) 0 ;
20379     bool result;
20380     PyObject * obj0 = 0 ;
20381     char *kwnames[] = {
20382         (char *) "self", NULL
20383     };
20384
20385     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetCollate",kwnames,&obj0)) goto fail;
20386     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20387     if (SWIG_arg_fail(1)) SWIG_fail;
20388     {
20389         PyThreadState* __tstate = wxPyBeginAllowThreads();
20390         result = (bool)(arg1)->GetCollate();
20391
20392         wxPyEndAllowThreads(__tstate);
20393         if (PyErr_Occurred()) SWIG_fail;
20394     }
20395     {
20396         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20397     }
20398     return resultobj;
20399     fail:
20400     return NULL;
20401 }
20402
20403
20404 static PyObject *_wrap_PrintData_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
20405     PyObject *resultobj;
20406     wxPrintData *arg1 = (wxPrintData *) 0 ;
20407     int result;
20408     PyObject * obj0 = 0 ;
20409     char *kwnames[] = {
20410         (char *) "self", NULL
20411     };
20412
20413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetOrientation",kwnames,&obj0)) goto fail;
20414     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20415     if (SWIG_arg_fail(1)) SWIG_fail;
20416     {
20417         PyThreadState* __tstate = wxPyBeginAllowThreads();
20418         result = (int)(arg1)->GetOrientation();
20419
20420         wxPyEndAllowThreads(__tstate);
20421         if (PyErr_Occurred()) SWIG_fail;
20422     }
20423     {
20424         resultobj = SWIG_From_int((int)(result));
20425     }
20426     return resultobj;
20427     fail:
20428     return NULL;
20429 }
20430
20431
20432 static PyObject *_wrap_PrintData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
20433     PyObject *resultobj;
20434     wxPrintData *arg1 = (wxPrintData *) 0 ;
20435     bool result;
20436     PyObject * obj0 = 0 ;
20437     char *kwnames[] = {
20438         (char *) "self", NULL
20439     };
20440
20441     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_Ok",kwnames,&obj0)) goto fail;
20442     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20443     if (SWIG_arg_fail(1)) SWIG_fail;
20444     {
20445         PyThreadState* __tstate = wxPyBeginAllowThreads();
20446         result = (bool)(arg1)->Ok();
20447
20448         wxPyEndAllowThreads(__tstate);
20449         if (PyErr_Occurred()) SWIG_fail;
20450     }
20451     {
20452         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20453     }
20454     return resultobj;
20455     fail:
20456     return NULL;
20457 }
20458
20459
20460 static PyObject *_wrap_PrintData_GetPrinterName(PyObject *, PyObject *args, PyObject *kwargs) {
20461     PyObject *resultobj;
20462     wxPrintData *arg1 = (wxPrintData *) 0 ;
20463     wxString *result;
20464     PyObject * obj0 = 0 ;
20465     char *kwnames[] = {
20466         (char *) "self", NULL
20467     };
20468
20469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterName",kwnames,&obj0)) goto fail;
20470     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20471     if (SWIG_arg_fail(1)) SWIG_fail;
20472     {
20473         PyThreadState* __tstate = wxPyBeginAllowThreads();
20474         {
20475             wxString const &_result_ref = (arg1)->GetPrinterName();
20476             result = (wxString *) &_result_ref;
20477         }
20478
20479         wxPyEndAllowThreads(__tstate);
20480         if (PyErr_Occurred()) SWIG_fail;
20481     }
20482     {
20483 #if wxUSE_UNICODE
20484         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20485 #else
20486         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20487 #endif
20488     }
20489     return resultobj;
20490     fail:
20491     return NULL;
20492 }
20493
20494
20495 static PyObject *_wrap_PrintData_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
20496     PyObject *resultobj;
20497     wxPrintData *arg1 = (wxPrintData *) 0 ;
20498     bool result;
20499     PyObject * obj0 = 0 ;
20500     char *kwnames[] = {
20501         (char *) "self", NULL
20502     };
20503
20504     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetColour",kwnames,&obj0)) goto fail;
20505     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20506     if (SWIG_arg_fail(1)) SWIG_fail;
20507     {
20508         PyThreadState* __tstate = wxPyBeginAllowThreads();
20509         result = (bool)(arg1)->GetColour();
20510
20511         wxPyEndAllowThreads(__tstate);
20512         if (PyErr_Occurred()) SWIG_fail;
20513     }
20514     {
20515         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20516     }
20517     return resultobj;
20518     fail:
20519     return NULL;
20520 }
20521
20522
20523 static PyObject *_wrap_PrintData_GetDuplex(PyObject *, PyObject *args, PyObject *kwargs) {
20524     PyObject *resultobj;
20525     wxPrintData *arg1 = (wxPrintData *) 0 ;
20526     wxDuplexMode result;
20527     PyObject * obj0 = 0 ;
20528     char *kwnames[] = {
20529         (char *) "self", NULL
20530     };
20531
20532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetDuplex",kwnames,&obj0)) goto fail;
20533     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20534     if (SWIG_arg_fail(1)) SWIG_fail;
20535     {
20536         PyThreadState* __tstate = wxPyBeginAllowThreads();
20537         result = (wxDuplexMode)(arg1)->GetDuplex();
20538
20539         wxPyEndAllowThreads(__tstate);
20540         if (PyErr_Occurred()) SWIG_fail;
20541     }
20542     resultobj = SWIG_From_int((result));
20543     return resultobj;
20544     fail:
20545     return NULL;
20546 }
20547
20548
20549 static PyObject *_wrap_PrintData_GetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
20550     PyObject *resultobj;
20551     wxPrintData *arg1 = (wxPrintData *) 0 ;
20552     wxPaperSize result;
20553     PyObject * obj0 = 0 ;
20554     char *kwnames[] = {
20555         (char *) "self", NULL
20556     };
20557
20558     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPaperId",kwnames,&obj0)) goto fail;
20559     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20560     if (SWIG_arg_fail(1)) SWIG_fail;
20561     {
20562         PyThreadState* __tstate = wxPyBeginAllowThreads();
20563         result = (wxPaperSize)(arg1)->GetPaperId();
20564
20565         wxPyEndAllowThreads(__tstate);
20566         if (PyErr_Occurred()) SWIG_fail;
20567     }
20568     resultobj = SWIG_From_int((result));
20569     return resultobj;
20570     fail:
20571     return NULL;
20572 }
20573
20574
20575 static PyObject *_wrap_PrintData_GetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
20576     PyObject *resultobj;
20577     wxPrintData *arg1 = (wxPrintData *) 0 ;
20578     wxSize *result;
20579     PyObject * obj0 = 0 ;
20580     char *kwnames[] = {
20581         (char *) "self", NULL
20582     };
20583
20584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPaperSize",kwnames,&obj0)) goto fail;
20585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20586     if (SWIG_arg_fail(1)) SWIG_fail;
20587     {
20588         PyThreadState* __tstate = wxPyBeginAllowThreads();
20589         {
20590             wxSize const &_result_ref = (arg1)->GetPaperSize();
20591             result = (wxSize *) &_result_ref;
20592         }
20593
20594         wxPyEndAllowThreads(__tstate);
20595         if (PyErr_Occurred()) SWIG_fail;
20596     }
20597     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20598     return resultobj;
20599     fail:
20600     return NULL;
20601 }
20602
20603
20604 static PyObject *_wrap_PrintData_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
20605     PyObject *resultobj;
20606     wxPrintData *arg1 = (wxPrintData *) 0 ;
20607     int result;
20608     PyObject * obj0 = 0 ;
20609     char *kwnames[] = {
20610         (char *) "self", NULL
20611     };
20612
20613     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetQuality",kwnames,&obj0)) goto fail;
20614     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20615     if (SWIG_arg_fail(1)) SWIG_fail;
20616     {
20617         PyThreadState* __tstate = wxPyBeginAllowThreads();
20618         result = (int)(arg1)->GetQuality();
20619
20620         wxPyEndAllowThreads(__tstate);
20621         if (PyErr_Occurred()) SWIG_fail;
20622     }
20623     {
20624         resultobj = SWIG_From_int((int)(result));
20625     }
20626     return resultobj;
20627     fail:
20628     return NULL;
20629 }
20630
20631
20632 static PyObject *_wrap_PrintData_GetBin(PyObject *, PyObject *args, PyObject *kwargs) {
20633     PyObject *resultobj;
20634     wxPrintData *arg1 = (wxPrintData *) 0 ;
20635     wxPrintBin result;
20636     PyObject * obj0 = 0 ;
20637     char *kwnames[] = {
20638         (char *) "self", NULL
20639     };
20640
20641     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetBin",kwnames,&obj0)) goto fail;
20642     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20643     if (SWIG_arg_fail(1)) SWIG_fail;
20644     {
20645         PyThreadState* __tstate = wxPyBeginAllowThreads();
20646         result = (wxPrintBin)(arg1)->GetBin();
20647
20648         wxPyEndAllowThreads(__tstate);
20649         if (PyErr_Occurred()) SWIG_fail;
20650     }
20651     resultobj = SWIG_From_int((result));
20652     return resultobj;
20653     fail:
20654     return NULL;
20655 }
20656
20657
20658 static PyObject *_wrap_PrintData_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
20659     PyObject *resultobj;
20660     wxPrintData *arg1 = (wxPrintData *) 0 ;
20661     wxPrintMode result;
20662     PyObject * obj0 = 0 ;
20663     char *kwnames[] = {
20664         (char *) "self", NULL
20665     };
20666
20667     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrintMode",kwnames,&obj0)) goto fail;
20668     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20669     if (SWIG_arg_fail(1)) SWIG_fail;
20670     {
20671         PyThreadState* __tstate = wxPyBeginAllowThreads();
20672         result = (wxPrintMode)((wxPrintData const *)arg1)->GetPrintMode();
20673
20674         wxPyEndAllowThreads(__tstate);
20675         if (PyErr_Occurred()) SWIG_fail;
20676     }
20677     resultobj = SWIG_From_int((result));
20678     return resultobj;
20679     fail:
20680     return NULL;
20681 }
20682
20683
20684 static PyObject *_wrap_PrintData_SetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
20685     PyObject *resultobj;
20686     wxPrintData *arg1 = (wxPrintData *) 0 ;
20687     int arg2 ;
20688     PyObject * obj0 = 0 ;
20689     PyObject * obj1 = 0 ;
20690     char *kwnames[] = {
20691         (char *) "self",(char *) "v", NULL
20692     };
20693
20694     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetNoCopies",kwnames,&obj0,&obj1)) goto fail;
20695     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20696     if (SWIG_arg_fail(1)) SWIG_fail;
20697     {
20698         arg2 = (int)(SWIG_As_int(obj1));
20699         if (SWIG_arg_fail(2)) SWIG_fail;
20700     }
20701     {
20702         PyThreadState* __tstate = wxPyBeginAllowThreads();
20703         (arg1)->SetNoCopies(arg2);
20704
20705         wxPyEndAllowThreads(__tstate);
20706         if (PyErr_Occurred()) SWIG_fail;
20707     }
20708     Py_INCREF(Py_None); resultobj = Py_None;
20709     return resultobj;
20710     fail:
20711     return NULL;
20712 }
20713
20714
20715 static PyObject *_wrap_PrintData_SetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
20716     PyObject *resultobj;
20717     wxPrintData *arg1 = (wxPrintData *) 0 ;
20718     bool arg2 ;
20719     PyObject * obj0 = 0 ;
20720     PyObject * obj1 = 0 ;
20721     char *kwnames[] = {
20722         (char *) "self",(char *) "flag", NULL
20723     };
20724
20725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetCollate",kwnames,&obj0,&obj1)) goto fail;
20726     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20727     if (SWIG_arg_fail(1)) SWIG_fail;
20728     {
20729         arg2 = (bool)(SWIG_As_bool(obj1));
20730         if (SWIG_arg_fail(2)) SWIG_fail;
20731     }
20732     {
20733         PyThreadState* __tstate = wxPyBeginAllowThreads();
20734         (arg1)->SetCollate(arg2);
20735
20736         wxPyEndAllowThreads(__tstate);
20737         if (PyErr_Occurred()) SWIG_fail;
20738     }
20739     Py_INCREF(Py_None); resultobj = Py_None;
20740     return resultobj;
20741     fail:
20742     return NULL;
20743 }
20744
20745
20746 static PyObject *_wrap_PrintData_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
20747     PyObject *resultobj;
20748     wxPrintData *arg1 = (wxPrintData *) 0 ;
20749     int arg2 ;
20750     PyObject * obj0 = 0 ;
20751     PyObject * obj1 = 0 ;
20752     char *kwnames[] = {
20753         (char *) "self",(char *) "orient", NULL
20754     };
20755
20756     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
20757     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20758     if (SWIG_arg_fail(1)) SWIG_fail;
20759     {
20760         arg2 = (int)(SWIG_As_int(obj1));
20761         if (SWIG_arg_fail(2)) SWIG_fail;
20762     }
20763     {
20764         PyThreadState* __tstate = wxPyBeginAllowThreads();
20765         (arg1)->SetOrientation(arg2);
20766
20767         wxPyEndAllowThreads(__tstate);
20768         if (PyErr_Occurred()) SWIG_fail;
20769     }
20770     Py_INCREF(Py_None); resultobj = Py_None;
20771     return resultobj;
20772     fail:
20773     return NULL;
20774 }
20775
20776
20777 static PyObject *_wrap_PrintData_SetPrinterName(PyObject *, PyObject *args, PyObject *kwargs) {
20778     PyObject *resultobj;
20779     wxPrintData *arg1 = (wxPrintData *) 0 ;
20780     wxString *arg2 = 0 ;
20781     bool temp2 = false ;
20782     PyObject * obj0 = 0 ;
20783     PyObject * obj1 = 0 ;
20784     char *kwnames[] = {
20785         (char *) "self",(char *) "name", NULL
20786     };
20787
20788     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterName",kwnames,&obj0,&obj1)) goto fail;
20789     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20790     if (SWIG_arg_fail(1)) SWIG_fail;
20791     {
20792         arg2 = wxString_in_helper(obj1);
20793         if (arg2 == NULL) SWIG_fail;
20794         temp2 = true;
20795     }
20796     {
20797         PyThreadState* __tstate = wxPyBeginAllowThreads();
20798         (arg1)->SetPrinterName((wxString const &)*arg2);
20799
20800         wxPyEndAllowThreads(__tstate);
20801         if (PyErr_Occurred()) SWIG_fail;
20802     }
20803     Py_INCREF(Py_None); resultobj = Py_None;
20804     {
20805         if (temp2)
20806         delete arg2;
20807     }
20808     return resultobj;
20809     fail:
20810     {
20811         if (temp2)
20812         delete arg2;
20813     }
20814     return NULL;
20815 }
20816
20817
20818 static PyObject *_wrap_PrintData_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
20819     PyObject *resultobj;
20820     wxPrintData *arg1 = (wxPrintData *) 0 ;
20821     bool arg2 ;
20822     PyObject * obj0 = 0 ;
20823     PyObject * obj1 = 0 ;
20824     char *kwnames[] = {
20825         (char *) "self",(char *) "colour", NULL
20826     };
20827
20828     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetColour",kwnames,&obj0,&obj1)) goto fail;
20829     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20830     if (SWIG_arg_fail(1)) SWIG_fail;
20831     {
20832         arg2 = (bool)(SWIG_As_bool(obj1));
20833         if (SWIG_arg_fail(2)) SWIG_fail;
20834     }
20835     {
20836         PyThreadState* __tstate = wxPyBeginAllowThreads();
20837         (arg1)->SetColour(arg2);
20838
20839         wxPyEndAllowThreads(__tstate);
20840         if (PyErr_Occurred()) SWIG_fail;
20841     }
20842     Py_INCREF(Py_None); resultobj = Py_None;
20843     return resultobj;
20844     fail:
20845     return NULL;
20846 }
20847
20848
20849 static PyObject *_wrap_PrintData_SetDuplex(PyObject *, PyObject *args, PyObject *kwargs) {
20850     PyObject *resultobj;
20851     wxPrintData *arg1 = (wxPrintData *) 0 ;
20852     wxDuplexMode arg2 ;
20853     PyObject * obj0 = 0 ;
20854     PyObject * obj1 = 0 ;
20855     char *kwnames[] = {
20856         (char *) "self",(char *) "duplex", NULL
20857     };
20858
20859     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetDuplex",kwnames,&obj0,&obj1)) goto fail;
20860     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20861     if (SWIG_arg_fail(1)) SWIG_fail;
20862     {
20863         arg2 = (wxDuplexMode)(SWIG_As_int(obj1));
20864         if (SWIG_arg_fail(2)) SWIG_fail;
20865     }
20866     {
20867         PyThreadState* __tstate = wxPyBeginAllowThreads();
20868         (arg1)->SetDuplex((wxDuplexMode )arg2);
20869
20870         wxPyEndAllowThreads(__tstate);
20871         if (PyErr_Occurred()) SWIG_fail;
20872     }
20873     Py_INCREF(Py_None); resultobj = Py_None;
20874     return resultobj;
20875     fail:
20876     return NULL;
20877 }
20878
20879
20880 static PyObject *_wrap_PrintData_SetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
20881     PyObject *resultobj;
20882     wxPrintData *arg1 = (wxPrintData *) 0 ;
20883     wxPaperSize arg2 ;
20884     PyObject * obj0 = 0 ;
20885     PyObject * obj1 = 0 ;
20886     char *kwnames[] = {
20887         (char *) "self",(char *) "sizeId", NULL
20888     };
20889
20890     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPaperId",kwnames,&obj0,&obj1)) goto fail;
20891     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20892     if (SWIG_arg_fail(1)) SWIG_fail;
20893     {
20894         arg2 = (wxPaperSize)(SWIG_As_int(obj1));
20895         if (SWIG_arg_fail(2)) SWIG_fail;
20896     }
20897     {
20898         PyThreadState* __tstate = wxPyBeginAllowThreads();
20899         (arg1)->SetPaperId((wxPaperSize )arg2);
20900
20901         wxPyEndAllowThreads(__tstate);
20902         if (PyErr_Occurred()) SWIG_fail;
20903     }
20904     Py_INCREF(Py_None); resultobj = Py_None;
20905     return resultobj;
20906     fail:
20907     return NULL;
20908 }
20909
20910
20911 static PyObject *_wrap_PrintData_SetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
20912     PyObject *resultobj;
20913     wxPrintData *arg1 = (wxPrintData *) 0 ;
20914     wxSize *arg2 = 0 ;
20915     wxSize temp2 ;
20916     PyObject * obj0 = 0 ;
20917     PyObject * obj1 = 0 ;
20918     char *kwnames[] = {
20919         (char *) "self",(char *) "sz", NULL
20920     };
20921
20922     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPaperSize",kwnames,&obj0,&obj1)) goto fail;
20923     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20924     if (SWIG_arg_fail(1)) SWIG_fail;
20925     {
20926         arg2 = &temp2;
20927         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
20928     }
20929     {
20930         PyThreadState* __tstate = wxPyBeginAllowThreads();
20931         (arg1)->SetPaperSize((wxSize const &)*arg2);
20932
20933         wxPyEndAllowThreads(__tstate);
20934         if (PyErr_Occurred()) SWIG_fail;
20935     }
20936     Py_INCREF(Py_None); resultobj = Py_None;
20937     return resultobj;
20938     fail:
20939     return NULL;
20940 }
20941
20942
20943 static PyObject *_wrap_PrintData_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
20944     PyObject *resultobj;
20945     wxPrintData *arg1 = (wxPrintData *) 0 ;
20946     int arg2 ;
20947     PyObject * obj0 = 0 ;
20948     PyObject * obj1 = 0 ;
20949     char *kwnames[] = {
20950         (char *) "self",(char *) "quality", NULL
20951     };
20952
20953     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetQuality",kwnames,&obj0,&obj1)) goto fail;
20954     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20955     if (SWIG_arg_fail(1)) SWIG_fail;
20956     {
20957         arg2 = (int)(SWIG_As_int(obj1));
20958         if (SWIG_arg_fail(2)) SWIG_fail;
20959     }
20960     {
20961         PyThreadState* __tstate = wxPyBeginAllowThreads();
20962         (arg1)->SetQuality(arg2);
20963
20964         wxPyEndAllowThreads(__tstate);
20965         if (PyErr_Occurred()) SWIG_fail;
20966     }
20967     Py_INCREF(Py_None); resultobj = Py_None;
20968     return resultobj;
20969     fail:
20970     return NULL;
20971 }
20972
20973
20974 static PyObject *_wrap_PrintData_SetBin(PyObject *, PyObject *args, PyObject *kwargs) {
20975     PyObject *resultobj;
20976     wxPrintData *arg1 = (wxPrintData *) 0 ;
20977     wxPrintBin arg2 ;
20978     PyObject * obj0 = 0 ;
20979     PyObject * obj1 = 0 ;
20980     char *kwnames[] = {
20981         (char *) "self",(char *) "bin", NULL
20982     };
20983
20984     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetBin",kwnames,&obj0,&obj1)) goto fail;
20985     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
20986     if (SWIG_arg_fail(1)) SWIG_fail;
20987     {
20988         arg2 = (wxPrintBin)(SWIG_As_int(obj1));
20989         if (SWIG_arg_fail(2)) SWIG_fail;
20990     }
20991     {
20992         PyThreadState* __tstate = wxPyBeginAllowThreads();
20993         (arg1)->SetBin((wxPrintBin )arg2);
20994
20995         wxPyEndAllowThreads(__tstate);
20996         if (PyErr_Occurred()) SWIG_fail;
20997     }
20998     Py_INCREF(Py_None); resultobj = Py_None;
20999     return resultobj;
21000     fail:
21001     return NULL;
21002 }
21003
21004
21005 static PyObject *_wrap_PrintData_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
21006     PyObject *resultobj;
21007     wxPrintData *arg1 = (wxPrintData *) 0 ;
21008     wxPrintMode arg2 ;
21009     PyObject * obj0 = 0 ;
21010     PyObject * obj1 = 0 ;
21011     char *kwnames[] = {
21012         (char *) "self",(char *) "printMode", NULL
21013     };
21014
21015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
21016     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21017     if (SWIG_arg_fail(1)) SWIG_fail;
21018     {
21019         arg2 = (wxPrintMode)(SWIG_As_int(obj1));
21020         if (SWIG_arg_fail(2)) SWIG_fail;
21021     }
21022     {
21023         PyThreadState* __tstate = wxPyBeginAllowThreads();
21024         (arg1)->SetPrintMode((wxPrintMode )arg2);
21025
21026         wxPyEndAllowThreads(__tstate);
21027         if (PyErr_Occurred()) SWIG_fail;
21028     }
21029     Py_INCREF(Py_None); resultobj = Py_None;
21030     return resultobj;
21031     fail:
21032     return NULL;
21033 }
21034
21035
21036 static PyObject *_wrap_PrintData_GetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
21037     PyObject *resultobj;
21038     wxPrintData *arg1 = (wxPrintData *) 0 ;
21039     wxString result;
21040     PyObject * obj0 = 0 ;
21041     char *kwnames[] = {
21042         (char *) "self", NULL
21043     };
21044
21045     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetFilename",kwnames,&obj0)) goto fail;
21046     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21047     if (SWIG_arg_fail(1)) SWIG_fail;
21048     {
21049         PyThreadState* __tstate = wxPyBeginAllowThreads();
21050         result = ((wxPrintData const *)arg1)->GetFilename();
21051
21052         wxPyEndAllowThreads(__tstate);
21053         if (PyErr_Occurred()) SWIG_fail;
21054     }
21055     {
21056 #if wxUSE_UNICODE
21057         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21058 #else
21059         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21060 #endif
21061     }
21062     return resultobj;
21063     fail:
21064     return NULL;
21065 }
21066
21067
21068 static PyObject *_wrap_PrintData_SetFilename(PyObject *, PyObject *args, PyObject *kwargs) {
21069     PyObject *resultobj;
21070     wxPrintData *arg1 = (wxPrintData *) 0 ;
21071     wxString *arg2 = 0 ;
21072     bool temp2 = false ;
21073     PyObject * obj0 = 0 ;
21074     PyObject * obj1 = 0 ;
21075     char *kwnames[] = {
21076         (char *) "self",(char *) "filename", NULL
21077     };
21078
21079     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetFilename",kwnames,&obj0,&obj1)) goto fail;
21080     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21081     if (SWIG_arg_fail(1)) SWIG_fail;
21082     {
21083         arg2 = wxString_in_helper(obj1);
21084         if (arg2 == NULL) SWIG_fail;
21085         temp2 = true;
21086     }
21087     {
21088         PyThreadState* __tstate = wxPyBeginAllowThreads();
21089         (arg1)->SetFilename((wxString const &)*arg2);
21090
21091         wxPyEndAllowThreads(__tstate);
21092         if (PyErr_Occurred()) SWIG_fail;
21093     }
21094     Py_INCREF(Py_None); resultobj = Py_None;
21095     {
21096         if (temp2)
21097         delete arg2;
21098     }
21099     return resultobj;
21100     fail:
21101     {
21102         if (temp2)
21103         delete arg2;
21104     }
21105     return NULL;
21106 }
21107
21108
21109 static PyObject *_wrap_PrintData_GetPrivData(PyObject *, PyObject *args, PyObject *kwargs) {
21110     PyObject *resultobj;
21111     wxPrintData *arg1 = (wxPrintData *) 0 ;
21112     PyObject *result;
21113     PyObject * obj0 = 0 ;
21114     char *kwnames[] = {
21115         (char *) "self", NULL
21116     };
21117
21118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrivData",kwnames,&obj0)) goto fail;
21119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21120     if (SWIG_arg_fail(1)) SWIG_fail;
21121     {
21122         PyThreadState* __tstate = wxPyBeginAllowThreads();
21123         result = (PyObject *)wxPrintData_GetPrivData(arg1);
21124
21125         wxPyEndAllowThreads(__tstate);
21126         if (PyErr_Occurred()) SWIG_fail;
21127     }
21128     resultobj = result;
21129     return resultobj;
21130     fail:
21131     return NULL;
21132 }
21133
21134
21135 static PyObject *_wrap_PrintData_SetPrivData(PyObject *, PyObject *args, PyObject *kwargs) {
21136     PyObject *resultobj;
21137     wxPrintData *arg1 = (wxPrintData *) 0 ;
21138     PyObject *arg2 = (PyObject *) 0 ;
21139     PyObject * obj0 = 0 ;
21140     PyObject * obj1 = 0 ;
21141     char *kwnames[] = {
21142         (char *) "self",(char *) "data", NULL
21143     };
21144
21145     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrivData",kwnames,&obj0,&obj1)) goto fail;
21146     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21147     if (SWIG_arg_fail(1)) SWIG_fail;
21148     arg2 = obj1;
21149     {
21150         PyThreadState* __tstate = wxPyBeginAllowThreads();
21151         wxPrintData_SetPrivData(arg1,arg2);
21152
21153         wxPyEndAllowThreads(__tstate);
21154         if (PyErr_Occurred()) SWIG_fail;
21155     }
21156     Py_INCREF(Py_None); resultobj = Py_None;
21157     return resultobj;
21158     fail:
21159     return NULL;
21160 }
21161
21162
21163 static PyObject *_wrap_PrintData_GetPrinterCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21164     PyObject *resultobj;
21165     wxPrintData *arg1 = (wxPrintData *) 0 ;
21166     wxString *result;
21167     PyObject * obj0 = 0 ;
21168     char *kwnames[] = {
21169         (char *) "self", NULL
21170     };
21171
21172     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterCommand",kwnames,&obj0)) goto fail;
21173     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21174     if (SWIG_arg_fail(1)) SWIG_fail;
21175     {
21176         PyThreadState* __tstate = wxPyBeginAllowThreads();
21177         {
21178             wxString const &_result_ref = (arg1)->GetPrinterCommand();
21179             result = (wxString *) &_result_ref;
21180         }
21181
21182         wxPyEndAllowThreads(__tstate);
21183         if (PyErr_Occurred()) SWIG_fail;
21184     }
21185     {
21186 #if wxUSE_UNICODE
21187         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21188 #else
21189         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21190 #endif
21191     }
21192     return resultobj;
21193     fail:
21194     return NULL;
21195 }
21196
21197
21198 static PyObject *_wrap_PrintData_GetPrinterOptions(PyObject *, PyObject *args, PyObject *kwargs) {
21199     PyObject *resultobj;
21200     wxPrintData *arg1 = (wxPrintData *) 0 ;
21201     wxString *result;
21202     PyObject * obj0 = 0 ;
21203     char *kwnames[] = {
21204         (char *) "self", NULL
21205     };
21206
21207     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterOptions",kwnames,&obj0)) goto fail;
21208     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21209     if (SWIG_arg_fail(1)) SWIG_fail;
21210     {
21211         PyThreadState* __tstate = wxPyBeginAllowThreads();
21212         {
21213             wxString const &_result_ref = (arg1)->GetPrinterOptions();
21214             result = (wxString *) &_result_ref;
21215         }
21216
21217         wxPyEndAllowThreads(__tstate);
21218         if (PyErr_Occurred()) SWIG_fail;
21219     }
21220     {
21221 #if wxUSE_UNICODE
21222         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21223 #else
21224         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21225 #endif
21226     }
21227     return resultobj;
21228     fail:
21229     return NULL;
21230 }
21231
21232
21233 static PyObject *_wrap_PrintData_GetPreviewCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21234     PyObject *resultobj;
21235     wxPrintData *arg1 = (wxPrintData *) 0 ;
21236     wxString *result;
21237     PyObject * obj0 = 0 ;
21238     char *kwnames[] = {
21239         (char *) "self", NULL
21240     };
21241
21242     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPreviewCommand",kwnames,&obj0)) goto fail;
21243     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21244     if (SWIG_arg_fail(1)) SWIG_fail;
21245     {
21246         PyThreadState* __tstate = wxPyBeginAllowThreads();
21247         {
21248             wxString const &_result_ref = (arg1)->GetPreviewCommand();
21249             result = (wxString *) &_result_ref;
21250         }
21251
21252         wxPyEndAllowThreads(__tstate);
21253         if (PyErr_Occurred()) SWIG_fail;
21254     }
21255     {
21256 #if wxUSE_UNICODE
21257         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21258 #else
21259         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21260 #endif
21261     }
21262     return resultobj;
21263     fail:
21264     return NULL;
21265 }
21266
21267
21268 static PyObject *_wrap_PrintData_GetFontMetricPath(PyObject *, PyObject *args, PyObject *kwargs) {
21269     PyObject *resultobj;
21270     wxPrintData *arg1 = (wxPrintData *) 0 ;
21271     wxString *result;
21272     PyObject * obj0 = 0 ;
21273     char *kwnames[] = {
21274         (char *) "self", NULL
21275     };
21276
21277     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetFontMetricPath",kwnames,&obj0)) goto fail;
21278     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21279     if (SWIG_arg_fail(1)) SWIG_fail;
21280     {
21281         PyThreadState* __tstate = wxPyBeginAllowThreads();
21282         {
21283             wxString const &_result_ref = (arg1)->GetFontMetricPath();
21284             result = (wxString *) &_result_ref;
21285         }
21286
21287         wxPyEndAllowThreads(__tstate);
21288         if (PyErr_Occurred()) SWIG_fail;
21289     }
21290     {
21291 #if wxUSE_UNICODE
21292         resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21293 #else
21294         resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21295 #endif
21296     }
21297     return resultobj;
21298     fail:
21299     return NULL;
21300 }
21301
21302
21303 static PyObject *_wrap_PrintData_GetPrinterScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
21304     PyObject *resultobj;
21305     wxPrintData *arg1 = (wxPrintData *) 0 ;
21306     double result;
21307     PyObject * obj0 = 0 ;
21308     char *kwnames[] = {
21309         (char *) "self", NULL
21310     };
21311
21312     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterScaleX",kwnames,&obj0)) goto fail;
21313     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21314     if (SWIG_arg_fail(1)) SWIG_fail;
21315     {
21316         PyThreadState* __tstate = wxPyBeginAllowThreads();
21317         result = (double)(arg1)->GetPrinterScaleX();
21318
21319         wxPyEndAllowThreads(__tstate);
21320         if (PyErr_Occurred()) SWIG_fail;
21321     }
21322     {
21323         resultobj = SWIG_From_double((double)(result));
21324     }
21325     return resultobj;
21326     fail:
21327     return NULL;
21328 }
21329
21330
21331 static PyObject *_wrap_PrintData_GetPrinterScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
21332     PyObject *resultobj;
21333     wxPrintData *arg1 = (wxPrintData *) 0 ;
21334     double result;
21335     PyObject * obj0 = 0 ;
21336     char *kwnames[] = {
21337         (char *) "self", NULL
21338     };
21339
21340     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterScaleY",kwnames,&obj0)) goto fail;
21341     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21342     if (SWIG_arg_fail(1)) SWIG_fail;
21343     {
21344         PyThreadState* __tstate = wxPyBeginAllowThreads();
21345         result = (double)(arg1)->GetPrinterScaleY();
21346
21347         wxPyEndAllowThreads(__tstate);
21348         if (PyErr_Occurred()) SWIG_fail;
21349     }
21350     {
21351         resultobj = SWIG_From_double((double)(result));
21352     }
21353     return resultobj;
21354     fail:
21355     return NULL;
21356 }
21357
21358
21359 static PyObject *_wrap_PrintData_GetPrinterTranslateX(PyObject *, PyObject *args, PyObject *kwargs) {
21360     PyObject *resultobj;
21361     wxPrintData *arg1 = (wxPrintData *) 0 ;
21362     long result;
21363     PyObject * obj0 = 0 ;
21364     char *kwnames[] = {
21365         (char *) "self", NULL
21366     };
21367
21368     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterTranslateX",kwnames,&obj0)) goto fail;
21369     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21370     if (SWIG_arg_fail(1)) SWIG_fail;
21371     {
21372         PyThreadState* __tstate = wxPyBeginAllowThreads();
21373         result = (long)(arg1)->GetPrinterTranslateX();
21374
21375         wxPyEndAllowThreads(__tstate);
21376         if (PyErr_Occurred()) SWIG_fail;
21377     }
21378     {
21379         resultobj = SWIG_From_long((long)(result));
21380     }
21381     return resultobj;
21382     fail:
21383     return NULL;
21384 }
21385
21386
21387 static PyObject *_wrap_PrintData_GetPrinterTranslateY(PyObject *, PyObject *args, PyObject *kwargs) {
21388     PyObject *resultobj;
21389     wxPrintData *arg1 = (wxPrintData *) 0 ;
21390     long result;
21391     PyObject * obj0 = 0 ;
21392     char *kwnames[] = {
21393         (char *) "self", NULL
21394     };
21395
21396     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintData_GetPrinterTranslateY",kwnames,&obj0)) goto fail;
21397     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21398     if (SWIG_arg_fail(1)) SWIG_fail;
21399     {
21400         PyThreadState* __tstate = wxPyBeginAllowThreads();
21401         result = (long)(arg1)->GetPrinterTranslateY();
21402
21403         wxPyEndAllowThreads(__tstate);
21404         if (PyErr_Occurred()) SWIG_fail;
21405     }
21406     {
21407         resultobj = SWIG_From_long((long)(result));
21408     }
21409     return resultobj;
21410     fail:
21411     return NULL;
21412 }
21413
21414
21415 static PyObject *_wrap_PrintData_SetPrinterCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21416     PyObject *resultobj;
21417     wxPrintData *arg1 = (wxPrintData *) 0 ;
21418     wxString *arg2 = 0 ;
21419     bool temp2 = false ;
21420     PyObject * obj0 = 0 ;
21421     PyObject * obj1 = 0 ;
21422     char *kwnames[] = {
21423         (char *) "self",(char *) "command", NULL
21424     };
21425
21426     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterCommand",kwnames,&obj0,&obj1)) goto fail;
21427     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21428     if (SWIG_arg_fail(1)) SWIG_fail;
21429     {
21430         arg2 = wxString_in_helper(obj1);
21431         if (arg2 == NULL) SWIG_fail;
21432         temp2 = true;
21433     }
21434     {
21435         PyThreadState* __tstate = wxPyBeginAllowThreads();
21436         (arg1)->SetPrinterCommand((wxString const &)*arg2);
21437
21438         wxPyEndAllowThreads(__tstate);
21439         if (PyErr_Occurred()) SWIG_fail;
21440     }
21441     Py_INCREF(Py_None); resultobj = Py_None;
21442     {
21443         if (temp2)
21444         delete arg2;
21445     }
21446     return resultobj;
21447     fail:
21448     {
21449         if (temp2)
21450         delete arg2;
21451     }
21452     return NULL;
21453 }
21454
21455
21456 static PyObject *_wrap_PrintData_SetPrinterOptions(PyObject *, PyObject *args, PyObject *kwargs) {
21457     PyObject *resultobj;
21458     wxPrintData *arg1 = (wxPrintData *) 0 ;
21459     wxString *arg2 = 0 ;
21460     bool temp2 = false ;
21461     PyObject * obj0 = 0 ;
21462     PyObject * obj1 = 0 ;
21463     char *kwnames[] = {
21464         (char *) "self",(char *) "options", NULL
21465     };
21466
21467     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterOptions",kwnames,&obj0,&obj1)) goto fail;
21468     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21469     if (SWIG_arg_fail(1)) SWIG_fail;
21470     {
21471         arg2 = wxString_in_helper(obj1);
21472         if (arg2 == NULL) SWIG_fail;
21473         temp2 = true;
21474     }
21475     {
21476         PyThreadState* __tstate = wxPyBeginAllowThreads();
21477         (arg1)->SetPrinterOptions((wxString const &)*arg2);
21478
21479         wxPyEndAllowThreads(__tstate);
21480         if (PyErr_Occurred()) SWIG_fail;
21481     }
21482     Py_INCREF(Py_None); resultobj = Py_None;
21483     {
21484         if (temp2)
21485         delete arg2;
21486     }
21487     return resultobj;
21488     fail:
21489     {
21490         if (temp2)
21491         delete arg2;
21492     }
21493     return NULL;
21494 }
21495
21496
21497 static PyObject *_wrap_PrintData_SetPreviewCommand(PyObject *, PyObject *args, PyObject *kwargs) {
21498     PyObject *resultobj;
21499     wxPrintData *arg1 = (wxPrintData *) 0 ;
21500     wxString *arg2 = 0 ;
21501     bool temp2 = false ;
21502     PyObject * obj0 = 0 ;
21503     PyObject * obj1 = 0 ;
21504     char *kwnames[] = {
21505         (char *) "self",(char *) "command", NULL
21506     };
21507
21508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPreviewCommand",kwnames,&obj0,&obj1)) goto fail;
21509     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21510     if (SWIG_arg_fail(1)) SWIG_fail;
21511     {
21512         arg2 = wxString_in_helper(obj1);
21513         if (arg2 == NULL) SWIG_fail;
21514         temp2 = true;
21515     }
21516     {
21517         PyThreadState* __tstate = wxPyBeginAllowThreads();
21518         (arg1)->SetPreviewCommand((wxString const &)*arg2);
21519
21520         wxPyEndAllowThreads(__tstate);
21521         if (PyErr_Occurred()) SWIG_fail;
21522     }
21523     Py_INCREF(Py_None); resultobj = Py_None;
21524     {
21525         if (temp2)
21526         delete arg2;
21527     }
21528     return resultobj;
21529     fail:
21530     {
21531         if (temp2)
21532         delete arg2;
21533     }
21534     return NULL;
21535 }
21536
21537
21538 static PyObject *_wrap_PrintData_SetFontMetricPath(PyObject *, PyObject *args, PyObject *kwargs) {
21539     PyObject *resultobj;
21540     wxPrintData *arg1 = (wxPrintData *) 0 ;
21541     wxString *arg2 = 0 ;
21542     bool temp2 = false ;
21543     PyObject * obj0 = 0 ;
21544     PyObject * obj1 = 0 ;
21545     char *kwnames[] = {
21546         (char *) "self",(char *) "path", NULL
21547     };
21548
21549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetFontMetricPath",kwnames,&obj0,&obj1)) goto fail;
21550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21551     if (SWIG_arg_fail(1)) SWIG_fail;
21552     {
21553         arg2 = wxString_in_helper(obj1);
21554         if (arg2 == NULL) SWIG_fail;
21555         temp2 = true;
21556     }
21557     {
21558         PyThreadState* __tstate = wxPyBeginAllowThreads();
21559         (arg1)->SetFontMetricPath((wxString const &)*arg2);
21560
21561         wxPyEndAllowThreads(__tstate);
21562         if (PyErr_Occurred()) SWIG_fail;
21563     }
21564     Py_INCREF(Py_None); resultobj = Py_None;
21565     {
21566         if (temp2)
21567         delete arg2;
21568     }
21569     return resultobj;
21570     fail:
21571     {
21572         if (temp2)
21573         delete arg2;
21574     }
21575     return NULL;
21576 }
21577
21578
21579 static PyObject *_wrap_PrintData_SetPrinterScaleX(PyObject *, PyObject *args, PyObject *kwargs) {
21580     PyObject *resultobj;
21581     wxPrintData *arg1 = (wxPrintData *) 0 ;
21582     double arg2 ;
21583     PyObject * obj0 = 0 ;
21584     PyObject * obj1 = 0 ;
21585     char *kwnames[] = {
21586         (char *) "self",(char *) "x", NULL
21587     };
21588
21589     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterScaleX",kwnames,&obj0,&obj1)) goto fail;
21590     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21591     if (SWIG_arg_fail(1)) SWIG_fail;
21592     {
21593         arg2 = (double)(SWIG_As_double(obj1));
21594         if (SWIG_arg_fail(2)) SWIG_fail;
21595     }
21596     {
21597         PyThreadState* __tstate = wxPyBeginAllowThreads();
21598         (arg1)->SetPrinterScaleX(arg2);
21599
21600         wxPyEndAllowThreads(__tstate);
21601         if (PyErr_Occurred()) SWIG_fail;
21602     }
21603     Py_INCREF(Py_None); resultobj = Py_None;
21604     return resultobj;
21605     fail:
21606     return NULL;
21607 }
21608
21609
21610 static PyObject *_wrap_PrintData_SetPrinterScaleY(PyObject *, PyObject *args, PyObject *kwargs) {
21611     PyObject *resultobj;
21612     wxPrintData *arg1 = (wxPrintData *) 0 ;
21613     double arg2 ;
21614     PyObject * obj0 = 0 ;
21615     PyObject * obj1 = 0 ;
21616     char *kwnames[] = {
21617         (char *) "self",(char *) "y", NULL
21618     };
21619
21620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterScaleY",kwnames,&obj0,&obj1)) goto fail;
21621     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21622     if (SWIG_arg_fail(1)) SWIG_fail;
21623     {
21624         arg2 = (double)(SWIG_As_double(obj1));
21625         if (SWIG_arg_fail(2)) SWIG_fail;
21626     }
21627     {
21628         PyThreadState* __tstate = wxPyBeginAllowThreads();
21629         (arg1)->SetPrinterScaleY(arg2);
21630
21631         wxPyEndAllowThreads(__tstate);
21632         if (PyErr_Occurred()) SWIG_fail;
21633     }
21634     Py_INCREF(Py_None); resultobj = Py_None;
21635     return resultobj;
21636     fail:
21637     return NULL;
21638 }
21639
21640
21641 static PyObject *_wrap_PrintData_SetPrinterScaling(PyObject *, PyObject *args, PyObject *kwargs) {
21642     PyObject *resultobj;
21643     wxPrintData *arg1 = (wxPrintData *) 0 ;
21644     double arg2 ;
21645     double arg3 ;
21646     PyObject * obj0 = 0 ;
21647     PyObject * obj1 = 0 ;
21648     PyObject * obj2 = 0 ;
21649     char *kwnames[] = {
21650         (char *) "self",(char *) "x",(char *) "y", NULL
21651     };
21652
21653     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintData_SetPrinterScaling",kwnames,&obj0,&obj1,&obj2)) goto fail;
21654     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21655     if (SWIG_arg_fail(1)) SWIG_fail;
21656     {
21657         arg2 = (double)(SWIG_As_double(obj1));
21658         if (SWIG_arg_fail(2)) SWIG_fail;
21659     }
21660     {
21661         arg3 = (double)(SWIG_As_double(obj2));
21662         if (SWIG_arg_fail(3)) SWIG_fail;
21663     }
21664     {
21665         PyThreadState* __tstate = wxPyBeginAllowThreads();
21666         (arg1)->SetPrinterScaling(arg2,arg3);
21667
21668         wxPyEndAllowThreads(__tstate);
21669         if (PyErr_Occurred()) SWIG_fail;
21670     }
21671     Py_INCREF(Py_None); resultobj = Py_None;
21672     return resultobj;
21673     fail:
21674     return NULL;
21675 }
21676
21677
21678 static PyObject *_wrap_PrintData_SetPrinterTranslateX(PyObject *, PyObject *args, PyObject *kwargs) {
21679     PyObject *resultobj;
21680     wxPrintData *arg1 = (wxPrintData *) 0 ;
21681     long arg2 ;
21682     PyObject * obj0 = 0 ;
21683     PyObject * obj1 = 0 ;
21684     char *kwnames[] = {
21685         (char *) "self",(char *) "x", NULL
21686     };
21687
21688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterTranslateX",kwnames,&obj0,&obj1)) goto fail;
21689     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21690     if (SWIG_arg_fail(1)) SWIG_fail;
21691     {
21692         arg2 = (long)(SWIG_As_long(obj1));
21693         if (SWIG_arg_fail(2)) SWIG_fail;
21694     }
21695     {
21696         PyThreadState* __tstate = wxPyBeginAllowThreads();
21697         (arg1)->SetPrinterTranslateX(arg2);
21698
21699         wxPyEndAllowThreads(__tstate);
21700         if (PyErr_Occurred()) SWIG_fail;
21701     }
21702     Py_INCREF(Py_None); resultobj = Py_None;
21703     return resultobj;
21704     fail:
21705     return NULL;
21706 }
21707
21708
21709 static PyObject *_wrap_PrintData_SetPrinterTranslateY(PyObject *, PyObject *args, PyObject *kwargs) {
21710     PyObject *resultobj;
21711     wxPrintData *arg1 = (wxPrintData *) 0 ;
21712     long arg2 ;
21713     PyObject * obj0 = 0 ;
21714     PyObject * obj1 = 0 ;
21715     char *kwnames[] = {
21716         (char *) "self",(char *) "y", NULL
21717     };
21718
21719     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetPrinterTranslateY",kwnames,&obj0,&obj1)) goto fail;
21720     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21721     if (SWIG_arg_fail(1)) SWIG_fail;
21722     {
21723         arg2 = (long)(SWIG_As_long(obj1));
21724         if (SWIG_arg_fail(2)) SWIG_fail;
21725     }
21726     {
21727         PyThreadState* __tstate = wxPyBeginAllowThreads();
21728         (arg1)->SetPrinterTranslateY(arg2);
21729
21730         wxPyEndAllowThreads(__tstate);
21731         if (PyErr_Occurred()) SWIG_fail;
21732     }
21733     Py_INCREF(Py_None); resultobj = Py_None;
21734     return resultobj;
21735     fail:
21736     return NULL;
21737 }
21738
21739
21740 static PyObject *_wrap_PrintData_SetPrinterTranslation(PyObject *, PyObject *args, PyObject *kwargs) {
21741     PyObject *resultobj;
21742     wxPrintData *arg1 = (wxPrintData *) 0 ;
21743     long arg2 ;
21744     long arg3 ;
21745     PyObject * obj0 = 0 ;
21746     PyObject * obj1 = 0 ;
21747     PyObject * obj2 = 0 ;
21748     char *kwnames[] = {
21749         (char *) "self",(char *) "x",(char *) "y", NULL
21750     };
21751
21752     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintData_SetPrinterTranslation",kwnames,&obj0,&obj1,&obj2)) goto fail;
21753     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21754     if (SWIG_arg_fail(1)) SWIG_fail;
21755     {
21756         arg2 = (long)(SWIG_As_long(obj1));
21757         if (SWIG_arg_fail(2)) SWIG_fail;
21758     }
21759     {
21760         arg3 = (long)(SWIG_As_long(obj2));
21761         if (SWIG_arg_fail(3)) SWIG_fail;
21762     }
21763     {
21764         PyThreadState* __tstate = wxPyBeginAllowThreads();
21765         (arg1)->SetPrinterTranslation(arg2,arg3);
21766
21767         wxPyEndAllowThreads(__tstate);
21768         if (PyErr_Occurred()) SWIG_fail;
21769     }
21770     Py_INCREF(Py_None); resultobj = Py_None;
21771     return resultobj;
21772     fail:
21773     return NULL;
21774 }
21775
21776
21777 static PyObject * PrintData_swigregister(PyObject *, PyObject *args) {
21778     PyObject *obj;
21779     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21780     SWIG_TypeClientData(SWIGTYPE_p_wxPrintData, obj);
21781     Py_INCREF(obj);
21782     return Py_BuildValue((char *)"");
21783 }
21784 static PyObject *_wrap_new_PageSetupDialogData__SWIG_0(PyObject *, PyObject *args) {
21785     PyObject *resultobj;
21786     wxPageSetupDialogData *result;
21787
21788     if(!PyArg_ParseTuple(args,(char *)":new_PageSetupDialogData")) goto fail;
21789     {
21790         PyThreadState* __tstate = wxPyBeginAllowThreads();
21791         result = (wxPageSetupDialogData *)new wxPageSetupDialogData();
21792
21793         wxPyEndAllowThreads(__tstate);
21794         if (PyErr_Occurred()) SWIG_fail;
21795     }
21796     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21797     return resultobj;
21798     fail:
21799     return NULL;
21800 }
21801
21802
21803 static PyObject *_wrap_new_PageSetupDialogData__SWIG_1(PyObject *, PyObject *args) {
21804     PyObject *resultobj;
21805     wxPageSetupDialogData *arg1 = 0 ;
21806     wxPageSetupDialogData *result;
21807     PyObject * obj0 = 0 ;
21808
21809     if(!PyArg_ParseTuple(args,(char *)"O:new_PageSetupDialogData",&obj0)) goto fail;
21810     {
21811         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21812         if (SWIG_arg_fail(1)) SWIG_fail;
21813         if (arg1 == NULL) {
21814             SWIG_null_ref("wxPageSetupDialogData");
21815         }
21816         if (SWIG_arg_fail(1)) SWIG_fail;
21817     }
21818     {
21819         PyThreadState* __tstate = wxPyBeginAllowThreads();
21820         result = (wxPageSetupDialogData *)new wxPageSetupDialogData((wxPageSetupDialogData const &)*arg1);
21821
21822         wxPyEndAllowThreads(__tstate);
21823         if (PyErr_Occurred()) SWIG_fail;
21824     }
21825     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21826     return resultobj;
21827     fail:
21828     return NULL;
21829 }
21830
21831
21832 static PyObject *_wrap_new_PageSetupDialogData__SWIG_2(PyObject *, PyObject *args) {
21833     PyObject *resultobj;
21834     wxPrintData *arg1 = 0 ;
21835     wxPageSetupDialogData *result;
21836     PyObject * obj0 = 0 ;
21837
21838     if(!PyArg_ParseTuple(args,(char *)"O:new_PageSetupDialogData",&obj0)) goto fail;
21839     {
21840         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
21841         if (SWIG_arg_fail(1)) SWIG_fail;
21842         if (arg1 == NULL) {
21843             SWIG_null_ref("wxPrintData");
21844         }
21845         if (SWIG_arg_fail(1)) SWIG_fail;
21846     }
21847     {
21848         PyThreadState* __tstate = wxPyBeginAllowThreads();
21849         result = (wxPageSetupDialogData *)new wxPageSetupDialogData((wxPrintData const &)*arg1);
21850
21851         wxPyEndAllowThreads(__tstate);
21852         if (PyErr_Occurred()) SWIG_fail;
21853     }
21854     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 1);
21855     return resultobj;
21856     fail:
21857     return NULL;
21858 }
21859
21860
21861 static PyObject *_wrap_new_PageSetupDialogData(PyObject *self, PyObject *args) {
21862     int argc;
21863     PyObject *argv[2];
21864     int ii;
21865
21866     argc = PyObject_Length(args);
21867     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
21868         argv[ii] = PyTuple_GetItem(args,ii);
21869     }
21870     if (argc == 0) {
21871         return _wrap_new_PageSetupDialogData__SWIG_0(self,args);
21872     }
21873     if (argc == 1) {
21874         int _v;
21875         {
21876             void *ptr = 0;
21877             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPageSetupDialogData, 0) == -1) {
21878                 _v = 0;
21879                 PyErr_Clear();
21880             } else {
21881                 _v = (ptr != 0);
21882             }
21883         }
21884         if (_v) {
21885             return _wrap_new_PageSetupDialogData__SWIG_1(self,args);
21886         }
21887     }
21888     if (argc == 1) {
21889         int _v;
21890         {
21891             void *ptr = 0;
21892             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
21893                 _v = 0;
21894                 PyErr_Clear();
21895             } else {
21896                 _v = (ptr != 0);
21897             }
21898         }
21899         if (_v) {
21900             return _wrap_new_PageSetupDialogData__SWIG_2(self,args);
21901         }
21902     }
21903
21904     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PageSetupDialogData'");
21905     return NULL;
21906 }
21907
21908
21909 static PyObject *_wrap_delete_PageSetupDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
21910     PyObject *resultobj;
21911     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
21912     PyObject * obj0 = 0 ;
21913     char *kwnames[] = {
21914         (char *) "self", NULL
21915     };
21916
21917     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PageSetupDialogData",kwnames,&obj0)) goto fail;
21918     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21919     if (SWIG_arg_fail(1)) SWIG_fail;
21920     {
21921         PyThreadState* __tstate = wxPyBeginAllowThreads();
21922         delete arg1;
21923
21924         wxPyEndAllowThreads(__tstate);
21925         if (PyErr_Occurred()) SWIG_fail;
21926     }
21927     Py_INCREF(Py_None); resultobj = Py_None;
21928     return resultobj;
21929     fail:
21930     return NULL;
21931 }
21932
21933
21934 static PyObject *_wrap_PageSetupDialogData_EnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
21935     PyObject *resultobj;
21936     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
21937     bool arg2 ;
21938     PyObject * obj0 = 0 ;
21939     PyObject * obj1 = 0 ;
21940     char *kwnames[] = {
21941         (char *) "self",(char *) "flag", NULL
21942     };
21943
21944     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableHelp",kwnames,&obj0,&obj1)) goto fail;
21945     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21946     if (SWIG_arg_fail(1)) SWIG_fail;
21947     {
21948         arg2 = (bool)(SWIG_As_bool(obj1));
21949         if (SWIG_arg_fail(2)) SWIG_fail;
21950     }
21951     {
21952         PyThreadState* __tstate = wxPyBeginAllowThreads();
21953         (arg1)->EnableHelp(arg2);
21954
21955         wxPyEndAllowThreads(__tstate);
21956         if (PyErr_Occurred()) SWIG_fail;
21957     }
21958     Py_INCREF(Py_None); resultobj = Py_None;
21959     return resultobj;
21960     fail:
21961     return NULL;
21962 }
21963
21964
21965 static PyObject *_wrap_PageSetupDialogData_EnableMargins(PyObject *, PyObject *args, PyObject *kwargs) {
21966     PyObject *resultobj;
21967     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
21968     bool arg2 ;
21969     PyObject * obj0 = 0 ;
21970     PyObject * obj1 = 0 ;
21971     char *kwnames[] = {
21972         (char *) "self",(char *) "flag", NULL
21973     };
21974
21975     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableMargins",kwnames,&obj0,&obj1)) goto fail;
21976     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
21977     if (SWIG_arg_fail(1)) SWIG_fail;
21978     {
21979         arg2 = (bool)(SWIG_As_bool(obj1));
21980         if (SWIG_arg_fail(2)) SWIG_fail;
21981     }
21982     {
21983         PyThreadState* __tstate = wxPyBeginAllowThreads();
21984         (arg1)->EnableMargins(arg2);
21985
21986         wxPyEndAllowThreads(__tstate);
21987         if (PyErr_Occurred()) SWIG_fail;
21988     }
21989     Py_INCREF(Py_None); resultobj = Py_None;
21990     return resultobj;
21991     fail:
21992     return NULL;
21993 }
21994
21995
21996 static PyObject *_wrap_PageSetupDialogData_EnableOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
21997     PyObject *resultobj;
21998     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
21999     bool arg2 ;
22000     PyObject * obj0 = 0 ;
22001     PyObject * obj1 = 0 ;
22002     char *kwnames[] = {
22003         (char *) "self",(char *) "flag", NULL
22004     };
22005
22006     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnableOrientation",kwnames,&obj0,&obj1)) goto fail;
22007     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22008     if (SWIG_arg_fail(1)) SWIG_fail;
22009     {
22010         arg2 = (bool)(SWIG_As_bool(obj1));
22011         if (SWIG_arg_fail(2)) SWIG_fail;
22012     }
22013     {
22014         PyThreadState* __tstate = wxPyBeginAllowThreads();
22015         (arg1)->EnableOrientation(arg2);
22016
22017         wxPyEndAllowThreads(__tstate);
22018         if (PyErr_Occurred()) SWIG_fail;
22019     }
22020     Py_INCREF(Py_None); resultobj = Py_None;
22021     return resultobj;
22022     fail:
22023     return NULL;
22024 }
22025
22026
22027 static PyObject *_wrap_PageSetupDialogData_EnablePaper(PyObject *, PyObject *args, PyObject *kwargs) {
22028     PyObject *resultobj;
22029     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22030     bool arg2 ;
22031     PyObject * obj0 = 0 ;
22032     PyObject * obj1 = 0 ;
22033     char *kwnames[] = {
22034         (char *) "self",(char *) "flag", NULL
22035     };
22036
22037     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnablePaper",kwnames,&obj0,&obj1)) goto fail;
22038     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22039     if (SWIG_arg_fail(1)) SWIG_fail;
22040     {
22041         arg2 = (bool)(SWIG_As_bool(obj1));
22042         if (SWIG_arg_fail(2)) SWIG_fail;
22043     }
22044     {
22045         PyThreadState* __tstate = wxPyBeginAllowThreads();
22046         (arg1)->EnablePaper(arg2);
22047
22048         wxPyEndAllowThreads(__tstate);
22049         if (PyErr_Occurred()) SWIG_fail;
22050     }
22051     Py_INCREF(Py_None); resultobj = Py_None;
22052     return resultobj;
22053     fail:
22054     return NULL;
22055 }
22056
22057
22058 static PyObject *_wrap_PageSetupDialogData_EnablePrinter(PyObject *, PyObject *args, PyObject *kwargs) {
22059     PyObject *resultobj;
22060     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22061     bool arg2 ;
22062     PyObject * obj0 = 0 ;
22063     PyObject * obj1 = 0 ;
22064     char *kwnames[] = {
22065         (char *) "self",(char *) "flag", NULL
22066     };
22067
22068     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_EnablePrinter",kwnames,&obj0,&obj1)) goto fail;
22069     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22070     if (SWIG_arg_fail(1)) SWIG_fail;
22071     {
22072         arg2 = (bool)(SWIG_As_bool(obj1));
22073         if (SWIG_arg_fail(2)) SWIG_fail;
22074     }
22075     {
22076         PyThreadState* __tstate = wxPyBeginAllowThreads();
22077         (arg1)->EnablePrinter(arg2);
22078
22079         wxPyEndAllowThreads(__tstate);
22080         if (PyErr_Occurred()) SWIG_fail;
22081     }
22082     Py_INCREF(Py_None); resultobj = Py_None;
22083     return resultobj;
22084     fail:
22085     return NULL;
22086 }
22087
22088
22089 static PyObject *_wrap_PageSetupDialogData_GetDefaultMinMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22090     PyObject *resultobj;
22091     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22092     bool result;
22093     PyObject * obj0 = 0 ;
22094     char *kwnames[] = {
22095         (char *) "self", NULL
22096     };
22097
22098     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetDefaultMinMargins",kwnames,&obj0)) goto fail;
22099     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22100     if (SWIG_arg_fail(1)) SWIG_fail;
22101     {
22102         PyThreadState* __tstate = wxPyBeginAllowThreads();
22103         result = (bool)(arg1)->GetDefaultMinMargins();
22104
22105         wxPyEndAllowThreads(__tstate);
22106         if (PyErr_Occurred()) SWIG_fail;
22107     }
22108     {
22109         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22110     }
22111     return resultobj;
22112     fail:
22113     return NULL;
22114 }
22115
22116
22117 static PyObject *_wrap_PageSetupDialogData_GetEnableMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22118     PyObject *resultobj;
22119     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22120     bool result;
22121     PyObject * obj0 = 0 ;
22122     char *kwnames[] = {
22123         (char *) "self", NULL
22124     };
22125
22126     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableMargins",kwnames,&obj0)) goto fail;
22127     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22128     if (SWIG_arg_fail(1)) SWIG_fail;
22129     {
22130         PyThreadState* __tstate = wxPyBeginAllowThreads();
22131         result = (bool)(arg1)->GetEnableMargins();
22132
22133         wxPyEndAllowThreads(__tstate);
22134         if (PyErr_Occurred()) SWIG_fail;
22135     }
22136     {
22137         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22138     }
22139     return resultobj;
22140     fail:
22141     return NULL;
22142 }
22143
22144
22145 static PyObject *_wrap_PageSetupDialogData_GetEnableOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
22146     PyObject *resultobj;
22147     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22148     bool result;
22149     PyObject * obj0 = 0 ;
22150     char *kwnames[] = {
22151         (char *) "self", NULL
22152     };
22153
22154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableOrientation",kwnames,&obj0)) goto fail;
22155     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22156     if (SWIG_arg_fail(1)) SWIG_fail;
22157     {
22158         PyThreadState* __tstate = wxPyBeginAllowThreads();
22159         result = (bool)(arg1)->GetEnableOrientation();
22160
22161         wxPyEndAllowThreads(__tstate);
22162         if (PyErr_Occurred()) SWIG_fail;
22163     }
22164     {
22165         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22166     }
22167     return resultobj;
22168     fail:
22169     return NULL;
22170 }
22171
22172
22173 static PyObject *_wrap_PageSetupDialogData_GetEnablePaper(PyObject *, PyObject *args, PyObject *kwargs) {
22174     PyObject *resultobj;
22175     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22176     bool result;
22177     PyObject * obj0 = 0 ;
22178     char *kwnames[] = {
22179         (char *) "self", NULL
22180     };
22181
22182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnablePaper",kwnames,&obj0)) goto fail;
22183     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22184     if (SWIG_arg_fail(1)) SWIG_fail;
22185     {
22186         PyThreadState* __tstate = wxPyBeginAllowThreads();
22187         result = (bool)(arg1)->GetEnablePaper();
22188
22189         wxPyEndAllowThreads(__tstate);
22190         if (PyErr_Occurred()) SWIG_fail;
22191     }
22192     {
22193         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22194     }
22195     return resultobj;
22196     fail:
22197     return NULL;
22198 }
22199
22200
22201 static PyObject *_wrap_PageSetupDialogData_GetEnablePrinter(PyObject *, PyObject *args, PyObject *kwargs) {
22202     PyObject *resultobj;
22203     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22204     bool result;
22205     PyObject * obj0 = 0 ;
22206     char *kwnames[] = {
22207         (char *) "self", NULL
22208     };
22209
22210     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnablePrinter",kwnames,&obj0)) goto fail;
22211     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22212     if (SWIG_arg_fail(1)) SWIG_fail;
22213     {
22214         PyThreadState* __tstate = wxPyBeginAllowThreads();
22215         result = (bool)(arg1)->GetEnablePrinter();
22216
22217         wxPyEndAllowThreads(__tstate);
22218         if (PyErr_Occurred()) SWIG_fail;
22219     }
22220     {
22221         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22222     }
22223     return resultobj;
22224     fail:
22225     return NULL;
22226 }
22227
22228
22229 static PyObject *_wrap_PageSetupDialogData_GetEnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
22230     PyObject *resultobj;
22231     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22232     bool result;
22233     PyObject * obj0 = 0 ;
22234     char *kwnames[] = {
22235         (char *) "self", NULL
22236     };
22237
22238     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetEnableHelp",kwnames,&obj0)) goto fail;
22239     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22240     if (SWIG_arg_fail(1)) SWIG_fail;
22241     {
22242         PyThreadState* __tstate = wxPyBeginAllowThreads();
22243         result = (bool)(arg1)->GetEnableHelp();
22244
22245         wxPyEndAllowThreads(__tstate);
22246         if (PyErr_Occurred()) SWIG_fail;
22247     }
22248     {
22249         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22250     }
22251     return resultobj;
22252     fail:
22253     return NULL;
22254 }
22255
22256
22257 static PyObject *_wrap_PageSetupDialogData_GetDefaultInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22258     PyObject *resultobj;
22259     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22260     bool result;
22261     PyObject * obj0 = 0 ;
22262     char *kwnames[] = {
22263         (char *) "self", NULL
22264     };
22265
22266     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetDefaultInfo",kwnames,&obj0)) goto fail;
22267     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22268     if (SWIG_arg_fail(1)) SWIG_fail;
22269     {
22270         PyThreadState* __tstate = wxPyBeginAllowThreads();
22271         result = (bool)(arg1)->GetDefaultInfo();
22272
22273         wxPyEndAllowThreads(__tstate);
22274         if (PyErr_Occurred()) SWIG_fail;
22275     }
22276     {
22277         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22278     }
22279     return resultobj;
22280     fail:
22281     return NULL;
22282 }
22283
22284
22285 static PyObject *_wrap_PageSetupDialogData_GetMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22286     PyObject *resultobj;
22287     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22288     wxPoint result;
22289     PyObject * obj0 = 0 ;
22290     char *kwnames[] = {
22291         (char *) "self", NULL
22292     };
22293
22294     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMarginTopLeft",kwnames,&obj0)) goto fail;
22295     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22296     if (SWIG_arg_fail(1)) SWIG_fail;
22297     {
22298         PyThreadState* __tstate = wxPyBeginAllowThreads();
22299         result = (arg1)->GetMarginTopLeft();
22300
22301         wxPyEndAllowThreads(__tstate);
22302         if (PyErr_Occurred()) SWIG_fail;
22303     }
22304     {
22305         wxPoint * resultptr;
22306         resultptr = new wxPoint((wxPoint &)(result));
22307         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22308     }
22309     return resultobj;
22310     fail:
22311     return NULL;
22312 }
22313
22314
22315 static PyObject *_wrap_PageSetupDialogData_GetMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22316     PyObject *resultobj;
22317     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22318     wxPoint result;
22319     PyObject * obj0 = 0 ;
22320     char *kwnames[] = {
22321         (char *) "self", NULL
22322     };
22323
22324     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMarginBottomRight",kwnames,&obj0)) goto fail;
22325     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22326     if (SWIG_arg_fail(1)) SWIG_fail;
22327     {
22328         PyThreadState* __tstate = wxPyBeginAllowThreads();
22329         result = (arg1)->GetMarginBottomRight();
22330
22331         wxPyEndAllowThreads(__tstate);
22332         if (PyErr_Occurred()) SWIG_fail;
22333     }
22334     {
22335         wxPoint * resultptr;
22336         resultptr = new wxPoint((wxPoint &)(result));
22337         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22338     }
22339     return resultobj;
22340     fail:
22341     return NULL;
22342 }
22343
22344
22345 static PyObject *_wrap_PageSetupDialogData_GetMinMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22346     PyObject *resultobj;
22347     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22348     wxPoint result;
22349     PyObject * obj0 = 0 ;
22350     char *kwnames[] = {
22351         (char *) "self", NULL
22352     };
22353
22354     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMinMarginTopLeft",kwnames,&obj0)) goto fail;
22355     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22356     if (SWIG_arg_fail(1)) SWIG_fail;
22357     {
22358         PyThreadState* __tstate = wxPyBeginAllowThreads();
22359         result = (arg1)->GetMinMarginTopLeft();
22360
22361         wxPyEndAllowThreads(__tstate);
22362         if (PyErr_Occurred()) SWIG_fail;
22363     }
22364     {
22365         wxPoint * resultptr;
22366         resultptr = new wxPoint((wxPoint &)(result));
22367         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22368     }
22369     return resultobj;
22370     fail:
22371     return NULL;
22372 }
22373
22374
22375 static PyObject *_wrap_PageSetupDialogData_GetMinMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22376     PyObject *resultobj;
22377     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22378     wxPoint result;
22379     PyObject * obj0 = 0 ;
22380     char *kwnames[] = {
22381         (char *) "self", NULL
22382     };
22383
22384     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetMinMarginBottomRight",kwnames,&obj0)) goto fail;
22385     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22386     if (SWIG_arg_fail(1)) SWIG_fail;
22387     {
22388         PyThreadState* __tstate = wxPyBeginAllowThreads();
22389         result = (arg1)->GetMinMarginBottomRight();
22390
22391         wxPyEndAllowThreads(__tstate);
22392         if (PyErr_Occurred()) SWIG_fail;
22393     }
22394     {
22395         wxPoint * resultptr;
22396         resultptr = new wxPoint((wxPoint &)(result));
22397         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
22398     }
22399     return resultobj;
22400     fail:
22401     return NULL;
22402 }
22403
22404
22405 static PyObject *_wrap_PageSetupDialogData_GetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
22406     PyObject *resultobj;
22407     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22408     wxPaperSize result;
22409     PyObject * obj0 = 0 ;
22410     char *kwnames[] = {
22411         (char *) "self", NULL
22412     };
22413
22414     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPaperId",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 = (wxPaperSize)(arg1)->GetPaperId();
22420
22421         wxPyEndAllowThreads(__tstate);
22422         if (PyErr_Occurred()) SWIG_fail;
22423     }
22424     resultobj = SWIG_From_int((result));
22425     return resultobj;
22426     fail:
22427     return NULL;
22428 }
22429
22430
22431 static PyObject *_wrap_PageSetupDialogData_GetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22432     PyObject *resultobj;
22433     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22434     wxSize result;
22435     PyObject * obj0 = 0 ;
22436     char *kwnames[] = {
22437         (char *) "self", NULL
22438     };
22439
22440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPaperSize",kwnames,&obj0)) goto fail;
22441     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22442     if (SWIG_arg_fail(1)) SWIG_fail;
22443     {
22444         PyThreadState* __tstate = wxPyBeginAllowThreads();
22445         result = (arg1)->GetPaperSize();
22446
22447         wxPyEndAllowThreads(__tstate);
22448         if (PyErr_Occurred()) SWIG_fail;
22449     }
22450     {
22451         wxSize * resultptr;
22452         resultptr = new wxSize((wxSize &)(result));
22453         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
22454     }
22455     return resultobj;
22456     fail:
22457     return NULL;
22458 }
22459
22460
22461 static PyObject *_wrap_PageSetupDialogData_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
22462     PyObject *resultobj;
22463     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22464     wxPrintData *result;
22465     PyObject * obj0 = 0 ;
22466     char *kwnames[] = {
22467         (char *) "self", NULL
22468     };
22469
22470     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_GetPrintData",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         {
22476             wxPrintData &_result_ref = (arg1)->GetPrintData();
22477             result = (wxPrintData *) &_result_ref;
22478         }
22479
22480         wxPyEndAllowThreads(__tstate);
22481         if (PyErr_Occurred()) SWIG_fail;
22482     }
22483     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
22484     return resultobj;
22485     fail:
22486     return NULL;
22487 }
22488
22489
22490 static PyObject *_wrap_PageSetupDialogData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
22491     PyObject *resultobj;
22492     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22493     bool result;
22494     PyObject * obj0 = 0 ;
22495     char *kwnames[] = {
22496         (char *) "self", NULL
22497     };
22498
22499     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_Ok",kwnames,&obj0)) goto fail;
22500     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22501     if (SWIG_arg_fail(1)) SWIG_fail;
22502     {
22503         PyThreadState* __tstate = wxPyBeginAllowThreads();
22504         result = (bool)(arg1)->Ok();
22505
22506         wxPyEndAllowThreads(__tstate);
22507         if (PyErr_Occurred()) SWIG_fail;
22508     }
22509     {
22510         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22511     }
22512     return resultobj;
22513     fail:
22514     return NULL;
22515 }
22516
22517
22518 static PyObject *_wrap_PageSetupDialogData_SetDefaultInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22519     PyObject *resultobj;
22520     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22521     bool arg2 ;
22522     PyObject * obj0 = 0 ;
22523     PyObject * obj1 = 0 ;
22524     char *kwnames[] = {
22525         (char *) "self",(char *) "flag", NULL
22526     };
22527
22528     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetDefaultInfo",kwnames,&obj0,&obj1)) goto fail;
22529     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22530     if (SWIG_arg_fail(1)) SWIG_fail;
22531     {
22532         arg2 = (bool)(SWIG_As_bool(obj1));
22533         if (SWIG_arg_fail(2)) SWIG_fail;
22534     }
22535     {
22536         PyThreadState* __tstate = wxPyBeginAllowThreads();
22537         (arg1)->SetDefaultInfo(arg2);
22538
22539         wxPyEndAllowThreads(__tstate);
22540         if (PyErr_Occurred()) SWIG_fail;
22541     }
22542     Py_INCREF(Py_None); resultobj = Py_None;
22543     return resultobj;
22544     fail:
22545     return NULL;
22546 }
22547
22548
22549 static PyObject *_wrap_PageSetupDialogData_SetDefaultMinMargins(PyObject *, PyObject *args, PyObject *kwargs) {
22550     PyObject *resultobj;
22551     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22552     bool arg2 ;
22553     PyObject * obj0 = 0 ;
22554     PyObject * obj1 = 0 ;
22555     char *kwnames[] = {
22556         (char *) "self",(char *) "flag", NULL
22557     };
22558
22559     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetDefaultMinMargins",kwnames,&obj0,&obj1)) goto fail;
22560     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22561     if (SWIG_arg_fail(1)) SWIG_fail;
22562     {
22563         arg2 = (bool)(SWIG_As_bool(obj1));
22564         if (SWIG_arg_fail(2)) SWIG_fail;
22565     }
22566     {
22567         PyThreadState* __tstate = wxPyBeginAllowThreads();
22568         (arg1)->SetDefaultMinMargins(arg2);
22569
22570         wxPyEndAllowThreads(__tstate);
22571         if (PyErr_Occurred()) SWIG_fail;
22572     }
22573     Py_INCREF(Py_None); resultobj = Py_None;
22574     return resultobj;
22575     fail:
22576     return NULL;
22577 }
22578
22579
22580 static PyObject *_wrap_PageSetupDialogData_SetMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22581     PyObject *resultobj;
22582     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22583     wxPoint *arg2 = 0 ;
22584     wxPoint temp2 ;
22585     PyObject * obj0 = 0 ;
22586     PyObject * obj1 = 0 ;
22587     char *kwnames[] = {
22588         (char *) "self",(char *) "pt", NULL
22589     };
22590
22591     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMarginTopLeft",kwnames,&obj0,&obj1)) goto fail;
22592     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22593     if (SWIG_arg_fail(1)) SWIG_fail;
22594     {
22595         arg2 = &temp2;
22596         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22597     }
22598     {
22599         PyThreadState* __tstate = wxPyBeginAllowThreads();
22600         (arg1)->SetMarginTopLeft((wxPoint const &)*arg2);
22601
22602         wxPyEndAllowThreads(__tstate);
22603         if (PyErr_Occurred()) SWIG_fail;
22604     }
22605     Py_INCREF(Py_None); resultobj = Py_None;
22606     return resultobj;
22607     fail:
22608     return NULL;
22609 }
22610
22611
22612 static PyObject *_wrap_PageSetupDialogData_SetMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22613     PyObject *resultobj;
22614     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22615     wxPoint *arg2 = 0 ;
22616     wxPoint temp2 ;
22617     PyObject * obj0 = 0 ;
22618     PyObject * obj1 = 0 ;
22619     char *kwnames[] = {
22620         (char *) "self",(char *) "pt", NULL
22621     };
22622
22623     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMarginBottomRight",kwnames,&obj0,&obj1)) goto fail;
22624     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22625     if (SWIG_arg_fail(1)) SWIG_fail;
22626     {
22627         arg2 = &temp2;
22628         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22629     }
22630     {
22631         PyThreadState* __tstate = wxPyBeginAllowThreads();
22632         (arg1)->SetMarginBottomRight((wxPoint const &)*arg2);
22633
22634         wxPyEndAllowThreads(__tstate);
22635         if (PyErr_Occurred()) SWIG_fail;
22636     }
22637     Py_INCREF(Py_None); resultobj = Py_None;
22638     return resultobj;
22639     fail:
22640     return NULL;
22641 }
22642
22643
22644 static PyObject *_wrap_PageSetupDialogData_SetMinMarginTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
22645     PyObject *resultobj;
22646     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22647     wxPoint *arg2 = 0 ;
22648     wxPoint temp2 ;
22649     PyObject * obj0 = 0 ;
22650     PyObject * obj1 = 0 ;
22651     char *kwnames[] = {
22652         (char *) "self",(char *) "pt", NULL
22653     };
22654
22655     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMinMarginTopLeft",kwnames,&obj0,&obj1)) goto fail;
22656     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22657     if (SWIG_arg_fail(1)) SWIG_fail;
22658     {
22659         arg2 = &temp2;
22660         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22661     }
22662     {
22663         PyThreadState* __tstate = wxPyBeginAllowThreads();
22664         (arg1)->SetMinMarginTopLeft((wxPoint const &)*arg2);
22665
22666         wxPyEndAllowThreads(__tstate);
22667         if (PyErr_Occurred()) SWIG_fail;
22668     }
22669     Py_INCREF(Py_None); resultobj = Py_None;
22670     return resultobj;
22671     fail:
22672     return NULL;
22673 }
22674
22675
22676 static PyObject *_wrap_PageSetupDialogData_SetMinMarginBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
22677     PyObject *resultobj;
22678     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22679     wxPoint *arg2 = 0 ;
22680     wxPoint temp2 ;
22681     PyObject * obj0 = 0 ;
22682     PyObject * obj1 = 0 ;
22683     char *kwnames[] = {
22684         (char *) "self",(char *) "pt", NULL
22685     };
22686
22687     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetMinMarginBottomRight",kwnames,&obj0,&obj1)) goto fail;
22688     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22689     if (SWIG_arg_fail(1)) SWIG_fail;
22690     {
22691         arg2 = &temp2;
22692         if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22693     }
22694     {
22695         PyThreadState* __tstate = wxPyBeginAllowThreads();
22696         (arg1)->SetMinMarginBottomRight((wxPoint const &)*arg2);
22697
22698         wxPyEndAllowThreads(__tstate);
22699         if (PyErr_Occurred()) SWIG_fail;
22700     }
22701     Py_INCREF(Py_None); resultobj = Py_None;
22702     return resultobj;
22703     fail:
22704     return NULL;
22705 }
22706
22707
22708 static PyObject *_wrap_PageSetupDialogData_SetPaperId(PyObject *, PyObject *args, PyObject *kwargs) {
22709     PyObject *resultobj;
22710     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22711     wxPaperSize arg2 ;
22712     PyObject * obj0 = 0 ;
22713     PyObject * obj1 = 0 ;
22714     char *kwnames[] = {
22715         (char *) "self",(char *) "id", NULL
22716     };
22717
22718     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPaperId",kwnames,&obj0,&obj1)) goto fail;
22719     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22720     if (SWIG_arg_fail(1)) SWIG_fail;
22721     {
22722         arg2 = (wxPaperSize)(SWIG_As_int(obj1));
22723         if (SWIG_arg_fail(2)) SWIG_fail;
22724     }
22725     {
22726         PyThreadState* __tstate = wxPyBeginAllowThreads();
22727         (arg1)->SetPaperId((wxPaperSize )arg2);
22728
22729         wxPyEndAllowThreads(__tstate);
22730         if (PyErr_Occurred()) SWIG_fail;
22731     }
22732     Py_INCREF(Py_None); resultobj = Py_None;
22733     return resultobj;
22734     fail:
22735     return NULL;
22736 }
22737
22738
22739 static PyObject *_wrap_PageSetupDialogData_SetPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22740     PyObject *resultobj;
22741     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22742     wxSize *arg2 = 0 ;
22743     wxSize temp2 ;
22744     PyObject * obj0 = 0 ;
22745     PyObject * obj1 = 0 ;
22746     char *kwnames[] = {
22747         (char *) "self",(char *) "size", NULL
22748     };
22749
22750     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPaperSize",kwnames,&obj0,&obj1)) goto fail;
22751     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22752     if (SWIG_arg_fail(1)) SWIG_fail;
22753     {
22754         arg2 = &temp2;
22755         if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
22756     }
22757     {
22758         PyThreadState* __tstate = wxPyBeginAllowThreads();
22759         (arg1)->SetPaperSize((wxSize const &)*arg2);
22760
22761         wxPyEndAllowThreads(__tstate);
22762         if (PyErr_Occurred()) SWIG_fail;
22763     }
22764     Py_INCREF(Py_None); resultobj = Py_None;
22765     return resultobj;
22766     fail:
22767     return NULL;
22768 }
22769
22770
22771 static PyObject *_wrap_PageSetupDialogData_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
22772     PyObject *resultobj;
22773     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22774     wxPrintData *arg2 = 0 ;
22775     PyObject * obj0 = 0 ;
22776     PyObject * obj1 = 0 ;
22777     char *kwnames[] = {
22778         (char *) "self",(char *) "printData", NULL
22779     };
22780
22781     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PageSetupDialogData_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
22782     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22783     if (SWIG_arg_fail(1)) SWIG_fail;
22784     {
22785         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
22786         if (SWIG_arg_fail(2)) SWIG_fail;
22787         if (arg2 == NULL) {
22788             SWIG_null_ref("wxPrintData");
22789         }
22790         if (SWIG_arg_fail(2)) SWIG_fail;
22791     }
22792     {
22793         PyThreadState* __tstate = wxPyBeginAllowThreads();
22794         (arg1)->SetPrintData((wxPrintData const &)*arg2);
22795
22796         wxPyEndAllowThreads(__tstate);
22797         if (PyErr_Occurred()) SWIG_fail;
22798     }
22799     Py_INCREF(Py_None); resultobj = Py_None;
22800     return resultobj;
22801     fail:
22802     return NULL;
22803 }
22804
22805
22806 static PyObject *_wrap_PageSetupDialogData_CalculateIdFromPaperSize(PyObject *, PyObject *args, PyObject *kwargs) {
22807     PyObject *resultobj;
22808     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22809     PyObject * obj0 = 0 ;
22810     char *kwnames[] = {
22811         (char *) "self", NULL
22812     };
22813
22814     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_CalculateIdFromPaperSize",kwnames,&obj0)) goto fail;
22815     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22816     if (SWIG_arg_fail(1)) SWIG_fail;
22817     {
22818         PyThreadState* __tstate = wxPyBeginAllowThreads();
22819         (arg1)->CalculateIdFromPaperSize();
22820
22821         wxPyEndAllowThreads(__tstate);
22822         if (PyErr_Occurred()) SWIG_fail;
22823     }
22824     Py_INCREF(Py_None); resultobj = Py_None;
22825     return resultobj;
22826     fail:
22827     return NULL;
22828 }
22829
22830
22831 static PyObject *_wrap_PageSetupDialogData_CalculatePaperSizeFromId(PyObject *, PyObject *args, PyObject *kwargs) {
22832     PyObject *resultobj;
22833     wxPageSetupDialogData *arg1 = (wxPageSetupDialogData *) 0 ;
22834     PyObject * obj0 = 0 ;
22835     char *kwnames[] = {
22836         (char *) "self", NULL
22837     };
22838
22839     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialogData_CalculatePaperSizeFromId",kwnames,&obj0)) goto fail;
22840     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22841     if (SWIG_arg_fail(1)) SWIG_fail;
22842     {
22843         PyThreadState* __tstate = wxPyBeginAllowThreads();
22844         (arg1)->CalculatePaperSizeFromId();
22845
22846         wxPyEndAllowThreads(__tstate);
22847         if (PyErr_Occurred()) SWIG_fail;
22848     }
22849     Py_INCREF(Py_None); resultobj = Py_None;
22850     return resultobj;
22851     fail:
22852     return NULL;
22853 }
22854
22855
22856 static PyObject * PageSetupDialogData_swigregister(PyObject *, PyObject *args) {
22857     PyObject *obj;
22858     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22859     SWIG_TypeClientData(SWIGTYPE_p_wxPageSetupDialogData, obj);
22860     Py_INCREF(obj);
22861     return Py_BuildValue((char *)"");
22862 }
22863 static PyObject *_wrap_new_PageSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
22864     PyObject *resultobj;
22865     wxWindow *arg1 = (wxWindow *) 0 ;
22866     wxPageSetupDialogData *arg2 = (wxPageSetupDialogData *) NULL ;
22867     wxPageSetupDialog *result;
22868     PyObject * obj0 = 0 ;
22869     PyObject * obj1 = 0 ;
22870     char *kwnames[] = {
22871         (char *) "parent",(char *) "data", NULL
22872     };
22873
22874     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PageSetupDialog",kwnames,&obj0,&obj1)) goto fail;
22875     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22876     if (SWIG_arg_fail(1)) SWIG_fail;
22877     if (obj1) {
22878         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPageSetupDialogData, SWIG_POINTER_EXCEPTION | 0);
22879         if (SWIG_arg_fail(2)) SWIG_fail;
22880     }
22881     {
22882         if (!wxPyCheckForApp()) SWIG_fail;
22883         PyThreadState* __tstate = wxPyBeginAllowThreads();
22884         result = (wxPageSetupDialog *)new wxPageSetupDialog(arg1,arg2);
22885
22886         wxPyEndAllowThreads(__tstate);
22887         if (PyErr_Occurred()) SWIG_fail;
22888     }
22889     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialog, 1);
22890     return resultobj;
22891     fail:
22892     return NULL;
22893 }
22894
22895
22896 static PyObject *_wrap_PageSetupDialog_GetPageSetupData(PyObject *, PyObject *args, PyObject *kwargs) {
22897     PyObject *resultobj;
22898     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
22899     wxPageSetupDialogData *result;
22900     PyObject * obj0 = 0 ;
22901     char *kwnames[] = {
22902         (char *) "self", NULL
22903     };
22904
22905     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_GetPageSetupData",kwnames,&obj0)) goto fail;
22906     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
22907     if (SWIG_arg_fail(1)) SWIG_fail;
22908     {
22909         PyThreadState* __tstate = wxPyBeginAllowThreads();
22910         {
22911             wxPageSetupDialogData &_result_ref = (arg1)->GetPageSetupData();
22912             result = (wxPageSetupDialogData *) &_result_ref;
22913         }
22914
22915         wxPyEndAllowThreads(__tstate);
22916         if (PyErr_Occurred()) SWIG_fail;
22917     }
22918     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 0);
22919     return resultobj;
22920     fail:
22921     return NULL;
22922 }
22923
22924
22925 static PyObject *_wrap_PageSetupDialog_GetPageSetupDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
22926     PyObject *resultobj;
22927     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
22928     wxPageSetupDialogData *result;
22929     PyObject * obj0 = 0 ;
22930     char *kwnames[] = {
22931         (char *) "self", NULL
22932     };
22933
22934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_GetPageSetupDialogData",kwnames,&obj0)) goto fail;
22935     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
22936     if (SWIG_arg_fail(1)) SWIG_fail;
22937     {
22938         PyThreadState* __tstate = wxPyBeginAllowThreads();
22939         {
22940             wxPageSetupDialogData &_result_ref = (arg1)->GetPageSetupDialogData();
22941             result = (wxPageSetupDialogData *) &_result_ref;
22942         }
22943
22944         wxPyEndAllowThreads(__tstate);
22945         if (PyErr_Occurred()) SWIG_fail;
22946     }
22947     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPageSetupDialogData, 0);
22948     return resultobj;
22949     fail:
22950     return NULL;
22951 }
22952
22953
22954 static PyObject *_wrap_PageSetupDialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
22955     PyObject *resultobj;
22956     wxPageSetupDialog *arg1 = (wxPageSetupDialog *) 0 ;
22957     int result;
22958     PyObject * obj0 = 0 ;
22959     char *kwnames[] = {
22960         (char *) "self", NULL
22961     };
22962
22963     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PageSetupDialog_ShowModal",kwnames,&obj0)) goto fail;
22964     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPageSetupDialog, SWIG_POINTER_EXCEPTION | 0);
22965     if (SWIG_arg_fail(1)) SWIG_fail;
22966     {
22967         PyThreadState* __tstate = wxPyBeginAllowThreads();
22968         result = (int)(arg1)->ShowModal();
22969
22970         wxPyEndAllowThreads(__tstate);
22971         if (PyErr_Occurred()) SWIG_fail;
22972     }
22973     {
22974         resultobj = SWIG_From_int((int)(result));
22975     }
22976     return resultobj;
22977     fail:
22978     return NULL;
22979 }
22980
22981
22982 static PyObject * PageSetupDialog_swigregister(PyObject *, PyObject *args) {
22983     PyObject *obj;
22984     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22985     SWIG_TypeClientData(SWIGTYPE_p_wxPageSetupDialog, obj);
22986     Py_INCREF(obj);
22987     return Py_BuildValue((char *)"");
22988 }
22989 static PyObject *_wrap_new_PrintDialogData__SWIG_0(PyObject *, PyObject *args) {
22990     PyObject *resultobj;
22991     wxPrintDialogData *result;
22992
22993     if(!PyArg_ParseTuple(args,(char *)":new_PrintDialogData")) goto fail;
22994     {
22995         PyThreadState* __tstate = wxPyBeginAllowThreads();
22996         result = (wxPrintDialogData *)new wxPrintDialogData();
22997
22998         wxPyEndAllowThreads(__tstate);
22999         if (PyErr_Occurred()) SWIG_fail;
23000     }
23001     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23002     return resultobj;
23003     fail:
23004     return NULL;
23005 }
23006
23007
23008 static PyObject *_wrap_new_PrintDialogData__SWIG_1(PyObject *, PyObject *args) {
23009     PyObject *resultobj;
23010     wxPrintData *arg1 = 0 ;
23011     wxPrintDialogData *result;
23012     PyObject * obj0 = 0 ;
23013
23014     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintDialogData",&obj0)) goto fail;
23015     {
23016         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
23017         if (SWIG_arg_fail(1)) SWIG_fail;
23018         if (arg1 == NULL) {
23019             SWIG_null_ref("wxPrintData");
23020         }
23021         if (SWIG_arg_fail(1)) SWIG_fail;
23022     }
23023     {
23024         PyThreadState* __tstate = wxPyBeginAllowThreads();
23025         result = (wxPrintDialogData *)new wxPrintDialogData((wxPrintData const &)*arg1);
23026
23027         wxPyEndAllowThreads(__tstate);
23028         if (PyErr_Occurred()) SWIG_fail;
23029     }
23030     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23031     return resultobj;
23032     fail:
23033     return NULL;
23034 }
23035
23036
23037 static PyObject *_wrap_new_PrintDialogData__SWIG_2(PyObject *, PyObject *args) {
23038     PyObject *resultobj;
23039     wxPrintDialogData *arg1 = 0 ;
23040     wxPrintDialogData *result;
23041     PyObject * obj0 = 0 ;
23042
23043     if(!PyArg_ParseTuple(args,(char *)"O:new_PrintDialogData",&obj0)) goto fail;
23044     {
23045         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23046         if (SWIG_arg_fail(1)) SWIG_fail;
23047         if (arg1 == NULL) {
23048             SWIG_null_ref("wxPrintDialogData");
23049         }
23050         if (SWIG_arg_fail(1)) SWIG_fail;
23051     }
23052     {
23053         PyThreadState* __tstate = wxPyBeginAllowThreads();
23054         result = (wxPrintDialogData *)new wxPrintDialogData((wxPrintDialogData const &)*arg1);
23055
23056         wxPyEndAllowThreads(__tstate);
23057         if (PyErr_Occurred()) SWIG_fail;
23058     }
23059     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 1);
23060     return resultobj;
23061     fail:
23062     return NULL;
23063 }
23064
23065
23066 static PyObject *_wrap_new_PrintDialogData(PyObject *self, PyObject *args) {
23067     int argc;
23068     PyObject *argv[2];
23069     int ii;
23070
23071     argc = PyObject_Length(args);
23072     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
23073         argv[ii] = PyTuple_GetItem(args,ii);
23074     }
23075     if (argc == 0) {
23076         return _wrap_new_PrintDialogData__SWIG_0(self,args);
23077     }
23078     if (argc == 1) {
23079         int _v;
23080         {
23081             void *ptr = 0;
23082             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
23083                 _v = 0;
23084                 PyErr_Clear();
23085             } else {
23086                 _v = (ptr != 0);
23087             }
23088         }
23089         if (_v) {
23090             return _wrap_new_PrintDialogData__SWIG_1(self,args);
23091         }
23092     }
23093     if (argc == 1) {
23094         int _v;
23095         {
23096             void *ptr = 0;
23097             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
23098                 _v = 0;
23099                 PyErr_Clear();
23100             } else {
23101                 _v = (ptr != 0);
23102             }
23103         }
23104         if (_v) {
23105             return _wrap_new_PrintDialogData__SWIG_2(self,args);
23106         }
23107     }
23108
23109     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintDialogData'");
23110     return NULL;
23111 }
23112
23113
23114 static PyObject *_wrap_delete_PrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
23115     PyObject *resultobj;
23116     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23117     PyObject * obj0 = 0 ;
23118     char *kwnames[] = {
23119         (char *) "self", NULL
23120     };
23121
23122     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PrintDialogData",kwnames,&obj0)) goto fail;
23123     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23124     if (SWIG_arg_fail(1)) SWIG_fail;
23125     {
23126         PyThreadState* __tstate = wxPyBeginAllowThreads();
23127         delete arg1;
23128
23129         wxPyEndAllowThreads(__tstate);
23130         if (PyErr_Occurred()) SWIG_fail;
23131     }
23132     Py_INCREF(Py_None); resultobj = Py_None;
23133     return resultobj;
23134     fail:
23135     return NULL;
23136 }
23137
23138
23139 static PyObject *_wrap_PrintDialogData_GetFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
23140     PyObject *resultobj;
23141     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23142     int result;
23143     PyObject * obj0 = 0 ;
23144     char *kwnames[] = {
23145         (char *) "self", NULL
23146     };
23147
23148     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetFromPage",kwnames,&obj0)) goto fail;
23149     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23150     if (SWIG_arg_fail(1)) SWIG_fail;
23151     {
23152         PyThreadState* __tstate = wxPyBeginAllowThreads();
23153         result = (int)((wxPrintDialogData const *)arg1)->GetFromPage();
23154
23155         wxPyEndAllowThreads(__tstate);
23156         if (PyErr_Occurred()) SWIG_fail;
23157     }
23158     {
23159         resultobj = SWIG_From_int((int)(result));
23160     }
23161     return resultobj;
23162     fail:
23163     return NULL;
23164 }
23165
23166
23167 static PyObject *_wrap_PrintDialogData_GetToPage(PyObject *, PyObject *args, PyObject *kwargs) {
23168     PyObject *resultobj;
23169     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23170     int result;
23171     PyObject * obj0 = 0 ;
23172     char *kwnames[] = {
23173         (char *) "self", NULL
23174     };
23175
23176     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetToPage",kwnames,&obj0)) goto fail;
23177     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23178     if (SWIG_arg_fail(1)) SWIG_fail;
23179     {
23180         PyThreadState* __tstate = wxPyBeginAllowThreads();
23181         result = (int)((wxPrintDialogData const *)arg1)->GetToPage();
23182
23183         wxPyEndAllowThreads(__tstate);
23184         if (PyErr_Occurred()) SWIG_fail;
23185     }
23186     {
23187         resultobj = SWIG_From_int((int)(result));
23188     }
23189     return resultobj;
23190     fail:
23191     return NULL;
23192 }
23193
23194
23195 static PyObject *_wrap_PrintDialogData_GetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
23196     PyObject *resultobj;
23197     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23198     int result;
23199     PyObject * obj0 = 0 ;
23200     char *kwnames[] = {
23201         (char *) "self", NULL
23202     };
23203
23204     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetMinPage",kwnames,&obj0)) goto fail;
23205     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23206     if (SWIG_arg_fail(1)) SWIG_fail;
23207     {
23208         PyThreadState* __tstate = wxPyBeginAllowThreads();
23209         result = (int)((wxPrintDialogData const *)arg1)->GetMinPage();
23210
23211         wxPyEndAllowThreads(__tstate);
23212         if (PyErr_Occurred()) SWIG_fail;
23213     }
23214     {
23215         resultobj = SWIG_From_int((int)(result));
23216     }
23217     return resultobj;
23218     fail:
23219     return NULL;
23220 }
23221
23222
23223 static PyObject *_wrap_PrintDialogData_GetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
23224     PyObject *resultobj;
23225     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23226     int result;
23227     PyObject * obj0 = 0 ;
23228     char *kwnames[] = {
23229         (char *) "self", NULL
23230     };
23231
23232     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetMaxPage",kwnames,&obj0)) goto fail;
23233     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23234     if (SWIG_arg_fail(1)) SWIG_fail;
23235     {
23236         PyThreadState* __tstate = wxPyBeginAllowThreads();
23237         result = (int)((wxPrintDialogData const *)arg1)->GetMaxPage();
23238
23239         wxPyEndAllowThreads(__tstate);
23240         if (PyErr_Occurred()) SWIG_fail;
23241     }
23242     {
23243         resultobj = SWIG_From_int((int)(result));
23244     }
23245     return resultobj;
23246     fail:
23247     return NULL;
23248 }
23249
23250
23251 static PyObject *_wrap_PrintDialogData_GetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
23252     PyObject *resultobj;
23253     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23254     int result;
23255     PyObject * obj0 = 0 ;
23256     char *kwnames[] = {
23257         (char *) "self", NULL
23258     };
23259
23260     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetNoCopies",kwnames,&obj0)) goto fail;
23261     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23262     if (SWIG_arg_fail(1)) SWIG_fail;
23263     {
23264         PyThreadState* __tstate = wxPyBeginAllowThreads();
23265         result = (int)((wxPrintDialogData const *)arg1)->GetNoCopies();
23266
23267         wxPyEndAllowThreads(__tstate);
23268         if (PyErr_Occurred()) SWIG_fail;
23269     }
23270     {
23271         resultobj = SWIG_From_int((int)(result));
23272     }
23273     return resultobj;
23274     fail:
23275     return NULL;
23276 }
23277
23278
23279 static PyObject *_wrap_PrintDialogData_GetAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
23280     PyObject *resultobj;
23281     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23282     bool result;
23283     PyObject * obj0 = 0 ;
23284     char *kwnames[] = {
23285         (char *) "self", NULL
23286     };
23287
23288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetAllPages",kwnames,&obj0)) goto fail;
23289     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23290     if (SWIG_arg_fail(1)) SWIG_fail;
23291     {
23292         PyThreadState* __tstate = wxPyBeginAllowThreads();
23293         result = (bool)((wxPrintDialogData const *)arg1)->GetAllPages();
23294
23295         wxPyEndAllowThreads(__tstate);
23296         if (PyErr_Occurred()) SWIG_fail;
23297     }
23298     {
23299         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23300     }
23301     return resultobj;
23302     fail:
23303     return NULL;
23304 }
23305
23306
23307 static PyObject *_wrap_PrintDialogData_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23308     PyObject *resultobj;
23309     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23310     bool result;
23311     PyObject * obj0 = 0 ;
23312     char *kwnames[] = {
23313         (char *) "self", NULL
23314     };
23315
23316     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetSelection",kwnames,&obj0)) goto fail;
23317     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23318     if (SWIG_arg_fail(1)) SWIG_fail;
23319     {
23320         PyThreadState* __tstate = wxPyBeginAllowThreads();
23321         result = (bool)((wxPrintDialogData const *)arg1)->GetSelection();
23322
23323         wxPyEndAllowThreads(__tstate);
23324         if (PyErr_Occurred()) SWIG_fail;
23325     }
23326     {
23327         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23328     }
23329     return resultobj;
23330     fail:
23331     return NULL;
23332 }
23333
23334
23335 static PyObject *_wrap_PrintDialogData_GetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
23336     PyObject *resultobj;
23337     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23338     bool result;
23339     PyObject * obj0 = 0 ;
23340     char *kwnames[] = {
23341         (char *) "self", NULL
23342     };
23343
23344     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetCollate",kwnames,&obj0)) goto fail;
23345     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23346     if (SWIG_arg_fail(1)) SWIG_fail;
23347     {
23348         PyThreadState* __tstate = wxPyBeginAllowThreads();
23349         result = (bool)((wxPrintDialogData const *)arg1)->GetCollate();
23350
23351         wxPyEndAllowThreads(__tstate);
23352         if (PyErr_Occurred()) SWIG_fail;
23353     }
23354     {
23355         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23356     }
23357     return resultobj;
23358     fail:
23359     return NULL;
23360 }
23361
23362
23363 static PyObject *_wrap_PrintDialogData_GetPrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23364     PyObject *resultobj;
23365     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23366     bool result;
23367     PyObject * obj0 = 0 ;
23368     char *kwnames[] = {
23369         (char *) "self", NULL
23370     };
23371
23372     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetPrintToFile",kwnames,&obj0)) goto fail;
23373     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23374     if (SWIG_arg_fail(1)) SWIG_fail;
23375     {
23376         PyThreadState* __tstate = wxPyBeginAllowThreads();
23377         result = (bool)((wxPrintDialogData const *)arg1)->GetPrintToFile();
23378
23379         wxPyEndAllowThreads(__tstate);
23380         if (PyErr_Occurred()) SWIG_fail;
23381     }
23382     {
23383         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23384     }
23385     return resultobj;
23386     fail:
23387     return NULL;
23388 }
23389
23390
23391 static PyObject *_wrap_PrintDialogData_GetSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23392     PyObject *resultobj;
23393     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23394     bool result;
23395     PyObject * obj0 = 0 ;
23396     char *kwnames[] = {
23397         (char *) "self", NULL
23398     };
23399
23400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetSetupDialog",kwnames,&obj0)) goto fail;
23401     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23402     if (SWIG_arg_fail(1)) SWIG_fail;
23403     {
23404         PyThreadState* __tstate = wxPyBeginAllowThreads();
23405         result = (bool)((wxPrintDialogData const *)arg1)->GetSetupDialog();
23406
23407         wxPyEndAllowThreads(__tstate);
23408         if (PyErr_Occurred()) SWIG_fail;
23409     }
23410     {
23411         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23412     }
23413     return resultobj;
23414     fail:
23415     return NULL;
23416 }
23417
23418
23419 static PyObject *_wrap_PrintDialogData_SetSetupDialog(PyObject *, PyObject *args, PyObject *kwargs) {
23420     PyObject *resultobj;
23421     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23422     bool arg2 ;
23423     PyObject * obj0 = 0 ;
23424     PyObject * obj1 = 0 ;
23425     char *kwnames[] = {
23426         (char *) "self",(char *) "flag", NULL
23427     };
23428
23429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetSetupDialog",kwnames,&obj0,&obj1)) goto fail;
23430     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23431     if (SWIG_arg_fail(1)) SWIG_fail;
23432     {
23433         arg2 = (bool)(SWIG_As_bool(obj1));
23434         if (SWIG_arg_fail(2)) SWIG_fail;
23435     }
23436     {
23437         PyThreadState* __tstate = wxPyBeginAllowThreads();
23438         (arg1)->SetSetupDialog(arg2);
23439
23440         wxPyEndAllowThreads(__tstate);
23441         if (PyErr_Occurred()) SWIG_fail;
23442     }
23443     Py_INCREF(Py_None); resultobj = Py_None;
23444     return resultobj;
23445     fail:
23446     return NULL;
23447 }
23448
23449
23450 static PyObject *_wrap_PrintDialogData_SetFromPage(PyObject *, PyObject *args, PyObject *kwargs) {
23451     PyObject *resultobj;
23452     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23453     int arg2 ;
23454     PyObject * obj0 = 0 ;
23455     PyObject * obj1 = 0 ;
23456     char *kwnames[] = {
23457         (char *) "self",(char *) "v", NULL
23458     };
23459
23460     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetFromPage",kwnames,&obj0,&obj1)) goto fail;
23461     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23462     if (SWIG_arg_fail(1)) SWIG_fail;
23463     {
23464         arg2 = (int)(SWIG_As_int(obj1));
23465         if (SWIG_arg_fail(2)) SWIG_fail;
23466     }
23467     {
23468         PyThreadState* __tstate = wxPyBeginAllowThreads();
23469         (arg1)->SetFromPage(arg2);
23470
23471         wxPyEndAllowThreads(__tstate);
23472         if (PyErr_Occurred()) SWIG_fail;
23473     }
23474     Py_INCREF(Py_None); resultobj = Py_None;
23475     return resultobj;
23476     fail:
23477     return NULL;
23478 }
23479
23480
23481 static PyObject *_wrap_PrintDialogData_SetToPage(PyObject *, PyObject *args, PyObject *kwargs) {
23482     PyObject *resultobj;
23483     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23484     int arg2 ;
23485     PyObject * obj0 = 0 ;
23486     PyObject * obj1 = 0 ;
23487     char *kwnames[] = {
23488         (char *) "self",(char *) "v", NULL
23489     };
23490
23491     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetToPage",kwnames,&obj0,&obj1)) goto fail;
23492     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23493     if (SWIG_arg_fail(1)) SWIG_fail;
23494     {
23495         arg2 = (int)(SWIG_As_int(obj1));
23496         if (SWIG_arg_fail(2)) SWIG_fail;
23497     }
23498     {
23499         PyThreadState* __tstate = wxPyBeginAllowThreads();
23500         (arg1)->SetToPage(arg2);
23501
23502         wxPyEndAllowThreads(__tstate);
23503         if (PyErr_Occurred()) SWIG_fail;
23504     }
23505     Py_INCREF(Py_None); resultobj = Py_None;
23506     return resultobj;
23507     fail:
23508     return NULL;
23509 }
23510
23511
23512 static PyObject *_wrap_PrintDialogData_SetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
23513     PyObject *resultobj;
23514     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23515     int arg2 ;
23516     PyObject * obj0 = 0 ;
23517     PyObject * obj1 = 0 ;
23518     char *kwnames[] = {
23519         (char *) "self",(char *) "v", NULL
23520     };
23521
23522     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetMinPage",kwnames,&obj0,&obj1)) goto fail;
23523     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23524     if (SWIG_arg_fail(1)) SWIG_fail;
23525     {
23526         arg2 = (int)(SWIG_As_int(obj1));
23527         if (SWIG_arg_fail(2)) SWIG_fail;
23528     }
23529     {
23530         PyThreadState* __tstate = wxPyBeginAllowThreads();
23531         (arg1)->SetMinPage(arg2);
23532
23533         wxPyEndAllowThreads(__tstate);
23534         if (PyErr_Occurred()) SWIG_fail;
23535     }
23536     Py_INCREF(Py_None); resultobj = Py_None;
23537     return resultobj;
23538     fail:
23539     return NULL;
23540 }
23541
23542
23543 static PyObject *_wrap_PrintDialogData_SetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
23544     PyObject *resultobj;
23545     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23546     int arg2 ;
23547     PyObject * obj0 = 0 ;
23548     PyObject * obj1 = 0 ;
23549     char *kwnames[] = {
23550         (char *) "self",(char *) "v", NULL
23551     };
23552
23553     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetMaxPage",kwnames,&obj0,&obj1)) goto fail;
23554     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23555     if (SWIG_arg_fail(1)) SWIG_fail;
23556     {
23557         arg2 = (int)(SWIG_As_int(obj1));
23558         if (SWIG_arg_fail(2)) SWIG_fail;
23559     }
23560     {
23561         PyThreadState* __tstate = wxPyBeginAllowThreads();
23562         (arg1)->SetMaxPage(arg2);
23563
23564         wxPyEndAllowThreads(__tstate);
23565         if (PyErr_Occurred()) SWIG_fail;
23566     }
23567     Py_INCREF(Py_None); resultobj = Py_None;
23568     return resultobj;
23569     fail:
23570     return NULL;
23571 }
23572
23573
23574 static PyObject *_wrap_PrintDialogData_SetNoCopies(PyObject *, PyObject *args, PyObject *kwargs) {
23575     PyObject *resultobj;
23576     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23577     int arg2 ;
23578     PyObject * obj0 = 0 ;
23579     PyObject * obj1 = 0 ;
23580     char *kwnames[] = {
23581         (char *) "self",(char *) "v", NULL
23582     };
23583
23584     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetNoCopies",kwnames,&obj0,&obj1)) goto fail;
23585     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23586     if (SWIG_arg_fail(1)) SWIG_fail;
23587     {
23588         arg2 = (int)(SWIG_As_int(obj1));
23589         if (SWIG_arg_fail(2)) SWIG_fail;
23590     }
23591     {
23592         PyThreadState* __tstate = wxPyBeginAllowThreads();
23593         (arg1)->SetNoCopies(arg2);
23594
23595         wxPyEndAllowThreads(__tstate);
23596         if (PyErr_Occurred()) SWIG_fail;
23597     }
23598     Py_INCREF(Py_None); resultobj = Py_None;
23599     return resultobj;
23600     fail:
23601     return NULL;
23602 }
23603
23604
23605 static PyObject *_wrap_PrintDialogData_SetAllPages(PyObject *, PyObject *args, PyObject *kwargs) {
23606     PyObject *resultobj;
23607     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23608     bool arg2 ;
23609     PyObject * obj0 = 0 ;
23610     PyObject * obj1 = 0 ;
23611     char *kwnames[] = {
23612         (char *) "self",(char *) "flag", NULL
23613     };
23614
23615     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetAllPages",kwnames,&obj0,&obj1)) goto fail;
23616     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23617     if (SWIG_arg_fail(1)) SWIG_fail;
23618     {
23619         arg2 = (bool)(SWIG_As_bool(obj1));
23620         if (SWIG_arg_fail(2)) SWIG_fail;
23621     }
23622     {
23623         PyThreadState* __tstate = wxPyBeginAllowThreads();
23624         (arg1)->SetAllPages(arg2);
23625
23626         wxPyEndAllowThreads(__tstate);
23627         if (PyErr_Occurred()) SWIG_fail;
23628     }
23629     Py_INCREF(Py_None); resultobj = Py_None;
23630     return resultobj;
23631     fail:
23632     return NULL;
23633 }
23634
23635
23636 static PyObject *_wrap_PrintDialogData_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23637     PyObject *resultobj;
23638     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23639     bool arg2 ;
23640     PyObject * obj0 = 0 ;
23641     PyObject * obj1 = 0 ;
23642     char *kwnames[] = {
23643         (char *) "self",(char *) "flag", NULL
23644     };
23645
23646     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetSelection",kwnames,&obj0,&obj1)) goto fail;
23647     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23648     if (SWIG_arg_fail(1)) SWIG_fail;
23649     {
23650         arg2 = (bool)(SWIG_As_bool(obj1));
23651         if (SWIG_arg_fail(2)) SWIG_fail;
23652     }
23653     {
23654         PyThreadState* __tstate = wxPyBeginAllowThreads();
23655         (arg1)->SetSelection(arg2);
23656
23657         wxPyEndAllowThreads(__tstate);
23658         if (PyErr_Occurred()) SWIG_fail;
23659     }
23660     Py_INCREF(Py_None); resultobj = Py_None;
23661     return resultobj;
23662     fail:
23663     return NULL;
23664 }
23665
23666
23667 static PyObject *_wrap_PrintDialogData_SetCollate(PyObject *, PyObject *args, PyObject *kwargs) {
23668     PyObject *resultobj;
23669     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23670     bool arg2 ;
23671     PyObject * obj0 = 0 ;
23672     PyObject * obj1 = 0 ;
23673     char *kwnames[] = {
23674         (char *) "self",(char *) "flag", NULL
23675     };
23676
23677     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetCollate",kwnames,&obj0,&obj1)) goto fail;
23678     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23679     if (SWIG_arg_fail(1)) SWIG_fail;
23680     {
23681         arg2 = (bool)(SWIG_As_bool(obj1));
23682         if (SWIG_arg_fail(2)) SWIG_fail;
23683     }
23684     {
23685         PyThreadState* __tstate = wxPyBeginAllowThreads();
23686         (arg1)->SetCollate(arg2);
23687
23688         wxPyEndAllowThreads(__tstate);
23689         if (PyErr_Occurred()) SWIG_fail;
23690     }
23691     Py_INCREF(Py_None); resultobj = Py_None;
23692     return resultobj;
23693     fail:
23694     return NULL;
23695 }
23696
23697
23698 static PyObject *_wrap_PrintDialogData_SetPrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23699     PyObject *resultobj;
23700     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23701     bool arg2 ;
23702     PyObject * obj0 = 0 ;
23703     PyObject * obj1 = 0 ;
23704     char *kwnames[] = {
23705         (char *) "self",(char *) "flag", NULL
23706     };
23707
23708     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetPrintToFile",kwnames,&obj0,&obj1)) goto fail;
23709     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23710     if (SWIG_arg_fail(1)) SWIG_fail;
23711     {
23712         arg2 = (bool)(SWIG_As_bool(obj1));
23713         if (SWIG_arg_fail(2)) SWIG_fail;
23714     }
23715     {
23716         PyThreadState* __tstate = wxPyBeginAllowThreads();
23717         (arg1)->SetPrintToFile(arg2);
23718
23719         wxPyEndAllowThreads(__tstate);
23720         if (PyErr_Occurred()) SWIG_fail;
23721     }
23722     Py_INCREF(Py_None); resultobj = Py_None;
23723     return resultobj;
23724     fail:
23725     return NULL;
23726 }
23727
23728
23729 static PyObject *_wrap_PrintDialogData_EnablePrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23730     PyObject *resultobj;
23731     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23732     bool arg2 ;
23733     PyObject * obj0 = 0 ;
23734     PyObject * obj1 = 0 ;
23735     char *kwnames[] = {
23736         (char *) "self",(char *) "flag", NULL
23737     };
23738
23739     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnablePrintToFile",kwnames,&obj0,&obj1)) goto fail;
23740     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23741     if (SWIG_arg_fail(1)) SWIG_fail;
23742     {
23743         arg2 = (bool)(SWIG_As_bool(obj1));
23744         if (SWIG_arg_fail(2)) SWIG_fail;
23745     }
23746     {
23747         PyThreadState* __tstate = wxPyBeginAllowThreads();
23748         (arg1)->EnablePrintToFile(arg2);
23749
23750         wxPyEndAllowThreads(__tstate);
23751         if (PyErr_Occurred()) SWIG_fail;
23752     }
23753     Py_INCREF(Py_None); resultobj = Py_None;
23754     return resultobj;
23755     fail:
23756     return NULL;
23757 }
23758
23759
23760 static PyObject *_wrap_PrintDialogData_EnableSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23761     PyObject *resultobj;
23762     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23763     bool arg2 ;
23764     PyObject * obj0 = 0 ;
23765     PyObject * obj1 = 0 ;
23766     char *kwnames[] = {
23767         (char *) "self",(char *) "flag", NULL
23768     };
23769
23770     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnableSelection",kwnames,&obj0,&obj1)) goto fail;
23771     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23772     if (SWIG_arg_fail(1)) SWIG_fail;
23773     {
23774         arg2 = (bool)(SWIG_As_bool(obj1));
23775         if (SWIG_arg_fail(2)) SWIG_fail;
23776     }
23777     {
23778         PyThreadState* __tstate = wxPyBeginAllowThreads();
23779         (arg1)->EnableSelection(arg2);
23780
23781         wxPyEndAllowThreads(__tstate);
23782         if (PyErr_Occurred()) SWIG_fail;
23783     }
23784     Py_INCREF(Py_None); resultobj = Py_None;
23785     return resultobj;
23786     fail:
23787     return NULL;
23788 }
23789
23790
23791 static PyObject *_wrap_PrintDialogData_EnablePageNumbers(PyObject *, PyObject *args, PyObject *kwargs) {
23792     PyObject *resultobj;
23793     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23794     bool arg2 ;
23795     PyObject * obj0 = 0 ;
23796     PyObject * obj1 = 0 ;
23797     char *kwnames[] = {
23798         (char *) "self",(char *) "flag", NULL
23799     };
23800
23801     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnablePageNumbers",kwnames,&obj0,&obj1)) goto fail;
23802     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23803     if (SWIG_arg_fail(1)) SWIG_fail;
23804     {
23805         arg2 = (bool)(SWIG_As_bool(obj1));
23806         if (SWIG_arg_fail(2)) SWIG_fail;
23807     }
23808     {
23809         PyThreadState* __tstate = wxPyBeginAllowThreads();
23810         (arg1)->EnablePageNumbers(arg2);
23811
23812         wxPyEndAllowThreads(__tstate);
23813         if (PyErr_Occurred()) SWIG_fail;
23814     }
23815     Py_INCREF(Py_None); resultobj = Py_None;
23816     return resultobj;
23817     fail:
23818     return NULL;
23819 }
23820
23821
23822 static PyObject *_wrap_PrintDialogData_EnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
23823     PyObject *resultobj;
23824     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23825     bool arg2 ;
23826     PyObject * obj0 = 0 ;
23827     PyObject * obj1 = 0 ;
23828     char *kwnames[] = {
23829         (char *) "self",(char *) "flag", NULL
23830     };
23831
23832     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_EnableHelp",kwnames,&obj0,&obj1)) goto fail;
23833     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23834     if (SWIG_arg_fail(1)) SWIG_fail;
23835     {
23836         arg2 = (bool)(SWIG_As_bool(obj1));
23837         if (SWIG_arg_fail(2)) SWIG_fail;
23838     }
23839     {
23840         PyThreadState* __tstate = wxPyBeginAllowThreads();
23841         (arg1)->EnableHelp(arg2);
23842
23843         wxPyEndAllowThreads(__tstate);
23844         if (PyErr_Occurred()) SWIG_fail;
23845     }
23846     Py_INCREF(Py_None); resultobj = Py_None;
23847     return resultobj;
23848     fail:
23849     return NULL;
23850 }
23851
23852
23853 static PyObject *_wrap_PrintDialogData_GetEnablePrintToFile(PyObject *, PyObject *args, PyObject *kwargs) {
23854     PyObject *resultobj;
23855     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23856     bool result;
23857     PyObject * obj0 = 0 ;
23858     char *kwnames[] = {
23859         (char *) "self", NULL
23860     };
23861
23862     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnablePrintToFile",kwnames,&obj0)) goto fail;
23863     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23864     if (SWIG_arg_fail(1)) SWIG_fail;
23865     {
23866         PyThreadState* __tstate = wxPyBeginAllowThreads();
23867         result = (bool)((wxPrintDialogData const *)arg1)->GetEnablePrintToFile();
23868
23869         wxPyEndAllowThreads(__tstate);
23870         if (PyErr_Occurred()) SWIG_fail;
23871     }
23872     {
23873         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23874     }
23875     return resultobj;
23876     fail:
23877     return NULL;
23878 }
23879
23880
23881 static PyObject *_wrap_PrintDialogData_GetEnableSelection(PyObject *, PyObject *args, PyObject *kwargs) {
23882     PyObject *resultobj;
23883     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23884     bool result;
23885     PyObject * obj0 = 0 ;
23886     char *kwnames[] = {
23887         (char *) "self", NULL
23888     };
23889
23890     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnableSelection",kwnames,&obj0)) goto fail;
23891     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23892     if (SWIG_arg_fail(1)) SWIG_fail;
23893     {
23894         PyThreadState* __tstate = wxPyBeginAllowThreads();
23895         result = (bool)((wxPrintDialogData const *)arg1)->GetEnableSelection();
23896
23897         wxPyEndAllowThreads(__tstate);
23898         if (PyErr_Occurred()) SWIG_fail;
23899     }
23900     {
23901         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23902     }
23903     return resultobj;
23904     fail:
23905     return NULL;
23906 }
23907
23908
23909 static PyObject *_wrap_PrintDialogData_GetEnablePageNumbers(PyObject *, PyObject *args, PyObject *kwargs) {
23910     PyObject *resultobj;
23911     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23912     bool result;
23913     PyObject * obj0 = 0 ;
23914     char *kwnames[] = {
23915         (char *) "self", NULL
23916     };
23917
23918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnablePageNumbers",kwnames,&obj0)) goto fail;
23919     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23920     if (SWIG_arg_fail(1)) SWIG_fail;
23921     {
23922         PyThreadState* __tstate = wxPyBeginAllowThreads();
23923         result = (bool)((wxPrintDialogData const *)arg1)->GetEnablePageNumbers();
23924
23925         wxPyEndAllowThreads(__tstate);
23926         if (PyErr_Occurred()) SWIG_fail;
23927     }
23928     {
23929         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23930     }
23931     return resultobj;
23932     fail:
23933     return NULL;
23934 }
23935
23936
23937 static PyObject *_wrap_PrintDialogData_GetEnableHelp(PyObject *, PyObject *args, PyObject *kwargs) {
23938     PyObject *resultobj;
23939     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23940     bool result;
23941     PyObject * obj0 = 0 ;
23942     char *kwnames[] = {
23943         (char *) "self", NULL
23944     };
23945
23946     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetEnableHelp",kwnames,&obj0)) goto fail;
23947     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23948     if (SWIG_arg_fail(1)) SWIG_fail;
23949     {
23950         PyThreadState* __tstate = wxPyBeginAllowThreads();
23951         result = (bool)((wxPrintDialogData const *)arg1)->GetEnableHelp();
23952
23953         wxPyEndAllowThreads(__tstate);
23954         if (PyErr_Occurred()) SWIG_fail;
23955     }
23956     {
23957         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23958     }
23959     return resultobj;
23960     fail:
23961     return NULL;
23962 }
23963
23964
23965 static PyObject *_wrap_PrintDialogData_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23966     PyObject *resultobj;
23967     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23968     bool result;
23969     PyObject * obj0 = 0 ;
23970     char *kwnames[] = {
23971         (char *) "self", NULL
23972     };
23973
23974     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_Ok",kwnames,&obj0)) goto fail;
23975     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
23976     if (SWIG_arg_fail(1)) SWIG_fail;
23977     {
23978         PyThreadState* __tstate = wxPyBeginAllowThreads();
23979         result = (bool)((wxPrintDialogData const *)arg1)->Ok();
23980
23981         wxPyEndAllowThreads(__tstate);
23982         if (PyErr_Occurred()) SWIG_fail;
23983     }
23984     {
23985         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23986     }
23987     return resultobj;
23988     fail:
23989     return NULL;
23990 }
23991
23992
23993 static PyObject *_wrap_PrintDialogData_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
23994     PyObject *resultobj;
23995     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
23996     wxPrintData *result;
23997     PyObject * obj0 = 0 ;
23998     char *kwnames[] = {
23999         (char *) "self", NULL
24000     };
24001
24002     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialogData_GetPrintData",kwnames,&obj0)) goto fail;
24003     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24004     if (SWIG_arg_fail(1)) SWIG_fail;
24005     {
24006         PyThreadState* __tstate = wxPyBeginAllowThreads();
24007         {
24008             wxPrintData &_result_ref = (arg1)->GetPrintData();
24009             result = (wxPrintData *) &_result_ref;
24010         }
24011
24012         wxPyEndAllowThreads(__tstate);
24013         if (PyErr_Occurred()) SWIG_fail;
24014     }
24015     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
24016     return resultobj;
24017     fail:
24018     return NULL;
24019 }
24020
24021
24022 static PyObject *_wrap_PrintDialogData_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24023     PyObject *resultobj;
24024     wxPrintDialogData *arg1 = (wxPrintDialogData *) 0 ;
24025     wxPrintData *arg2 = 0 ;
24026     PyObject * obj0 = 0 ;
24027     PyObject * obj1 = 0 ;
24028     char *kwnames[] = {
24029         (char *) "self",(char *) "printData", NULL
24030     };
24031
24032     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintDialogData_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
24033     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24034     if (SWIG_arg_fail(1)) SWIG_fail;
24035     {
24036         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
24037         if (SWIG_arg_fail(2)) SWIG_fail;
24038         if (arg2 == NULL) {
24039             SWIG_null_ref("wxPrintData");
24040         }
24041         if (SWIG_arg_fail(2)) SWIG_fail;
24042     }
24043     {
24044         PyThreadState* __tstate = wxPyBeginAllowThreads();
24045         (arg1)->SetPrintData((wxPrintData const &)*arg2);
24046
24047         wxPyEndAllowThreads(__tstate);
24048         if (PyErr_Occurred()) SWIG_fail;
24049     }
24050     Py_INCREF(Py_None); resultobj = Py_None;
24051     return resultobj;
24052     fail:
24053     return NULL;
24054 }
24055
24056
24057 static PyObject * PrintDialogData_swigregister(PyObject *, PyObject *args) {
24058     PyObject *obj;
24059     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24060     SWIG_TypeClientData(SWIGTYPE_p_wxPrintDialogData, obj);
24061     Py_INCREF(obj);
24062     return Py_BuildValue((char *)"");
24063 }
24064 static PyObject *_wrap_new_PrintDialog(PyObject *, PyObject *args, PyObject *kwargs) {
24065     PyObject *resultobj;
24066     wxWindow *arg1 = (wxWindow *) 0 ;
24067     wxPrintDialogData *arg2 = (wxPrintDialogData *) NULL ;
24068     wxPrintDialog *result;
24069     PyObject * obj0 = 0 ;
24070     PyObject * obj1 = 0 ;
24071     char *kwnames[] = {
24072         (char *) "parent",(char *) "data", NULL
24073     };
24074
24075     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PrintDialog",kwnames,&obj0,&obj1)) goto fail;
24076     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24077     if (SWIG_arg_fail(1)) SWIG_fail;
24078     if (obj1) {
24079         SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24080         if (SWIG_arg_fail(2)) SWIG_fail;
24081     }
24082     {
24083         if (!wxPyCheckForApp()) SWIG_fail;
24084         PyThreadState* __tstate = wxPyBeginAllowThreads();
24085         result = (wxPrintDialog *)new wxPrintDialog(arg1,arg2);
24086
24087         wxPyEndAllowThreads(__tstate);
24088         if (PyErr_Occurred()) SWIG_fail;
24089     }
24090     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialog, 1);
24091     return resultobj;
24092     fail:
24093     return NULL;
24094 }
24095
24096
24097 static PyObject *_wrap_PrintDialog_ShowModal(PyObject *, PyObject *args, PyObject *kwargs) {
24098     PyObject *resultobj;
24099     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24100     int result;
24101     PyObject * obj0 = 0 ;
24102     char *kwnames[] = {
24103         (char *) "self", NULL
24104     };
24105
24106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_ShowModal",kwnames,&obj0)) goto fail;
24107     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24108     if (SWIG_arg_fail(1)) SWIG_fail;
24109     {
24110         PyThreadState* __tstate = wxPyBeginAllowThreads();
24111         result = (int)(arg1)->ShowModal();
24112
24113         wxPyEndAllowThreads(__tstate);
24114         if (PyErr_Occurred()) SWIG_fail;
24115     }
24116     {
24117         resultobj = SWIG_From_int((int)(result));
24118     }
24119     return resultobj;
24120     fail:
24121     return NULL;
24122 }
24123
24124
24125 static PyObject *_wrap_PrintDialog_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
24126     PyObject *resultobj;
24127     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24128     wxPrintDialogData *result;
24129     PyObject * obj0 = 0 ;
24130     char *kwnames[] = {
24131         (char *) "self", NULL
24132     };
24133
24134     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintDialogData",kwnames,&obj0)) goto fail;
24135     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24136     if (SWIG_arg_fail(1)) SWIG_fail;
24137     {
24138         PyThreadState* __tstate = wxPyBeginAllowThreads();
24139         {
24140             wxPrintDialogData &_result_ref = (arg1)->GetPrintDialogData();
24141             result = (wxPrintDialogData *) &_result_ref;
24142         }
24143
24144         wxPyEndAllowThreads(__tstate);
24145         if (PyErr_Occurred()) SWIG_fail;
24146     }
24147     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
24148     return resultobj;
24149     fail:
24150     return NULL;
24151 }
24152
24153
24154 static PyObject *_wrap_PrintDialog_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
24155     PyObject *resultobj;
24156     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24157     wxPrintData *result;
24158     PyObject * obj0 = 0 ;
24159     char *kwnames[] = {
24160         (char *) "self", NULL
24161     };
24162
24163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintData",kwnames,&obj0)) goto fail;
24164     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24165     if (SWIG_arg_fail(1)) SWIG_fail;
24166     {
24167         PyThreadState* __tstate = wxPyBeginAllowThreads();
24168         {
24169             wxPrintData &_result_ref = (arg1)->GetPrintData();
24170             result = (wxPrintData *) &_result_ref;
24171         }
24172
24173         wxPyEndAllowThreads(__tstate);
24174         if (PyErr_Occurred()) SWIG_fail;
24175     }
24176     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
24177     return resultobj;
24178     fail:
24179     return NULL;
24180 }
24181
24182
24183 static PyObject *_wrap_PrintDialog_GetPrintDC(PyObject *, PyObject *args, PyObject *kwargs) {
24184     PyObject *resultobj;
24185     wxPrintDialog *arg1 = (wxPrintDialog *) 0 ;
24186     wxDC *result;
24187     PyObject * obj0 = 0 ;
24188     char *kwnames[] = {
24189         (char *) "self", NULL
24190     };
24191
24192     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintDialog_GetPrintDC",kwnames,&obj0)) goto fail;
24193     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialog, SWIG_POINTER_EXCEPTION | 0);
24194     if (SWIG_arg_fail(1)) SWIG_fail;
24195     {
24196         PyThreadState* __tstate = wxPyBeginAllowThreads();
24197         result = (wxDC *)(arg1)->GetPrintDC();
24198
24199         wxPyEndAllowThreads(__tstate);
24200         if (PyErr_Occurred()) SWIG_fail;
24201     }
24202     {
24203         resultobj = wxPyMake_wxObject(result, 1);
24204     }
24205     return resultobj;
24206     fail:
24207     return NULL;
24208 }
24209
24210
24211 static PyObject * PrintDialog_swigregister(PyObject *, PyObject *args) {
24212     PyObject *obj;
24213     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24214     SWIG_TypeClientData(SWIGTYPE_p_wxPrintDialog, obj);
24215     Py_INCREF(obj);
24216     return Py_BuildValue((char *)"");
24217 }
24218 static PyObject *_wrap_new_Printer(PyObject *, PyObject *args, PyObject *kwargs) {
24219     PyObject *resultobj;
24220     wxPrintDialogData *arg1 = (wxPrintDialogData *) NULL ;
24221     wxPrinter *result;
24222     PyObject * obj0 = 0 ;
24223     char *kwnames[] = {
24224         (char *) "data", NULL
24225     };
24226
24227     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Printer",kwnames,&obj0)) goto fail;
24228     if (obj0) {
24229         SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
24230         if (SWIG_arg_fail(1)) SWIG_fail;
24231     }
24232     {
24233         if (!wxPyCheckForApp()) SWIG_fail;
24234         PyThreadState* __tstate = wxPyBeginAllowThreads();
24235         result = (wxPrinter *)new wxPrinter(arg1);
24236
24237         wxPyEndAllowThreads(__tstate);
24238         if (PyErr_Occurred()) SWIG_fail;
24239     }
24240     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinter, 1);
24241     return resultobj;
24242     fail:
24243     return NULL;
24244 }
24245
24246
24247 static PyObject *_wrap_delete_Printer(PyObject *, PyObject *args, PyObject *kwargs) {
24248     PyObject *resultobj;
24249     wxPrinter *arg1 = (wxPrinter *) 0 ;
24250     PyObject * obj0 = 0 ;
24251     char *kwnames[] = {
24252         (char *) "self", NULL
24253     };
24254
24255     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Printer",kwnames,&obj0)) goto fail;
24256     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24257     if (SWIG_arg_fail(1)) SWIG_fail;
24258     {
24259         PyThreadState* __tstate = wxPyBeginAllowThreads();
24260         delete arg1;
24261
24262         wxPyEndAllowThreads(__tstate);
24263         if (PyErr_Occurred()) SWIG_fail;
24264     }
24265     Py_INCREF(Py_None); resultobj = Py_None;
24266     return resultobj;
24267     fail:
24268     return NULL;
24269 }
24270
24271
24272 static PyObject *_wrap_Printer_CreateAbortWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24273     PyObject *resultobj;
24274     wxPrinter *arg1 = (wxPrinter *) 0 ;
24275     wxWindow *arg2 = (wxWindow *) 0 ;
24276     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24277     wxWindow *result;
24278     PyObject * obj0 = 0 ;
24279     PyObject * obj1 = 0 ;
24280     PyObject * obj2 = 0 ;
24281     char *kwnames[] = {
24282         (char *) "self",(char *) "parent",(char *) "printout", NULL
24283     };
24284
24285     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printer_CreateAbortWindow",kwnames,&obj0,&obj1,&obj2)) goto fail;
24286     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24287     if (SWIG_arg_fail(1)) SWIG_fail;
24288     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24289     if (SWIG_arg_fail(2)) SWIG_fail;
24290     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24291     if (SWIG_arg_fail(3)) SWIG_fail;
24292     {
24293         PyThreadState* __tstate = wxPyBeginAllowThreads();
24294         result = (wxWindow *)(arg1)->CreateAbortWindow(arg2,arg3);
24295
24296         wxPyEndAllowThreads(__tstate);
24297         if (PyErr_Occurred()) SWIG_fail;
24298     }
24299     {
24300         resultobj = wxPyMake_wxObject(result, 0);
24301     }
24302     return resultobj;
24303     fail:
24304     return NULL;
24305 }
24306
24307
24308 static PyObject *_wrap_Printer_ReportError(PyObject *, PyObject *args, PyObject *kwargs) {
24309     PyObject *resultobj;
24310     wxPrinter *arg1 = (wxPrinter *) 0 ;
24311     wxWindow *arg2 = (wxWindow *) 0 ;
24312     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24313     wxString *arg4 = 0 ;
24314     bool temp4 = false ;
24315     PyObject * obj0 = 0 ;
24316     PyObject * obj1 = 0 ;
24317     PyObject * obj2 = 0 ;
24318     PyObject * obj3 = 0 ;
24319     char *kwnames[] = {
24320         (char *) "self",(char *) "parent",(char *) "printout",(char *) "message", NULL
24321     };
24322
24323     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Printer_ReportError",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24324     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24325     if (SWIG_arg_fail(1)) SWIG_fail;
24326     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24327     if (SWIG_arg_fail(2)) SWIG_fail;
24328     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24329     if (SWIG_arg_fail(3)) SWIG_fail;
24330     {
24331         arg4 = wxString_in_helper(obj3);
24332         if (arg4 == NULL) SWIG_fail;
24333         temp4 = true;
24334     }
24335     {
24336         PyThreadState* __tstate = wxPyBeginAllowThreads();
24337         (arg1)->ReportError(arg2,arg3,(wxString const &)*arg4);
24338
24339         wxPyEndAllowThreads(__tstate);
24340         if (PyErr_Occurred()) SWIG_fail;
24341     }
24342     Py_INCREF(Py_None); resultobj = Py_None;
24343     {
24344         if (temp4)
24345         delete arg4;
24346     }
24347     return resultobj;
24348     fail:
24349     {
24350         if (temp4)
24351         delete arg4;
24352     }
24353     return NULL;
24354 }
24355
24356
24357 static PyObject *_wrap_Printer_Setup(PyObject *, PyObject *args, PyObject *kwargs) {
24358     PyObject *resultobj;
24359     wxPrinter *arg1 = (wxPrinter *) 0 ;
24360     wxWindow *arg2 = (wxWindow *) 0 ;
24361     bool result;
24362     PyObject * obj0 = 0 ;
24363     PyObject * obj1 = 0 ;
24364     char *kwnames[] = {
24365         (char *) "self",(char *) "parent", NULL
24366     };
24367
24368     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printer_Setup",kwnames,&obj0,&obj1)) goto fail;
24369     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24370     if (SWIG_arg_fail(1)) SWIG_fail;
24371     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24372     if (SWIG_arg_fail(2)) SWIG_fail;
24373     {
24374         PyThreadState* __tstate = wxPyBeginAllowThreads();
24375         result = (bool)(arg1)->Setup(arg2);
24376
24377         wxPyEndAllowThreads(__tstate);
24378         if (PyErr_Occurred()) SWIG_fail;
24379     }
24380     {
24381         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24382     }
24383     return resultobj;
24384     fail:
24385     return NULL;
24386 }
24387
24388
24389 static PyObject *_wrap_Printer_Print(PyObject *, PyObject *args, PyObject *kwargs) {
24390     PyObject *resultobj;
24391     wxPrinter *arg1 = (wxPrinter *) 0 ;
24392     wxWindow *arg2 = (wxWindow *) 0 ;
24393     wxPyPrintout *arg3 = (wxPyPrintout *) 0 ;
24394     bool arg4 = (bool) true ;
24395     bool result;
24396     PyObject * obj0 = 0 ;
24397     PyObject * obj1 = 0 ;
24398     PyObject * obj2 = 0 ;
24399     PyObject * obj3 = 0 ;
24400     char *kwnames[] = {
24401         (char *) "self",(char *) "parent",(char *) "printout",(char *) "prompt", NULL
24402     };
24403
24404     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Printer_Print",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24405     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24406     if (SWIG_arg_fail(1)) SWIG_fail;
24407     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24408     if (SWIG_arg_fail(2)) SWIG_fail;
24409     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24410     if (SWIG_arg_fail(3)) SWIG_fail;
24411     if (obj3) {
24412         {
24413             arg4 = (bool)(SWIG_As_bool(obj3));
24414             if (SWIG_arg_fail(4)) SWIG_fail;
24415         }
24416     }
24417     {
24418         PyThreadState* __tstate = wxPyBeginAllowThreads();
24419         result = (bool)(arg1)->Print(arg2,arg3,arg4);
24420
24421         wxPyEndAllowThreads(__tstate);
24422         if (PyErr_Occurred()) SWIG_fail;
24423     }
24424     {
24425         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24426     }
24427     return resultobj;
24428     fail:
24429     return NULL;
24430 }
24431
24432
24433 static PyObject *_wrap_Printer_PrintDialog(PyObject *, PyObject *args, PyObject *kwargs) {
24434     PyObject *resultobj;
24435     wxPrinter *arg1 = (wxPrinter *) 0 ;
24436     wxWindow *arg2 = (wxWindow *) 0 ;
24437     wxDC *result;
24438     PyObject * obj0 = 0 ;
24439     PyObject * obj1 = 0 ;
24440     char *kwnames[] = {
24441         (char *) "self",(char *) "parent", NULL
24442     };
24443
24444     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printer_PrintDialog",kwnames,&obj0,&obj1)) goto fail;
24445     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24446     if (SWIG_arg_fail(1)) SWIG_fail;
24447     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24448     if (SWIG_arg_fail(2)) SWIG_fail;
24449     {
24450         PyThreadState* __tstate = wxPyBeginAllowThreads();
24451         result = (wxDC *)(arg1)->PrintDialog(arg2);
24452
24453         wxPyEndAllowThreads(__tstate);
24454         if (PyErr_Occurred()) SWIG_fail;
24455     }
24456     {
24457         resultobj = wxPyMake_wxObject(result, 0);
24458     }
24459     return resultobj;
24460     fail:
24461     return NULL;
24462 }
24463
24464
24465 static PyObject *_wrap_Printer_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
24466     PyObject *resultobj;
24467     wxPrinter *arg1 = (wxPrinter *) 0 ;
24468     wxPrintDialogData *result;
24469     PyObject * obj0 = 0 ;
24470     char *kwnames[] = {
24471         (char *) "self", NULL
24472     };
24473
24474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printer_GetPrintDialogData",kwnames,&obj0)) goto fail;
24475     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24476     if (SWIG_arg_fail(1)) SWIG_fail;
24477     {
24478         PyThreadState* __tstate = wxPyBeginAllowThreads();
24479         {
24480             wxPrintDialogData &_result_ref = ((wxPrinter const *)arg1)->GetPrintDialogData();
24481             result = (wxPrintDialogData *) &_result_ref;
24482         }
24483
24484         wxPyEndAllowThreads(__tstate);
24485         if (PyErr_Occurred()) SWIG_fail;
24486     }
24487     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
24488     return resultobj;
24489     fail:
24490     return NULL;
24491 }
24492
24493
24494 static PyObject *_wrap_Printer_GetAbort(PyObject *, PyObject *args, PyObject *kwargs) {
24495     PyObject *resultobj;
24496     wxPrinter *arg1 = (wxPrinter *) 0 ;
24497     bool result;
24498     PyObject * obj0 = 0 ;
24499     char *kwnames[] = {
24500         (char *) "self", NULL
24501     };
24502
24503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printer_GetAbort",kwnames,&obj0)) goto fail;
24504     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrinter, SWIG_POINTER_EXCEPTION | 0);
24505     if (SWIG_arg_fail(1)) SWIG_fail;
24506     {
24507         PyThreadState* __tstate = wxPyBeginAllowThreads();
24508         result = (bool)(arg1)->GetAbort();
24509
24510         wxPyEndAllowThreads(__tstate);
24511         if (PyErr_Occurred()) SWIG_fail;
24512     }
24513     {
24514         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24515     }
24516     return resultobj;
24517     fail:
24518     return NULL;
24519 }
24520
24521
24522 static PyObject *_wrap_Printer_GetLastError(PyObject *, PyObject *args, PyObject *kwargs) {
24523     PyObject *resultobj;
24524     wxPrinterError result;
24525     char *kwnames[] = {
24526         NULL
24527     };
24528
24529     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Printer_GetLastError",kwnames)) goto fail;
24530     {
24531         PyThreadState* __tstate = wxPyBeginAllowThreads();
24532         result = (wxPrinterError)wxPrinter::GetLastError();
24533
24534         wxPyEndAllowThreads(__tstate);
24535         if (PyErr_Occurred()) SWIG_fail;
24536     }
24537     resultobj = SWIG_From_int((result));
24538     return resultobj;
24539     fail:
24540     return NULL;
24541 }
24542
24543
24544 static PyObject * Printer_swigregister(PyObject *, PyObject *args) {
24545     PyObject *obj;
24546     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24547     SWIG_TypeClientData(SWIGTYPE_p_wxPrinter, obj);
24548     Py_INCREF(obj);
24549     return Py_BuildValue((char *)"");
24550 }
24551 static PyObject *_wrap_new_Printout(PyObject *, PyObject *args, PyObject *kwargs) {
24552     PyObject *resultobj;
24553     wxString const &arg1_defvalue = wxPyPrintoutTitleStr ;
24554     wxString *arg1 = (wxString *) &arg1_defvalue ;
24555     wxPyPrintout *result;
24556     bool temp1 = false ;
24557     PyObject * obj0 = 0 ;
24558     char *kwnames[] = {
24559         (char *) "title", NULL
24560     };
24561
24562     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Printout",kwnames,&obj0)) goto fail;
24563     if (obj0) {
24564         {
24565             arg1 = wxString_in_helper(obj0);
24566             if (arg1 == NULL) SWIG_fail;
24567             temp1 = true;
24568         }
24569     }
24570     {
24571         if (!wxPyCheckForApp()) SWIG_fail;
24572         PyThreadState* __tstate = wxPyBeginAllowThreads();
24573         result = (wxPyPrintout *)new wxPyPrintout((wxString const &)*arg1);
24574
24575         wxPyEndAllowThreads(__tstate);
24576         if (PyErr_Occurred()) SWIG_fail;
24577     }
24578     {
24579         resultobj = wxPyMake_wxObject(result, 1);
24580     }
24581     {
24582         if (temp1)
24583         delete arg1;
24584     }
24585     return resultobj;
24586     fail:
24587     {
24588         if (temp1)
24589         delete arg1;
24590     }
24591     return NULL;
24592 }
24593
24594
24595 static PyObject *_wrap_Printout__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
24596     PyObject *resultobj;
24597     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24598     PyObject *arg2 = (PyObject *) 0 ;
24599     PyObject *arg3 = (PyObject *) 0 ;
24600     PyObject * obj0 = 0 ;
24601     PyObject * obj1 = 0 ;
24602     PyObject * obj2 = 0 ;
24603     char *kwnames[] = {
24604         (char *) "self",(char *) "self",(char *) "_class", NULL
24605     };
24606
24607     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
24608     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24609     if (SWIG_arg_fail(1)) SWIG_fail;
24610     arg2 = obj1;
24611     arg3 = obj2;
24612     {
24613         PyThreadState* __tstate = wxPyBeginAllowThreads();
24614         (arg1)->_setCallbackInfo(arg2,arg3);
24615
24616         wxPyEndAllowThreads(__tstate);
24617         if (PyErr_Occurred()) SWIG_fail;
24618     }
24619     Py_INCREF(Py_None); resultobj = Py_None;
24620     return resultobj;
24621     fail:
24622     return NULL;
24623 }
24624
24625
24626 static PyObject *_wrap_Printout_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24627     PyObject *resultobj;
24628     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24629     wxString result;
24630     PyObject * obj0 = 0 ;
24631     char *kwnames[] = {
24632         (char *) "self", NULL
24633     };
24634
24635     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetTitle",kwnames,&obj0)) goto fail;
24636     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24637     if (SWIG_arg_fail(1)) SWIG_fail;
24638     {
24639         PyThreadState* __tstate = wxPyBeginAllowThreads();
24640         result = ((wxPyPrintout const *)arg1)->GetTitle();
24641
24642         wxPyEndAllowThreads(__tstate);
24643         if (PyErr_Occurred()) SWIG_fail;
24644     }
24645     {
24646 #if wxUSE_UNICODE
24647         resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24648 #else
24649         resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24650 #endif
24651     }
24652     return resultobj;
24653     fail:
24654     return NULL;
24655 }
24656
24657
24658 static PyObject *_wrap_Printout_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
24659     PyObject *resultobj;
24660     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24661     wxDC *result;
24662     PyObject * obj0 = 0 ;
24663     char *kwnames[] = {
24664         (char *) "self", NULL
24665     };
24666
24667     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetDC",kwnames,&obj0)) goto fail;
24668     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24669     if (SWIG_arg_fail(1)) SWIG_fail;
24670     {
24671         PyThreadState* __tstate = wxPyBeginAllowThreads();
24672         result = (wxDC *)(arg1)->GetDC();
24673
24674         wxPyEndAllowThreads(__tstate);
24675         if (PyErr_Occurred()) SWIG_fail;
24676     }
24677     {
24678         resultobj = wxPyMake_wxObject(result, 0);
24679     }
24680     return resultobj;
24681     fail:
24682     return NULL;
24683 }
24684
24685
24686 static PyObject *_wrap_Printout_SetDC(PyObject *, PyObject *args, PyObject *kwargs) {
24687     PyObject *resultobj;
24688     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24689     wxDC *arg2 = (wxDC *) 0 ;
24690     PyObject * obj0 = 0 ;
24691     PyObject * obj1 = 0 ;
24692     char *kwnames[] = {
24693         (char *) "self",(char *) "dc", NULL
24694     };
24695
24696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetDC",kwnames,&obj0,&obj1)) goto fail;
24697     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24698     if (SWIG_arg_fail(1)) SWIG_fail;
24699     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
24700     if (SWIG_arg_fail(2)) SWIG_fail;
24701     {
24702         PyThreadState* __tstate = wxPyBeginAllowThreads();
24703         (arg1)->SetDC(arg2);
24704
24705         wxPyEndAllowThreads(__tstate);
24706         if (PyErr_Occurred()) SWIG_fail;
24707     }
24708     Py_INCREF(Py_None); resultobj = Py_None;
24709     return resultobj;
24710     fail:
24711     return NULL;
24712 }
24713
24714
24715 static PyObject *_wrap_Printout_SetPageSizePixels(PyObject *, PyObject *args, PyObject *kwargs) {
24716     PyObject *resultobj;
24717     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24718     int arg2 ;
24719     int arg3 ;
24720     PyObject * obj0 = 0 ;
24721     PyObject * obj1 = 0 ;
24722     PyObject * obj2 = 0 ;
24723     char *kwnames[] = {
24724         (char *) "self",(char *) "w",(char *) "h", NULL
24725     };
24726
24727     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPageSizePixels",kwnames,&obj0,&obj1,&obj2)) goto fail;
24728     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24729     if (SWIG_arg_fail(1)) SWIG_fail;
24730     {
24731         arg2 = (int)(SWIG_As_int(obj1));
24732         if (SWIG_arg_fail(2)) SWIG_fail;
24733     }
24734     {
24735         arg3 = (int)(SWIG_As_int(obj2));
24736         if (SWIG_arg_fail(3)) SWIG_fail;
24737     }
24738     {
24739         PyThreadState* __tstate = wxPyBeginAllowThreads();
24740         (arg1)->SetPageSizePixels(arg2,arg3);
24741
24742         wxPyEndAllowThreads(__tstate);
24743         if (PyErr_Occurred()) SWIG_fail;
24744     }
24745     Py_INCREF(Py_None); resultobj = Py_None;
24746     return resultobj;
24747     fail:
24748     return NULL;
24749 }
24750
24751
24752 static PyObject *_wrap_Printout_GetPageSizePixels(PyObject *, PyObject *args, PyObject *kwargs) {
24753     PyObject *resultobj;
24754     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24755     int *arg2 = (int *) 0 ;
24756     int *arg3 = (int *) 0 ;
24757     int temp2 ;
24758     int res2 = 0 ;
24759     int temp3 ;
24760     int res3 = 0 ;
24761     PyObject * obj0 = 0 ;
24762     char *kwnames[] = {
24763         (char *) "self", NULL
24764     };
24765
24766     arg2 = &temp2; res2 = SWIG_NEWOBJ;
24767     arg3 = &temp3; res3 = SWIG_NEWOBJ;
24768     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPageSizePixels",kwnames,&obj0)) goto fail;
24769     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24770     if (SWIG_arg_fail(1)) SWIG_fail;
24771     {
24772         PyThreadState* __tstate = wxPyBeginAllowThreads();
24773         (arg1)->GetPageSizePixels(arg2,arg3);
24774
24775         wxPyEndAllowThreads(__tstate);
24776         if (PyErr_Occurred()) SWIG_fail;
24777     }
24778     Py_INCREF(Py_None); resultobj = Py_None;
24779     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
24780     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
24781     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
24782     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
24783     return resultobj;
24784     fail:
24785     return NULL;
24786 }
24787
24788
24789 static PyObject *_wrap_Printout_SetPageSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
24790     PyObject *resultobj;
24791     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24792     int arg2 ;
24793     int arg3 ;
24794     PyObject * obj0 = 0 ;
24795     PyObject * obj1 = 0 ;
24796     PyObject * obj2 = 0 ;
24797     char *kwnames[] = {
24798         (char *) "self",(char *) "w",(char *) "h", NULL
24799     };
24800
24801     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPageSizeMM",kwnames,&obj0,&obj1,&obj2)) goto fail;
24802     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24803     if (SWIG_arg_fail(1)) SWIG_fail;
24804     {
24805         arg2 = (int)(SWIG_As_int(obj1));
24806         if (SWIG_arg_fail(2)) SWIG_fail;
24807     }
24808     {
24809         arg3 = (int)(SWIG_As_int(obj2));
24810         if (SWIG_arg_fail(3)) SWIG_fail;
24811     }
24812     {
24813         PyThreadState* __tstate = wxPyBeginAllowThreads();
24814         (arg1)->SetPageSizeMM(arg2,arg3);
24815
24816         wxPyEndAllowThreads(__tstate);
24817         if (PyErr_Occurred()) SWIG_fail;
24818     }
24819     Py_INCREF(Py_None); resultobj = Py_None;
24820     return resultobj;
24821     fail:
24822     return NULL;
24823 }
24824
24825
24826 static PyObject *_wrap_Printout_GetPageSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
24827     PyObject *resultobj;
24828     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24829     int *arg2 = (int *) 0 ;
24830     int *arg3 = (int *) 0 ;
24831     int temp2 ;
24832     int res2 = 0 ;
24833     int temp3 ;
24834     int res3 = 0 ;
24835     PyObject * obj0 = 0 ;
24836     char *kwnames[] = {
24837         (char *) "self", NULL
24838     };
24839
24840     arg2 = &temp2; res2 = SWIG_NEWOBJ;
24841     arg3 = &temp3; res3 = SWIG_NEWOBJ;
24842     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPageSizeMM",kwnames,&obj0)) goto fail;
24843     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24844     if (SWIG_arg_fail(1)) SWIG_fail;
24845     {
24846         PyThreadState* __tstate = wxPyBeginAllowThreads();
24847         (arg1)->GetPageSizeMM(arg2,arg3);
24848
24849         wxPyEndAllowThreads(__tstate);
24850         if (PyErr_Occurred()) SWIG_fail;
24851     }
24852     Py_INCREF(Py_None); resultobj = Py_None;
24853     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
24854     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
24855     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
24856     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
24857     return resultobj;
24858     fail:
24859     return NULL;
24860 }
24861
24862
24863 static PyObject *_wrap_Printout_SetPPIScreen(PyObject *, PyObject *args, PyObject *kwargs) {
24864     PyObject *resultobj;
24865     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24866     int arg2 ;
24867     int arg3 ;
24868     PyObject * obj0 = 0 ;
24869     PyObject * obj1 = 0 ;
24870     PyObject * obj2 = 0 ;
24871     char *kwnames[] = {
24872         (char *) "self",(char *) "x",(char *) "y", NULL
24873     };
24874
24875     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPPIScreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
24876     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24877     if (SWIG_arg_fail(1)) SWIG_fail;
24878     {
24879         arg2 = (int)(SWIG_As_int(obj1));
24880         if (SWIG_arg_fail(2)) SWIG_fail;
24881     }
24882     {
24883         arg3 = (int)(SWIG_As_int(obj2));
24884         if (SWIG_arg_fail(3)) SWIG_fail;
24885     }
24886     {
24887         PyThreadState* __tstate = wxPyBeginAllowThreads();
24888         (arg1)->SetPPIScreen(arg2,arg3);
24889
24890         wxPyEndAllowThreads(__tstate);
24891         if (PyErr_Occurred()) SWIG_fail;
24892     }
24893     Py_INCREF(Py_None); resultobj = Py_None;
24894     return resultobj;
24895     fail:
24896     return NULL;
24897 }
24898
24899
24900 static PyObject *_wrap_Printout_GetPPIScreen(PyObject *, PyObject *args, PyObject *kwargs) {
24901     PyObject *resultobj;
24902     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24903     int *arg2 = (int *) 0 ;
24904     int *arg3 = (int *) 0 ;
24905     int temp2 ;
24906     int res2 = 0 ;
24907     int temp3 ;
24908     int res3 = 0 ;
24909     PyObject * obj0 = 0 ;
24910     char *kwnames[] = {
24911         (char *) "self", NULL
24912     };
24913
24914     arg2 = &temp2; res2 = SWIG_NEWOBJ;
24915     arg3 = &temp3; res3 = SWIG_NEWOBJ;
24916     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPPIScreen",kwnames,&obj0)) goto fail;
24917     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24918     if (SWIG_arg_fail(1)) SWIG_fail;
24919     {
24920         PyThreadState* __tstate = wxPyBeginAllowThreads();
24921         (arg1)->GetPPIScreen(arg2,arg3);
24922
24923         wxPyEndAllowThreads(__tstate);
24924         if (PyErr_Occurred()) SWIG_fail;
24925     }
24926     Py_INCREF(Py_None); resultobj = Py_None;
24927     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
24928     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
24929     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
24930     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
24931     return resultobj;
24932     fail:
24933     return NULL;
24934 }
24935
24936
24937 static PyObject *_wrap_Printout_SetPPIPrinter(PyObject *, PyObject *args, PyObject *kwargs) {
24938     PyObject *resultobj;
24939     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24940     int arg2 ;
24941     int arg3 ;
24942     PyObject * obj0 = 0 ;
24943     PyObject * obj1 = 0 ;
24944     PyObject * obj2 = 0 ;
24945     char *kwnames[] = {
24946         (char *) "self",(char *) "x",(char *) "y", NULL
24947     };
24948
24949     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetPPIPrinter",kwnames,&obj0,&obj1,&obj2)) goto fail;
24950     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24951     if (SWIG_arg_fail(1)) SWIG_fail;
24952     {
24953         arg2 = (int)(SWIG_As_int(obj1));
24954         if (SWIG_arg_fail(2)) SWIG_fail;
24955     }
24956     {
24957         arg3 = (int)(SWIG_As_int(obj2));
24958         if (SWIG_arg_fail(3)) SWIG_fail;
24959     }
24960     {
24961         PyThreadState* __tstate = wxPyBeginAllowThreads();
24962         (arg1)->SetPPIPrinter(arg2,arg3);
24963
24964         wxPyEndAllowThreads(__tstate);
24965         if (PyErr_Occurred()) SWIG_fail;
24966     }
24967     Py_INCREF(Py_None); resultobj = Py_None;
24968     return resultobj;
24969     fail:
24970     return NULL;
24971 }
24972
24973
24974 static PyObject *_wrap_Printout_GetPPIPrinter(PyObject *, PyObject *args, PyObject *kwargs) {
24975     PyObject *resultobj;
24976     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
24977     int *arg2 = (int *) 0 ;
24978     int *arg3 = (int *) 0 ;
24979     int temp2 ;
24980     int res2 = 0 ;
24981     int temp3 ;
24982     int res3 = 0 ;
24983     PyObject * obj0 = 0 ;
24984     char *kwnames[] = {
24985         (char *) "self", NULL
24986     };
24987
24988     arg2 = &temp2; res2 = SWIG_NEWOBJ;
24989     arg3 = &temp3; res3 = SWIG_NEWOBJ;
24990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_GetPPIPrinter",kwnames,&obj0)) goto fail;
24991     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
24992     if (SWIG_arg_fail(1)) SWIG_fail;
24993     {
24994         PyThreadState* __tstate = wxPyBeginAllowThreads();
24995         (arg1)->GetPPIPrinter(arg2,arg3);
24996
24997         wxPyEndAllowThreads(__tstate);
24998         if (PyErr_Occurred()) SWIG_fail;
24999     }
25000     Py_INCREF(Py_None); resultobj = Py_None;
25001     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25002     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25003     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25004     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25005     return resultobj;
25006     fail:
25007     return NULL;
25008 }
25009
25010
25011 static PyObject *_wrap_Printout_IsPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25012     PyObject *resultobj;
25013     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25014     bool result;
25015     PyObject * obj0 = 0 ;
25016     char *kwnames[] = {
25017         (char *) "self", NULL
25018     };
25019
25020     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_IsPreview",kwnames,&obj0)) goto fail;
25021     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25022     if (SWIG_arg_fail(1)) SWIG_fail;
25023     {
25024         PyThreadState* __tstate = wxPyBeginAllowThreads();
25025         result = (bool)(arg1)->IsPreview();
25026
25027         wxPyEndAllowThreads(__tstate);
25028         if (PyErr_Occurred()) SWIG_fail;
25029     }
25030     {
25031         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25032     }
25033     return resultobj;
25034     fail:
25035     return NULL;
25036 }
25037
25038
25039 static PyObject *_wrap_Printout_SetIsPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25040     PyObject *resultobj;
25041     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25042     bool arg2 ;
25043     PyObject * obj0 = 0 ;
25044     PyObject * obj1 = 0 ;
25045     char *kwnames[] = {
25046         (char *) "self",(char *) "p", NULL
25047     };
25048
25049     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetIsPreview",kwnames,&obj0,&obj1)) goto fail;
25050     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25051     if (SWIG_arg_fail(1)) SWIG_fail;
25052     {
25053         arg2 = (bool)(SWIG_As_bool(obj1));
25054         if (SWIG_arg_fail(2)) SWIG_fail;
25055     }
25056     {
25057         PyThreadState* __tstate = wxPyBeginAllowThreads();
25058         (arg1)->SetIsPreview(arg2);
25059
25060         wxPyEndAllowThreads(__tstate);
25061         if (PyErr_Occurred()) SWIG_fail;
25062     }
25063     Py_INCREF(Py_None); resultobj = Py_None;
25064     return resultobj;
25065     fail:
25066     return NULL;
25067 }
25068
25069
25070 static PyObject *_wrap_Printout_base_OnBeginDocument(PyObject *, PyObject *args, PyObject *kwargs) {
25071     PyObject *resultobj;
25072     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25073     int arg2 ;
25074     int arg3 ;
25075     bool result;
25076     PyObject * obj0 = 0 ;
25077     PyObject * obj1 = 0 ;
25078     PyObject * obj2 = 0 ;
25079     char *kwnames[] = {
25080         (char *) "self",(char *) "startPage",(char *) "endPage", NULL
25081     };
25082
25083     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_base_OnBeginDocument",kwnames,&obj0,&obj1,&obj2)) goto fail;
25084     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25085     if (SWIG_arg_fail(1)) SWIG_fail;
25086     {
25087         arg2 = (int)(SWIG_As_int(obj1));
25088         if (SWIG_arg_fail(2)) SWIG_fail;
25089     }
25090     {
25091         arg3 = (int)(SWIG_As_int(obj2));
25092         if (SWIG_arg_fail(3)) SWIG_fail;
25093     }
25094     {
25095         PyThreadState* __tstate = wxPyBeginAllowThreads();
25096         result = (bool)(arg1)->base_OnBeginDocument(arg2,arg3);
25097
25098         wxPyEndAllowThreads(__tstate);
25099         if (PyErr_Occurred()) SWIG_fail;
25100     }
25101     {
25102         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25103     }
25104     return resultobj;
25105     fail:
25106     return NULL;
25107 }
25108
25109
25110 static PyObject *_wrap_Printout_base_OnEndDocument(PyObject *, PyObject *args, PyObject *kwargs) {
25111     PyObject *resultobj;
25112     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25113     PyObject * obj0 = 0 ;
25114     char *kwnames[] = {
25115         (char *) "self", NULL
25116     };
25117
25118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnEndDocument",kwnames,&obj0)) goto fail;
25119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25120     if (SWIG_arg_fail(1)) SWIG_fail;
25121     {
25122         PyThreadState* __tstate = wxPyBeginAllowThreads();
25123         (arg1)->base_OnEndDocument();
25124
25125         wxPyEndAllowThreads(__tstate);
25126         if (PyErr_Occurred()) SWIG_fail;
25127     }
25128     Py_INCREF(Py_None); resultobj = Py_None;
25129     return resultobj;
25130     fail:
25131     return NULL;
25132 }
25133
25134
25135 static PyObject *_wrap_Printout_base_OnBeginPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25136     PyObject *resultobj;
25137     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25138     PyObject * obj0 = 0 ;
25139     char *kwnames[] = {
25140         (char *) "self", NULL
25141     };
25142
25143     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnBeginPrinting",kwnames,&obj0)) goto fail;
25144     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25145     if (SWIG_arg_fail(1)) SWIG_fail;
25146     {
25147         PyThreadState* __tstate = wxPyBeginAllowThreads();
25148         (arg1)->base_OnBeginPrinting();
25149
25150         wxPyEndAllowThreads(__tstate);
25151         if (PyErr_Occurred()) SWIG_fail;
25152     }
25153     Py_INCREF(Py_None); resultobj = Py_None;
25154     return resultobj;
25155     fail:
25156     return NULL;
25157 }
25158
25159
25160 static PyObject *_wrap_Printout_base_OnEndPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25161     PyObject *resultobj;
25162     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25163     PyObject * obj0 = 0 ;
25164     char *kwnames[] = {
25165         (char *) "self", NULL
25166     };
25167
25168     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnEndPrinting",kwnames,&obj0)) goto fail;
25169     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25170     if (SWIG_arg_fail(1)) SWIG_fail;
25171     {
25172         PyThreadState* __tstate = wxPyBeginAllowThreads();
25173         (arg1)->base_OnEndPrinting();
25174
25175         wxPyEndAllowThreads(__tstate);
25176         if (PyErr_Occurred()) SWIG_fail;
25177     }
25178     Py_INCREF(Py_None); resultobj = Py_None;
25179     return resultobj;
25180     fail:
25181     return NULL;
25182 }
25183
25184
25185 static PyObject *_wrap_Printout_base_OnPreparePrinting(PyObject *, PyObject *args, PyObject *kwargs) {
25186     PyObject *resultobj;
25187     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25188     PyObject * obj0 = 0 ;
25189     char *kwnames[] = {
25190         (char *) "self", NULL
25191     };
25192
25193     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_OnPreparePrinting",kwnames,&obj0)) goto fail;
25194     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25195     if (SWIG_arg_fail(1)) SWIG_fail;
25196     {
25197         PyThreadState* __tstate = wxPyBeginAllowThreads();
25198         (arg1)->base_OnPreparePrinting();
25199
25200         wxPyEndAllowThreads(__tstate);
25201         if (PyErr_Occurred()) SWIG_fail;
25202     }
25203     Py_INCREF(Py_None); resultobj = Py_None;
25204     return resultobj;
25205     fail:
25206     return NULL;
25207 }
25208
25209
25210 static PyObject *_wrap_Printout_base_HasPage(PyObject *, PyObject *args, PyObject *kwargs) {
25211     PyObject *resultobj;
25212     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25213     int arg2 ;
25214     bool result;
25215     PyObject * obj0 = 0 ;
25216     PyObject * obj1 = 0 ;
25217     char *kwnames[] = {
25218         (char *) "self",(char *) "page", NULL
25219     };
25220
25221     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_base_HasPage",kwnames,&obj0,&obj1)) goto fail;
25222     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25223     if (SWIG_arg_fail(1)) SWIG_fail;
25224     {
25225         arg2 = (int)(SWIG_As_int(obj1));
25226         if (SWIG_arg_fail(2)) SWIG_fail;
25227     }
25228     {
25229         PyThreadState* __tstate = wxPyBeginAllowThreads();
25230         result = (bool)(arg1)->base_HasPage(arg2);
25231
25232         wxPyEndAllowThreads(__tstate);
25233         if (PyErr_Occurred()) SWIG_fail;
25234     }
25235     {
25236         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25237     }
25238     return resultobj;
25239     fail:
25240     return NULL;
25241 }
25242
25243
25244 static PyObject *_wrap_Printout_base_GetPageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
25245     PyObject *resultobj;
25246     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25247     int *arg2 = (int *) 0 ;
25248     int *arg3 = (int *) 0 ;
25249     int *arg4 = (int *) 0 ;
25250     int *arg5 = (int *) 0 ;
25251     int temp2 ;
25252     int res2 = 0 ;
25253     int temp3 ;
25254     int res3 = 0 ;
25255     int temp4 ;
25256     int res4 = 0 ;
25257     int temp5 ;
25258     int res5 = 0 ;
25259     PyObject * obj0 = 0 ;
25260     char *kwnames[] = {
25261         (char *) "self", NULL
25262     };
25263
25264     arg2 = &temp2; res2 = SWIG_NEWOBJ;
25265     arg3 = &temp3; res3 = SWIG_NEWOBJ;
25266     arg4 = &temp4; res4 = SWIG_NEWOBJ;
25267     arg5 = &temp5; res5 = SWIG_NEWOBJ;
25268     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Printout_base_GetPageInfo",kwnames,&obj0)) goto fail;
25269     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25270     if (SWIG_arg_fail(1)) SWIG_fail;
25271     {
25272         PyThreadState* __tstate = wxPyBeginAllowThreads();
25273         (arg1)->base_GetPageInfo(arg2,arg3,arg4,arg5);
25274
25275         wxPyEndAllowThreads(__tstate);
25276         if (PyErr_Occurred()) SWIG_fail;
25277     }
25278     Py_INCREF(Py_None); resultobj = Py_None;
25279     resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25280     SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25281     resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25282     SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25283     resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
25284     SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
25285     resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
25286     SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
25287     return resultobj;
25288     fail:
25289     return NULL;
25290 }
25291
25292
25293 static PyObject * Printout_swigregister(PyObject *, PyObject *args) {
25294     PyObject *obj;
25295     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25296     SWIG_TypeClientData(SWIGTYPE_p_wxPyPrintout, obj);
25297     Py_INCREF(obj);
25298     return Py_BuildValue((char *)"");
25299 }
25300 static PyObject *_wrap_new_PreviewCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
25301     PyObject *resultobj;
25302     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25303     wxWindow *arg2 = (wxWindow *) 0 ;
25304     wxPoint const &arg3_defvalue = wxDefaultPosition ;
25305     wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25306     wxSize const &arg4_defvalue = wxDefaultSize ;
25307     wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25308     long arg5 = (long) 0 ;
25309     wxString const &arg6_defvalue = wxPyPreviewCanvasNameStr ;
25310     wxString *arg6 = (wxString *) &arg6_defvalue ;
25311     wxPreviewCanvas *result;
25312     wxPoint temp3 ;
25313     wxSize temp4 ;
25314     bool temp6 = false ;
25315     PyObject * obj0 = 0 ;
25316     PyObject * obj1 = 0 ;
25317     PyObject * obj2 = 0 ;
25318     PyObject * obj3 = 0 ;
25319     PyObject * obj4 = 0 ;
25320     PyObject * obj5 = 0 ;
25321     char *kwnames[] = {
25322         (char *) "preview",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25323     };
25324
25325     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_PreviewCanvas",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25326     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25327     if (SWIG_arg_fail(1)) SWIG_fail;
25328     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25329     if (SWIG_arg_fail(2)) SWIG_fail;
25330     if (obj2) {
25331         {
25332             arg3 = &temp3;
25333             if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25334         }
25335     }
25336     if (obj3) {
25337         {
25338             arg4 = &temp4;
25339             if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25340         }
25341     }
25342     if (obj4) {
25343         {
25344             arg5 = (long)(SWIG_As_long(obj4));
25345             if (SWIG_arg_fail(5)) SWIG_fail;
25346         }
25347     }
25348     if (obj5) {
25349         {
25350             arg6 = wxString_in_helper(obj5);
25351             if (arg6 == NULL) SWIG_fail;
25352             temp6 = true;
25353         }
25354     }
25355     {
25356         if (!wxPyCheckForApp()) SWIG_fail;
25357         PyThreadState* __tstate = wxPyBeginAllowThreads();
25358         result = (wxPreviewCanvas *)new wxPreviewCanvas(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25359
25360         wxPyEndAllowThreads(__tstate);
25361         if (PyErr_Occurred()) SWIG_fail;
25362     }
25363     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewCanvas, 1);
25364     {
25365         if (temp6)
25366         delete arg6;
25367     }
25368     return resultobj;
25369     fail:
25370     {
25371         if (temp6)
25372         delete arg6;
25373     }
25374     return NULL;
25375 }
25376
25377
25378 static PyObject * PreviewCanvas_swigregister(PyObject *, PyObject *args) {
25379     PyObject *obj;
25380     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25381     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewCanvas, obj);
25382     Py_INCREF(obj);
25383     return Py_BuildValue((char *)"");
25384 }
25385 static PyObject *_wrap_new_PreviewFrame(PyObject *, PyObject *args, PyObject *kwargs) {
25386     PyObject *resultobj;
25387     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25388     wxFrame *arg2 = (wxFrame *) 0 ;
25389     wxString *arg3 = 0 ;
25390     wxPoint const &arg4_defvalue = wxDefaultPosition ;
25391     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25392     wxSize const &arg5_defvalue = wxDefaultSize ;
25393     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25394     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
25395     wxString const &arg7_defvalue = wxPyFrameNameStr ;
25396     wxString *arg7 = (wxString *) &arg7_defvalue ;
25397     wxPreviewFrame *result;
25398     bool temp3 = false ;
25399     wxPoint temp4 ;
25400     wxSize temp5 ;
25401     bool temp7 = false ;
25402     PyObject * obj0 = 0 ;
25403     PyObject * obj1 = 0 ;
25404     PyObject * obj2 = 0 ;
25405     PyObject * obj3 = 0 ;
25406     PyObject * obj4 = 0 ;
25407     PyObject * obj5 = 0 ;
25408     PyObject * obj6 = 0 ;
25409     char *kwnames[] = {
25410         (char *) "preview",(char *) "parent",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25411     };
25412
25413     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PreviewFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25414     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25415     if (SWIG_arg_fail(1)) SWIG_fail;
25416     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
25417     if (SWIG_arg_fail(2)) SWIG_fail;
25418     {
25419         arg3 = wxString_in_helper(obj2);
25420         if (arg3 == NULL) SWIG_fail;
25421         temp3 = true;
25422     }
25423     if (obj3) {
25424         {
25425             arg4 = &temp4;
25426             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25427         }
25428     }
25429     if (obj4) {
25430         {
25431             arg5 = &temp5;
25432             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25433         }
25434     }
25435     if (obj5) {
25436         {
25437             arg6 = (long)(SWIG_As_long(obj5));
25438             if (SWIG_arg_fail(6)) SWIG_fail;
25439         }
25440     }
25441     if (obj6) {
25442         {
25443             arg7 = wxString_in_helper(obj6);
25444             if (arg7 == NULL) SWIG_fail;
25445             temp7 = true;
25446         }
25447     }
25448     {
25449         if (!wxPyCheckForApp()) SWIG_fail;
25450         PyThreadState* __tstate = wxPyBeginAllowThreads();
25451         result = (wxPreviewFrame *)new wxPreviewFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25452
25453         wxPyEndAllowThreads(__tstate);
25454         if (PyErr_Occurred()) SWIG_fail;
25455     }
25456     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewFrame, 1);
25457     {
25458         if (temp3)
25459         delete arg3;
25460     }
25461     {
25462         if (temp7)
25463         delete arg7;
25464     }
25465     return resultobj;
25466     fail:
25467     {
25468         if (temp3)
25469         delete arg3;
25470     }
25471     {
25472         if (temp7)
25473         delete arg7;
25474     }
25475     return NULL;
25476 }
25477
25478
25479 static PyObject *_wrap_PreviewFrame_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
25480     PyObject *resultobj;
25481     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25482     PyObject * obj0 = 0 ;
25483     char *kwnames[] = {
25484         (char *) "self", NULL
25485     };
25486
25487     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_Initialize",kwnames,&obj0)) goto fail;
25488     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25489     if (SWIG_arg_fail(1)) SWIG_fail;
25490     {
25491         PyThreadState* __tstate = wxPyBeginAllowThreads();
25492         (arg1)->Initialize();
25493
25494         wxPyEndAllowThreads(__tstate);
25495         if (PyErr_Occurred()) SWIG_fail;
25496     }
25497     Py_INCREF(Py_None); resultobj = Py_None;
25498     return resultobj;
25499     fail:
25500     return NULL;
25501 }
25502
25503
25504 static PyObject *_wrap_PreviewFrame_CreateControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25505     PyObject *resultobj;
25506     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25507     PyObject * obj0 = 0 ;
25508     char *kwnames[] = {
25509         (char *) "self", NULL
25510     };
25511
25512     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_CreateControlBar",kwnames,&obj0)) goto fail;
25513     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25514     if (SWIG_arg_fail(1)) SWIG_fail;
25515     {
25516         PyThreadState* __tstate = wxPyBeginAllowThreads();
25517         (arg1)->CreateControlBar();
25518
25519         wxPyEndAllowThreads(__tstate);
25520         if (PyErr_Occurred()) SWIG_fail;
25521     }
25522     Py_INCREF(Py_None); resultobj = Py_None;
25523     return resultobj;
25524     fail:
25525     return NULL;
25526 }
25527
25528
25529 static PyObject *_wrap_PreviewFrame_CreateCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
25530     PyObject *resultobj;
25531     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25532     PyObject * obj0 = 0 ;
25533     char *kwnames[] = {
25534         (char *) "self", NULL
25535     };
25536
25537     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_CreateCanvas",kwnames,&obj0)) goto fail;
25538     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25539     if (SWIG_arg_fail(1)) SWIG_fail;
25540     {
25541         PyThreadState* __tstate = wxPyBeginAllowThreads();
25542         (arg1)->CreateCanvas();
25543
25544         wxPyEndAllowThreads(__tstate);
25545         if (PyErr_Occurred()) SWIG_fail;
25546     }
25547     Py_INCREF(Py_None); resultobj = Py_None;
25548     return resultobj;
25549     fail:
25550     return NULL;
25551 }
25552
25553
25554 static PyObject *_wrap_PreviewFrame_GetControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25555     PyObject *resultobj;
25556     wxPreviewFrame *arg1 = (wxPreviewFrame *) 0 ;
25557     wxPreviewControlBar *result;
25558     PyObject * obj0 = 0 ;
25559     char *kwnames[] = {
25560         (char *) "self", NULL
25561     };
25562
25563     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewFrame_GetControlBar",kwnames,&obj0)) goto fail;
25564     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
25565     if (SWIG_arg_fail(1)) SWIG_fail;
25566     {
25567         PyThreadState* __tstate = wxPyBeginAllowThreads();
25568         result = (wxPreviewControlBar *)((wxPreviewFrame const *)arg1)->GetControlBar();
25569
25570         wxPyEndAllowThreads(__tstate);
25571         if (PyErr_Occurred()) SWIG_fail;
25572     }
25573     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewControlBar, 0);
25574     return resultobj;
25575     fail:
25576     return NULL;
25577 }
25578
25579
25580 static PyObject * PreviewFrame_swigregister(PyObject *, PyObject *args) {
25581     PyObject *obj;
25582     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25583     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewFrame, obj);
25584     Py_INCREF(obj);
25585     return Py_BuildValue((char *)"");
25586 }
25587 static PyObject *_wrap_new_PreviewControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
25588     PyObject *resultobj;
25589     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
25590     long arg2 ;
25591     wxWindow *arg3 = (wxWindow *) 0 ;
25592     wxPoint const &arg4_defvalue = wxDefaultPosition ;
25593     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25594     wxSize const &arg5_defvalue = wxDefaultSize ;
25595     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25596     long arg6 = (long) wxTAB_TRAVERSAL ;
25597     wxString const &arg7_defvalue = wxPyPanelNameStr ;
25598     wxString *arg7 = (wxString *) &arg7_defvalue ;
25599     wxPreviewControlBar *result;
25600     wxPoint temp4 ;
25601     wxSize temp5 ;
25602     bool temp7 = false ;
25603     PyObject * obj0 = 0 ;
25604     PyObject * obj1 = 0 ;
25605     PyObject * obj2 = 0 ;
25606     PyObject * obj3 = 0 ;
25607     PyObject * obj4 = 0 ;
25608     PyObject * obj5 = 0 ;
25609     PyObject * obj6 = 0 ;
25610     char *kwnames[] = {
25611         (char *) "preview",(char *) "buttons",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25612     };
25613
25614     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PreviewControlBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25615     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
25616     if (SWIG_arg_fail(1)) SWIG_fail;
25617     {
25618         arg2 = (long)(SWIG_As_long(obj1));
25619         if (SWIG_arg_fail(2)) SWIG_fail;
25620     }
25621     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25622     if (SWIG_arg_fail(3)) SWIG_fail;
25623     if (obj3) {
25624         {
25625             arg4 = &temp4;
25626             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25627         }
25628     }
25629     if (obj4) {
25630         {
25631             arg5 = &temp5;
25632             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25633         }
25634     }
25635     if (obj5) {
25636         {
25637             arg6 = (long)(SWIG_As_long(obj5));
25638             if (SWIG_arg_fail(6)) SWIG_fail;
25639         }
25640     }
25641     if (obj6) {
25642         {
25643             arg7 = wxString_in_helper(obj6);
25644             if (arg7 == NULL) SWIG_fail;
25645             temp7 = true;
25646         }
25647     }
25648     {
25649         if (!wxPyCheckForApp()) SWIG_fail;
25650         PyThreadState* __tstate = wxPyBeginAllowThreads();
25651         result = (wxPreviewControlBar *)new wxPreviewControlBar(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25652
25653         wxPyEndAllowThreads(__tstate);
25654         if (PyErr_Occurred()) SWIG_fail;
25655     }
25656     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewControlBar, 1);
25657     {
25658         if (temp7)
25659         delete arg7;
25660     }
25661     return resultobj;
25662     fail:
25663     {
25664         if (temp7)
25665         delete arg7;
25666     }
25667     return NULL;
25668 }
25669
25670
25671 static PyObject *_wrap_PreviewControlBar_GetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
25672     PyObject *resultobj;
25673     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25674     int result;
25675     PyObject * obj0 = 0 ;
25676     char *kwnames[] = {
25677         (char *) "self", NULL
25678     };
25679
25680     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_GetZoomControl",kwnames,&obj0)) goto fail;
25681     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25682     if (SWIG_arg_fail(1)) SWIG_fail;
25683     {
25684         PyThreadState* __tstate = wxPyBeginAllowThreads();
25685         result = (int)(arg1)->GetZoomControl();
25686
25687         wxPyEndAllowThreads(__tstate);
25688         if (PyErr_Occurred()) SWIG_fail;
25689     }
25690     {
25691         resultobj = SWIG_From_int((int)(result));
25692     }
25693     return resultobj;
25694     fail:
25695     return NULL;
25696 }
25697
25698
25699 static PyObject *_wrap_PreviewControlBar_SetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
25700     PyObject *resultobj;
25701     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25702     int arg2 ;
25703     PyObject * obj0 = 0 ;
25704     PyObject * obj1 = 0 ;
25705     char *kwnames[] = {
25706         (char *) "self",(char *) "zoom", NULL
25707     };
25708
25709     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PreviewControlBar_SetZoomControl",kwnames,&obj0,&obj1)) goto fail;
25710     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25711     if (SWIG_arg_fail(1)) SWIG_fail;
25712     {
25713         arg2 = (int)(SWIG_As_int(obj1));
25714         if (SWIG_arg_fail(2)) SWIG_fail;
25715     }
25716     {
25717         PyThreadState* __tstate = wxPyBeginAllowThreads();
25718         (arg1)->SetZoomControl(arg2);
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_PreviewControlBar_GetPrintPreview(PyObject *, PyObject *args, PyObject *kwargs) {
25731     PyObject *resultobj;
25732     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25733     wxPrintPreview *result;
25734     PyObject * obj0 = 0 ;
25735     char *kwnames[] = {
25736         (char *) "self", NULL
25737     };
25738
25739     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_GetPrintPreview",kwnames,&obj0)) goto fail;
25740     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25741     if (SWIG_arg_fail(1)) SWIG_fail;
25742     {
25743         PyThreadState* __tstate = wxPyBeginAllowThreads();
25744         result = (wxPrintPreview *)(arg1)->GetPrintPreview();
25745
25746         wxPyEndAllowThreads(__tstate);
25747         if (PyErr_Occurred()) SWIG_fail;
25748     }
25749     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 0);
25750     return resultobj;
25751     fail:
25752     return NULL;
25753 }
25754
25755
25756 static PyObject *_wrap_PreviewControlBar_OnNext(PyObject *, PyObject *args, PyObject *kwargs) {
25757     PyObject *resultobj;
25758     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25759     PyObject * obj0 = 0 ;
25760     char *kwnames[] = {
25761         (char *) "self", NULL
25762     };
25763
25764     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnNext",kwnames,&obj0)) goto fail;
25765     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25766     if (SWIG_arg_fail(1)) SWIG_fail;
25767     {
25768         PyThreadState* __tstate = wxPyBeginAllowThreads();
25769         (arg1)->OnNext();
25770
25771         wxPyEndAllowThreads(__tstate);
25772         if (PyErr_Occurred()) SWIG_fail;
25773     }
25774     Py_INCREF(Py_None); resultobj = Py_None;
25775     return resultobj;
25776     fail:
25777     return NULL;
25778 }
25779
25780
25781 static PyObject *_wrap_PreviewControlBar_OnPrevious(PyObject *, PyObject *args, PyObject *kwargs) {
25782     PyObject *resultobj;
25783     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25784     PyObject * obj0 = 0 ;
25785     char *kwnames[] = {
25786         (char *) "self", NULL
25787     };
25788
25789     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnPrevious",kwnames,&obj0)) goto fail;
25790     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25791     if (SWIG_arg_fail(1)) SWIG_fail;
25792     {
25793         PyThreadState* __tstate = wxPyBeginAllowThreads();
25794         (arg1)->OnPrevious();
25795
25796         wxPyEndAllowThreads(__tstate);
25797         if (PyErr_Occurred()) SWIG_fail;
25798     }
25799     Py_INCREF(Py_None); resultobj = Py_None;
25800     return resultobj;
25801     fail:
25802     return NULL;
25803 }
25804
25805
25806 static PyObject *_wrap_PreviewControlBar_OnFirst(PyObject *, PyObject *args, PyObject *kwargs) {
25807     PyObject *resultobj;
25808     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25809     PyObject * obj0 = 0 ;
25810     char *kwnames[] = {
25811         (char *) "self", NULL
25812     };
25813
25814     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnFirst",kwnames,&obj0)) goto fail;
25815     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25816     if (SWIG_arg_fail(1)) SWIG_fail;
25817     {
25818         PyThreadState* __tstate = wxPyBeginAllowThreads();
25819         (arg1)->OnFirst();
25820
25821         wxPyEndAllowThreads(__tstate);
25822         if (PyErr_Occurred()) SWIG_fail;
25823     }
25824     Py_INCREF(Py_None); resultobj = Py_None;
25825     return resultobj;
25826     fail:
25827     return NULL;
25828 }
25829
25830
25831 static PyObject *_wrap_PreviewControlBar_OnLast(PyObject *, PyObject *args, PyObject *kwargs) {
25832     PyObject *resultobj;
25833     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25834     PyObject * obj0 = 0 ;
25835     char *kwnames[] = {
25836         (char *) "self", NULL
25837     };
25838
25839     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnLast",kwnames,&obj0)) goto fail;
25840     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25841     if (SWIG_arg_fail(1)) SWIG_fail;
25842     {
25843         PyThreadState* __tstate = wxPyBeginAllowThreads();
25844         (arg1)->OnLast();
25845
25846         wxPyEndAllowThreads(__tstate);
25847         if (PyErr_Occurred()) SWIG_fail;
25848     }
25849     Py_INCREF(Py_None); resultobj = Py_None;
25850     return resultobj;
25851     fail:
25852     return NULL;
25853 }
25854
25855
25856 static PyObject *_wrap_PreviewControlBar_OnGoto(PyObject *, PyObject *args, PyObject *kwargs) {
25857     PyObject *resultobj;
25858     wxPreviewControlBar *arg1 = (wxPreviewControlBar *) 0 ;
25859     PyObject * obj0 = 0 ;
25860     char *kwnames[] = {
25861         (char *) "self", NULL
25862     };
25863
25864     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PreviewControlBar_OnGoto",kwnames,&obj0)) goto fail;
25865     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
25866     if (SWIG_arg_fail(1)) SWIG_fail;
25867     {
25868         PyThreadState* __tstate = wxPyBeginAllowThreads();
25869         (arg1)->OnGoto();
25870
25871         wxPyEndAllowThreads(__tstate);
25872         if (PyErr_Occurred()) SWIG_fail;
25873     }
25874     Py_INCREF(Py_None); resultobj = Py_None;
25875     return resultobj;
25876     fail:
25877     return NULL;
25878 }
25879
25880
25881 static PyObject * PreviewControlBar_swigregister(PyObject *, PyObject *args) {
25882     PyObject *obj;
25883     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25884     SWIG_TypeClientData(SWIGTYPE_p_wxPreviewControlBar, obj);
25885     Py_INCREF(obj);
25886     return Py_BuildValue((char *)"");
25887 }
25888 static PyObject *_wrap_new_PrintPreview__SWIG_0(PyObject *, PyObject *args) {
25889     PyObject *resultobj;
25890     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25891     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
25892     wxPrintDialogData *arg3 = (wxPrintDialogData *) NULL ;
25893     wxPrintPreview *result;
25894     PyObject * obj0 = 0 ;
25895     PyObject * obj1 = 0 ;
25896     PyObject * obj2 = 0 ;
25897
25898     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_PrintPreview",&obj0,&obj1,&obj2)) goto fail;
25899     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25900     if (SWIG_arg_fail(1)) SWIG_fail;
25901     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25902     if (SWIG_arg_fail(2)) SWIG_fail;
25903     if (obj2) {
25904         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
25905         if (SWIG_arg_fail(3)) SWIG_fail;
25906     }
25907     {
25908         if (!wxPyCheckForApp()) SWIG_fail;
25909         PyThreadState* __tstate = wxPyBeginAllowThreads();
25910         result = (wxPrintPreview *)new wxPrintPreview(arg1,arg2,arg3);
25911
25912         wxPyEndAllowThreads(__tstate);
25913         if (PyErr_Occurred()) SWIG_fail;
25914     }
25915     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 1);
25916     return resultobj;
25917     fail:
25918     return NULL;
25919 }
25920
25921
25922 static PyObject *_wrap_new_PrintPreview__SWIG_1(PyObject *, PyObject *args) {
25923     PyObject *resultobj;
25924     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
25925     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
25926     wxPrintData *arg3 = (wxPrintData *) 0 ;
25927     wxPrintPreview *result;
25928     PyObject * obj0 = 0 ;
25929     PyObject * obj1 = 0 ;
25930     PyObject * obj2 = 0 ;
25931
25932     if(!PyArg_ParseTuple(args,(char *)"OOO:new_PrintPreview",&obj0,&obj1,&obj2)) goto fail;
25933     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25934     if (SWIG_arg_fail(1)) SWIG_fail;
25935     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
25936     if (SWIG_arg_fail(2)) SWIG_fail;
25937     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
25938     if (SWIG_arg_fail(3)) SWIG_fail;
25939     {
25940         if (!wxPyCheckForApp()) SWIG_fail;
25941         PyThreadState* __tstate = wxPyBeginAllowThreads();
25942         result = (wxPrintPreview *)new wxPrintPreview(arg1,arg2,arg3);
25943
25944         wxPyEndAllowThreads(__tstate);
25945         if (PyErr_Occurred()) SWIG_fail;
25946     }
25947     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintPreview, 1);
25948     return resultobj;
25949     fail:
25950     return NULL;
25951 }
25952
25953
25954 static PyObject *_wrap_new_PrintPreview(PyObject *self, PyObject *args) {
25955     int argc;
25956     PyObject *argv[4];
25957     int ii;
25958
25959     argc = PyObject_Length(args);
25960     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
25961         argv[ii] = PyTuple_GetItem(args,ii);
25962     }
25963     if ((argc >= 2) && (argc <= 3)) {
25964         int _v;
25965         {
25966             void *ptr;
25967             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
25968                 _v = 0;
25969                 PyErr_Clear();
25970             } else {
25971                 _v = 1;
25972             }
25973         }
25974         if (_v) {
25975             {
25976                 void *ptr;
25977                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
25978                     _v = 0;
25979                     PyErr_Clear();
25980                 } else {
25981                     _v = 1;
25982                 }
25983             }
25984             if (_v) {
25985                 if (argc <= 2) {
25986                     return _wrap_new_PrintPreview__SWIG_0(self,args);
25987                 }
25988                 {
25989                     void *ptr;
25990                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
25991                         _v = 0;
25992                         PyErr_Clear();
25993                     } else {
25994                         _v = 1;
25995                     }
25996                 }
25997                 if (_v) {
25998                     return _wrap_new_PrintPreview__SWIG_0(self,args);
25999                 }
26000             }
26001         }
26002     }
26003     if (argc == 3) {
26004         int _v;
26005         {
26006             void *ptr;
26007             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26008                 _v = 0;
26009                 PyErr_Clear();
26010             } else {
26011                 _v = 1;
26012             }
26013         }
26014         if (_v) {
26015             {
26016                 void *ptr;
26017                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26018                     _v = 0;
26019                     PyErr_Clear();
26020                 } else {
26021                     _v = 1;
26022                 }
26023             }
26024             if (_v) {
26025                 {
26026                     void *ptr;
26027                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
26028                         _v = 0;
26029                         PyErr_Clear();
26030                     } else {
26031                         _v = 1;
26032                     }
26033                 }
26034                 if (_v) {
26035                     return _wrap_new_PrintPreview__SWIG_1(self,args);
26036                 }
26037             }
26038         }
26039     }
26040
26041     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PrintPreview'");
26042     return NULL;
26043 }
26044
26045
26046 static PyObject *_wrap_PrintPreview_SetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26047     PyObject *resultobj;
26048     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26049     int arg2 ;
26050     bool result;
26051     PyObject * obj0 = 0 ;
26052     PyObject * obj1 = 0 ;
26053     char *kwnames[] = {
26054         (char *) "self",(char *) "pageNum", NULL
26055     };
26056
26057     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetCurrentPage",kwnames,&obj0,&obj1)) goto fail;
26058     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26059     if (SWIG_arg_fail(1)) SWIG_fail;
26060     {
26061         arg2 = (int)(SWIG_As_int(obj1));
26062         if (SWIG_arg_fail(2)) SWIG_fail;
26063     }
26064     {
26065         PyThreadState* __tstate = wxPyBeginAllowThreads();
26066         result = (bool)(arg1)->SetCurrentPage(arg2);
26067
26068         wxPyEndAllowThreads(__tstate);
26069         if (PyErr_Occurred()) SWIG_fail;
26070     }
26071     {
26072         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26073     }
26074     return resultobj;
26075     fail:
26076     return NULL;
26077 }
26078
26079
26080 static PyObject *_wrap_PrintPreview_GetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26081     PyObject *resultobj;
26082     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26083     int result;
26084     PyObject * obj0 = 0 ;
26085     char *kwnames[] = {
26086         (char *) "self", NULL
26087     };
26088
26089     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetCurrentPage",kwnames,&obj0)) goto fail;
26090     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26091     if (SWIG_arg_fail(1)) SWIG_fail;
26092     {
26093         PyThreadState* __tstate = wxPyBeginAllowThreads();
26094         result = (int)(arg1)->GetCurrentPage();
26095
26096         wxPyEndAllowThreads(__tstate);
26097         if (PyErr_Occurred()) SWIG_fail;
26098     }
26099     {
26100         resultobj = SWIG_From_int((int)(result));
26101     }
26102     return resultobj;
26103     fail:
26104     return NULL;
26105 }
26106
26107
26108 static PyObject *_wrap_PrintPreview_SetPrintout(PyObject *, PyObject *args, PyObject *kwargs) {
26109     PyObject *resultobj;
26110     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26111     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26112     PyObject * obj0 = 0 ;
26113     PyObject * obj1 = 0 ;
26114     char *kwnames[] = {
26115         (char *) "self",(char *) "printout", NULL
26116     };
26117
26118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetPrintout",kwnames,&obj0,&obj1)) goto fail;
26119     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26120     if (SWIG_arg_fail(1)) SWIG_fail;
26121     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26122     if (SWIG_arg_fail(2)) SWIG_fail;
26123     {
26124         PyThreadState* __tstate = wxPyBeginAllowThreads();
26125         (arg1)->SetPrintout(arg2);
26126
26127         wxPyEndAllowThreads(__tstate);
26128         if (PyErr_Occurred()) SWIG_fail;
26129     }
26130     Py_INCREF(Py_None); resultobj = Py_None;
26131     return resultobj;
26132     fail:
26133     return NULL;
26134 }
26135
26136
26137 static PyObject *_wrap_PrintPreview_GetPrintout(PyObject *, PyObject *args, PyObject *kwargs) {
26138     PyObject *resultobj;
26139     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26140     wxPyPrintout *result;
26141     PyObject * obj0 = 0 ;
26142     char *kwnames[] = {
26143         (char *) "self", NULL
26144     };
26145
26146     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintout",kwnames,&obj0)) goto fail;
26147     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26148     if (SWIG_arg_fail(1)) SWIG_fail;
26149     {
26150         PyThreadState* __tstate = wxPyBeginAllowThreads();
26151         result = (wxPyPrintout *)(arg1)->GetPrintout();
26152
26153         wxPyEndAllowThreads(__tstate);
26154         if (PyErr_Occurred()) SWIG_fail;
26155     }
26156     {
26157         resultobj = wxPyMake_wxObject(result, 0);
26158     }
26159     return resultobj;
26160     fail:
26161     return NULL;
26162 }
26163
26164
26165 static PyObject *_wrap_PrintPreview_GetPrintoutForPrinting(PyObject *, PyObject *args, PyObject *kwargs) {
26166     PyObject *resultobj;
26167     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26168     wxPyPrintout *result;
26169     PyObject * obj0 = 0 ;
26170     char *kwnames[] = {
26171         (char *) "self", NULL
26172     };
26173
26174     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintoutForPrinting",kwnames,&obj0)) goto fail;
26175     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26176     if (SWIG_arg_fail(1)) SWIG_fail;
26177     {
26178         PyThreadState* __tstate = wxPyBeginAllowThreads();
26179         result = (wxPyPrintout *)(arg1)->GetPrintoutForPrinting();
26180
26181         wxPyEndAllowThreads(__tstate);
26182         if (PyErr_Occurred()) SWIG_fail;
26183     }
26184     {
26185         resultobj = wxPyMake_wxObject(result, 0);
26186     }
26187     return resultobj;
26188     fail:
26189     return NULL;
26190 }
26191
26192
26193 static PyObject *_wrap_PrintPreview_SetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
26194     PyObject *resultobj;
26195     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26196     wxFrame *arg2 = (wxFrame *) 0 ;
26197     PyObject * obj0 = 0 ;
26198     PyObject * obj1 = 0 ;
26199     char *kwnames[] = {
26200         (char *) "self",(char *) "frame", NULL
26201     };
26202
26203     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetFrame",kwnames,&obj0,&obj1)) goto fail;
26204     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26205     if (SWIG_arg_fail(1)) SWIG_fail;
26206     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
26207     if (SWIG_arg_fail(2)) SWIG_fail;
26208     {
26209         PyThreadState* __tstate = wxPyBeginAllowThreads();
26210         (arg1)->SetFrame(arg2);
26211
26212         wxPyEndAllowThreads(__tstate);
26213         if (PyErr_Occurred()) SWIG_fail;
26214     }
26215     Py_INCREF(Py_None); resultobj = Py_None;
26216     return resultobj;
26217     fail:
26218     return NULL;
26219 }
26220
26221
26222 static PyObject *_wrap_PrintPreview_SetCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
26223     PyObject *resultobj;
26224     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26225     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26226     PyObject * obj0 = 0 ;
26227     PyObject * obj1 = 0 ;
26228     char *kwnames[] = {
26229         (char *) "self",(char *) "canvas", NULL
26230     };
26231
26232     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetCanvas",kwnames,&obj0,&obj1)) goto fail;
26233     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26234     if (SWIG_arg_fail(1)) SWIG_fail;
26235     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26236     if (SWIG_arg_fail(2)) SWIG_fail;
26237     {
26238         PyThreadState* __tstate = wxPyBeginAllowThreads();
26239         (arg1)->SetCanvas(arg2);
26240
26241         wxPyEndAllowThreads(__tstate);
26242         if (PyErr_Occurred()) SWIG_fail;
26243     }
26244     Py_INCREF(Py_None); resultobj = Py_None;
26245     return resultobj;
26246     fail:
26247     return NULL;
26248 }
26249
26250
26251 static PyObject *_wrap_PrintPreview_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
26252     PyObject *resultobj;
26253     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26254     wxFrame *result;
26255     PyObject * obj0 = 0 ;
26256     char *kwnames[] = {
26257         (char *) "self", NULL
26258     };
26259
26260     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetFrame",kwnames,&obj0)) goto fail;
26261     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26262     if (SWIG_arg_fail(1)) SWIG_fail;
26263     {
26264         PyThreadState* __tstate = wxPyBeginAllowThreads();
26265         result = (wxFrame *)(arg1)->GetFrame();
26266
26267         wxPyEndAllowThreads(__tstate);
26268         if (PyErr_Occurred()) SWIG_fail;
26269     }
26270     {
26271         resultobj = wxPyMake_wxObject(result, 0);
26272     }
26273     return resultobj;
26274     fail:
26275     return NULL;
26276 }
26277
26278
26279 static PyObject *_wrap_PrintPreview_GetCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
26280     PyObject *resultobj;
26281     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26282     wxPreviewCanvas *result;
26283     PyObject * obj0 = 0 ;
26284     char *kwnames[] = {
26285         (char *) "self", NULL
26286     };
26287
26288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetCanvas",kwnames,&obj0)) goto fail;
26289     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26290     if (SWIG_arg_fail(1)) SWIG_fail;
26291     {
26292         PyThreadState* __tstate = wxPyBeginAllowThreads();
26293         result = (wxPreviewCanvas *)(arg1)->GetCanvas();
26294
26295         wxPyEndAllowThreads(__tstate);
26296         if (PyErr_Occurred()) SWIG_fail;
26297     }
26298     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPreviewCanvas, 0);
26299     return resultobj;
26300     fail:
26301     return NULL;
26302 }
26303
26304
26305 static PyObject *_wrap_PrintPreview_PaintPage(PyObject *, PyObject *args, PyObject *kwargs) {
26306     PyObject *resultobj;
26307     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26308     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26309     wxDC *arg3 = 0 ;
26310     bool result;
26311     PyObject * obj0 = 0 ;
26312     PyObject * obj1 = 0 ;
26313     PyObject * obj2 = 0 ;
26314     char *kwnames[] = {
26315         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26316     };
26317
26318     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintPreview_PaintPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26319     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26320     if (SWIG_arg_fail(1)) SWIG_fail;
26321     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26322     if (SWIG_arg_fail(2)) SWIG_fail;
26323     {
26324         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26325         if (SWIG_arg_fail(3)) SWIG_fail;
26326         if (arg3 == NULL) {
26327             SWIG_null_ref("wxDC");
26328         }
26329         if (SWIG_arg_fail(3)) SWIG_fail;
26330     }
26331     {
26332         PyThreadState* __tstate = wxPyBeginAllowThreads();
26333         result = (bool)(arg1)->PaintPage(arg2,*arg3);
26334
26335         wxPyEndAllowThreads(__tstate);
26336         if (PyErr_Occurred()) SWIG_fail;
26337     }
26338     {
26339         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26340     }
26341     return resultobj;
26342     fail:
26343     return NULL;
26344 }
26345
26346
26347 static PyObject *_wrap_PrintPreview_DrawBlankPage(PyObject *, PyObject *args, PyObject *kwargs) {
26348     PyObject *resultobj;
26349     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26350     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26351     wxDC *arg3 = 0 ;
26352     bool result;
26353     PyObject * obj0 = 0 ;
26354     PyObject * obj1 = 0 ;
26355     PyObject * obj2 = 0 ;
26356     char *kwnames[] = {
26357         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26358     };
26359
26360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PrintPreview_DrawBlankPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26361     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26362     if (SWIG_arg_fail(1)) SWIG_fail;
26363     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26364     if (SWIG_arg_fail(2)) SWIG_fail;
26365     {
26366         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26367         if (SWIG_arg_fail(3)) SWIG_fail;
26368         if (arg3 == NULL) {
26369             SWIG_null_ref("wxDC");
26370         }
26371         if (SWIG_arg_fail(3)) SWIG_fail;
26372     }
26373     {
26374         PyThreadState* __tstate = wxPyBeginAllowThreads();
26375         result = (bool)(arg1)->DrawBlankPage(arg2,*arg3);
26376
26377         wxPyEndAllowThreads(__tstate);
26378         if (PyErr_Occurred()) SWIG_fail;
26379     }
26380     {
26381         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26382     }
26383     return resultobj;
26384     fail:
26385     return NULL;
26386 }
26387
26388
26389 static PyObject *_wrap_PrintPreview_RenderPage(PyObject *, PyObject *args, PyObject *kwargs) {
26390     PyObject *resultobj;
26391     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26392     int arg2 ;
26393     bool result;
26394     PyObject * obj0 = 0 ;
26395     PyObject * obj1 = 0 ;
26396     char *kwnames[] = {
26397         (char *) "self",(char *) "pageNum", NULL
26398     };
26399
26400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_RenderPage",kwnames,&obj0,&obj1)) goto fail;
26401     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26402     if (SWIG_arg_fail(1)) SWIG_fail;
26403     {
26404         arg2 = (int)(SWIG_As_int(obj1));
26405         if (SWIG_arg_fail(2)) SWIG_fail;
26406     }
26407     {
26408         PyThreadState* __tstate = wxPyBeginAllowThreads();
26409         result = (bool)(arg1)->RenderPage(arg2);
26410
26411         wxPyEndAllowThreads(__tstate);
26412         if (PyErr_Occurred()) SWIG_fail;
26413     }
26414     {
26415         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26416     }
26417     return resultobj;
26418     fail:
26419     return NULL;
26420 }
26421
26422
26423 static PyObject *_wrap_PrintPreview_AdjustScrollbars(PyObject *, PyObject *args, PyObject *kwargs) {
26424     PyObject *resultobj;
26425     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26426     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26427     PyObject * obj0 = 0 ;
26428     PyObject * obj1 = 0 ;
26429     char *kwnames[] = {
26430         (char *) "self",(char *) "canvas", NULL
26431     };
26432
26433     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_AdjustScrollbars",kwnames,&obj0,&obj1)) goto fail;
26434     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26435     if (SWIG_arg_fail(1)) SWIG_fail;
26436     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26437     if (SWIG_arg_fail(2)) SWIG_fail;
26438     {
26439         PyThreadState* __tstate = wxPyBeginAllowThreads();
26440         (arg1)->AdjustScrollbars(arg2);
26441
26442         wxPyEndAllowThreads(__tstate);
26443         if (PyErr_Occurred()) SWIG_fail;
26444     }
26445     Py_INCREF(Py_None); resultobj = Py_None;
26446     return resultobj;
26447     fail:
26448     return NULL;
26449 }
26450
26451
26452 static PyObject *_wrap_PrintPreview_GetPrintDialogData(PyObject *, PyObject *args, PyObject *kwargs) {
26453     PyObject *resultobj;
26454     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26455     wxPrintDialogData *result;
26456     PyObject * obj0 = 0 ;
26457     char *kwnames[] = {
26458         (char *) "self", NULL
26459     };
26460
26461     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetPrintDialogData",kwnames,&obj0)) goto fail;
26462     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26463     if (SWIG_arg_fail(1)) SWIG_fail;
26464     {
26465         PyThreadState* __tstate = wxPyBeginAllowThreads();
26466         {
26467             wxPrintDialogData &_result_ref = (arg1)->GetPrintDialogData();
26468             result = (wxPrintDialogData *) &_result_ref;
26469         }
26470
26471         wxPyEndAllowThreads(__tstate);
26472         if (PyErr_Occurred()) SWIG_fail;
26473     }
26474     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintDialogData, 0);
26475     return resultobj;
26476     fail:
26477     return NULL;
26478 }
26479
26480
26481 static PyObject *_wrap_PrintPreview_SetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
26482     PyObject *resultobj;
26483     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26484     int arg2 ;
26485     PyObject * obj0 = 0 ;
26486     PyObject * obj1 = 0 ;
26487     char *kwnames[] = {
26488         (char *) "self",(char *) "percent", NULL
26489     };
26490
26491     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetZoom",kwnames,&obj0,&obj1)) goto fail;
26492     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26493     if (SWIG_arg_fail(1)) SWIG_fail;
26494     {
26495         arg2 = (int)(SWIG_As_int(obj1));
26496         if (SWIG_arg_fail(2)) SWIG_fail;
26497     }
26498     {
26499         PyThreadState* __tstate = wxPyBeginAllowThreads();
26500         (arg1)->SetZoom(arg2);
26501
26502         wxPyEndAllowThreads(__tstate);
26503         if (PyErr_Occurred()) SWIG_fail;
26504     }
26505     Py_INCREF(Py_None); resultobj = Py_None;
26506     return resultobj;
26507     fail:
26508     return NULL;
26509 }
26510
26511
26512 static PyObject *_wrap_PrintPreview_GetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
26513     PyObject *resultobj;
26514     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26515     int result;
26516     PyObject * obj0 = 0 ;
26517     char *kwnames[] = {
26518         (char *) "self", NULL
26519     };
26520
26521     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetZoom",kwnames,&obj0)) goto fail;
26522     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26523     if (SWIG_arg_fail(1)) SWIG_fail;
26524     {
26525         PyThreadState* __tstate = wxPyBeginAllowThreads();
26526         result = (int)(arg1)->GetZoom();
26527
26528         wxPyEndAllowThreads(__tstate);
26529         if (PyErr_Occurred()) SWIG_fail;
26530     }
26531     {
26532         resultobj = SWIG_From_int((int)(result));
26533     }
26534     return resultobj;
26535     fail:
26536     return NULL;
26537 }
26538
26539
26540 static PyObject *_wrap_PrintPreview_GetMaxPage(PyObject *, PyObject *args, PyObject *kwargs) {
26541     PyObject *resultobj;
26542     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26543     int result;
26544     PyObject * obj0 = 0 ;
26545     char *kwnames[] = {
26546         (char *) "self", NULL
26547     };
26548
26549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetMaxPage",kwnames,&obj0)) goto fail;
26550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26551     if (SWIG_arg_fail(1)) SWIG_fail;
26552     {
26553         PyThreadState* __tstate = wxPyBeginAllowThreads();
26554         result = (int)(arg1)->GetMaxPage();
26555
26556         wxPyEndAllowThreads(__tstate);
26557         if (PyErr_Occurred()) SWIG_fail;
26558     }
26559     {
26560         resultobj = SWIG_From_int((int)(result));
26561     }
26562     return resultobj;
26563     fail:
26564     return NULL;
26565 }
26566
26567
26568 static PyObject *_wrap_PrintPreview_GetMinPage(PyObject *, PyObject *args, PyObject *kwargs) {
26569     PyObject *resultobj;
26570     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26571     int result;
26572     PyObject * obj0 = 0 ;
26573     char *kwnames[] = {
26574         (char *) "self", NULL
26575     };
26576
26577     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_GetMinPage",kwnames,&obj0)) goto fail;
26578     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26579     if (SWIG_arg_fail(1)) SWIG_fail;
26580     {
26581         PyThreadState* __tstate = wxPyBeginAllowThreads();
26582         result = (int)(arg1)->GetMinPage();
26583
26584         wxPyEndAllowThreads(__tstate);
26585         if (PyErr_Occurred()) SWIG_fail;
26586     }
26587     {
26588         resultobj = SWIG_From_int((int)(result));
26589     }
26590     return resultobj;
26591     fail:
26592     return NULL;
26593 }
26594
26595
26596 static PyObject *_wrap_PrintPreview_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
26597     PyObject *resultobj;
26598     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26599     bool result;
26600     PyObject * obj0 = 0 ;
26601     char *kwnames[] = {
26602         (char *) "self", NULL
26603     };
26604
26605     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_Ok",kwnames,&obj0)) goto fail;
26606     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26607     if (SWIG_arg_fail(1)) SWIG_fail;
26608     {
26609         PyThreadState* __tstate = wxPyBeginAllowThreads();
26610         result = (bool)(arg1)->Ok();
26611
26612         wxPyEndAllowThreads(__tstate);
26613         if (PyErr_Occurred()) SWIG_fail;
26614     }
26615     {
26616         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26617     }
26618     return resultobj;
26619     fail:
26620     return NULL;
26621 }
26622
26623
26624 static PyObject *_wrap_PrintPreview_SetOk(PyObject *, PyObject *args, PyObject *kwargs) {
26625     PyObject *resultobj;
26626     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26627     bool arg2 ;
26628     PyObject * obj0 = 0 ;
26629     PyObject * obj1 = 0 ;
26630     char *kwnames[] = {
26631         (char *) "self",(char *) "ok", NULL
26632     };
26633
26634     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_SetOk",kwnames,&obj0,&obj1)) goto fail;
26635     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26636     if (SWIG_arg_fail(1)) SWIG_fail;
26637     {
26638         arg2 = (bool)(SWIG_As_bool(obj1));
26639         if (SWIG_arg_fail(2)) SWIG_fail;
26640     }
26641     {
26642         PyThreadState* __tstate = wxPyBeginAllowThreads();
26643         (arg1)->SetOk(arg2);
26644
26645         wxPyEndAllowThreads(__tstate);
26646         if (PyErr_Occurred()) SWIG_fail;
26647     }
26648     Py_INCREF(Py_None); resultobj = Py_None;
26649     return resultobj;
26650     fail:
26651     return NULL;
26652 }
26653
26654
26655 static PyObject *_wrap_PrintPreview_Print(PyObject *, PyObject *args, PyObject *kwargs) {
26656     PyObject *resultobj;
26657     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26658     bool arg2 ;
26659     bool result;
26660     PyObject * obj0 = 0 ;
26661     PyObject * obj1 = 0 ;
26662     char *kwnames[] = {
26663         (char *) "self",(char *) "interactive", NULL
26664     };
26665
26666     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintPreview_Print",kwnames,&obj0,&obj1)) goto fail;
26667     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26668     if (SWIG_arg_fail(1)) SWIG_fail;
26669     {
26670         arg2 = (bool)(SWIG_As_bool(obj1));
26671         if (SWIG_arg_fail(2)) SWIG_fail;
26672     }
26673     {
26674         PyThreadState* __tstate = wxPyBeginAllowThreads();
26675         result = (bool)(arg1)->Print(arg2);
26676
26677         wxPyEndAllowThreads(__tstate);
26678         if (PyErr_Occurred()) SWIG_fail;
26679     }
26680     {
26681         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26682     }
26683     return resultobj;
26684     fail:
26685     return NULL;
26686 }
26687
26688
26689 static PyObject *_wrap_PrintPreview_DetermineScaling(PyObject *, PyObject *args, PyObject *kwargs) {
26690     PyObject *resultobj;
26691     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
26692     PyObject * obj0 = 0 ;
26693     char *kwnames[] = {
26694         (char *) "self", NULL
26695     };
26696
26697     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PrintPreview_DetermineScaling",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         (arg1)->DetermineScaling();
26703
26704         wxPyEndAllowThreads(__tstate);
26705         if (PyErr_Occurred()) SWIG_fail;
26706     }
26707     Py_INCREF(Py_None); resultobj = Py_None;
26708     return resultobj;
26709     fail:
26710     return NULL;
26711 }
26712
26713
26714 static PyObject * PrintPreview_swigregister(PyObject *, PyObject *args) {
26715     PyObject *obj;
26716     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26717     SWIG_TypeClientData(SWIGTYPE_p_wxPrintPreview, obj);
26718     Py_INCREF(obj);
26719     return Py_BuildValue((char *)"");
26720 }
26721 static PyObject *_wrap_new_PyPrintPreview__SWIG_0(PyObject *, PyObject *args) {
26722     PyObject *resultobj;
26723     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26724     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26725     wxPrintDialogData *arg3 = (wxPrintDialogData *) NULL ;
26726     wxPyPrintPreview *result;
26727     PyObject * obj0 = 0 ;
26728     PyObject * obj1 = 0 ;
26729     PyObject * obj2 = 0 ;
26730
26731     if(!PyArg_ParseTuple(args,(char *)"OO|O:new_PyPrintPreview",&obj0,&obj1,&obj2)) goto fail;
26732     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26733     if (SWIG_arg_fail(1)) SWIG_fail;
26734     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26735     if (SWIG_arg_fail(2)) SWIG_fail;
26736     if (obj2) {
26737         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintDialogData, SWIG_POINTER_EXCEPTION | 0);
26738         if (SWIG_arg_fail(3)) SWIG_fail;
26739     }
26740     {
26741         if (!wxPyCheckForApp()) SWIG_fail;
26742         PyThreadState* __tstate = wxPyBeginAllowThreads();
26743         result = (wxPyPrintPreview *)new wxPyPrintPreview(arg1,arg2,arg3);
26744
26745         wxPyEndAllowThreads(__tstate);
26746         if (PyErr_Occurred()) SWIG_fail;
26747     }
26748     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPrintPreview, 1);
26749     return resultobj;
26750     fail:
26751     return NULL;
26752 }
26753
26754
26755 static PyObject *_wrap_new_PyPrintPreview__SWIG_1(PyObject *, PyObject *args) {
26756     PyObject *resultobj;
26757     wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
26758     wxPyPrintout *arg2 = (wxPyPrintout *) 0 ;
26759     wxPrintData *arg3 = (wxPrintData *) 0 ;
26760     wxPyPrintPreview *result;
26761     PyObject * obj0 = 0 ;
26762     PyObject * obj1 = 0 ;
26763     PyObject * obj2 = 0 ;
26764
26765     if(!PyArg_ParseTuple(args,(char *)"OOO:new_PyPrintPreview",&obj0,&obj1,&obj2)) goto fail;
26766     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26767     if (SWIG_arg_fail(1)) SWIG_fail;
26768     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyPrintout, SWIG_POINTER_EXCEPTION | 0);
26769     if (SWIG_arg_fail(2)) SWIG_fail;
26770     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
26771     if (SWIG_arg_fail(3)) SWIG_fail;
26772     {
26773         if (!wxPyCheckForApp()) SWIG_fail;
26774         PyThreadState* __tstate = wxPyBeginAllowThreads();
26775         result = (wxPyPrintPreview *)new wxPyPrintPreview(arg1,arg2,arg3);
26776
26777         wxPyEndAllowThreads(__tstate);
26778         if (PyErr_Occurred()) SWIG_fail;
26779     }
26780     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPrintPreview, 1);
26781     return resultobj;
26782     fail:
26783     return NULL;
26784 }
26785
26786
26787 static PyObject *_wrap_new_PyPrintPreview(PyObject *self, PyObject *args) {
26788     int argc;
26789     PyObject *argv[4];
26790     int ii;
26791
26792     argc = PyObject_Length(args);
26793     for (ii = 0; (ii < argc) && (ii < 3); ii++) {
26794         argv[ii] = PyTuple_GetItem(args,ii);
26795     }
26796     if ((argc >= 2) && (argc <= 3)) {
26797         int _v;
26798         {
26799             void *ptr;
26800             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26801                 _v = 0;
26802                 PyErr_Clear();
26803             } else {
26804                 _v = 1;
26805             }
26806         }
26807         if (_v) {
26808             {
26809                 void *ptr;
26810                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26811                     _v = 0;
26812                     PyErr_Clear();
26813                 } else {
26814                     _v = 1;
26815                 }
26816             }
26817             if (_v) {
26818                 if (argc <= 2) {
26819                     return _wrap_new_PyPrintPreview__SWIG_0(self,args);
26820                 }
26821                 {
26822                     void *ptr;
26823                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintDialogData, 0) == -1) {
26824                         _v = 0;
26825                         PyErr_Clear();
26826                     } else {
26827                         _v = 1;
26828                     }
26829                 }
26830                 if (_v) {
26831                     return _wrap_new_PyPrintPreview__SWIG_0(self,args);
26832                 }
26833             }
26834         }
26835     }
26836     if (argc == 3) {
26837         int _v;
26838         {
26839             void *ptr;
26840             if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26841                 _v = 0;
26842                 PyErr_Clear();
26843             } else {
26844                 _v = 1;
26845             }
26846         }
26847         if (_v) {
26848             {
26849                 void *ptr;
26850                 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxPyPrintout, 0) == -1) {
26851                     _v = 0;
26852                     PyErr_Clear();
26853                 } else {
26854                     _v = 1;
26855                 }
26856             }
26857             if (_v) {
26858                 {
26859                     void *ptr;
26860                     if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_wxPrintData, 0) == -1) {
26861                         _v = 0;
26862                         PyErr_Clear();
26863                     } else {
26864                         _v = 1;
26865                     }
26866                 }
26867                 if (_v) {
26868                     return _wrap_new_PyPrintPreview__SWIG_1(self,args);
26869                 }
26870             }
26871         }
26872     }
26873
26874     PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_PyPrintPreview'");
26875     return NULL;
26876 }
26877
26878
26879 static PyObject *_wrap_PyPrintPreview__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
26880     PyObject *resultobj;
26881     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
26882     PyObject *arg2 = (PyObject *) 0 ;
26883     PyObject *arg3 = (PyObject *) 0 ;
26884     PyObject * obj0 = 0 ;
26885     PyObject * obj1 = 0 ;
26886     PyObject * obj2 = 0 ;
26887     char *kwnames[] = {
26888         (char *) "self",(char *) "self",(char *) "_class", NULL
26889     };
26890
26891     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
26892     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26893     if (SWIG_arg_fail(1)) SWIG_fail;
26894     arg2 = obj1;
26895     arg3 = obj2;
26896     {
26897         PyThreadState* __tstate = wxPyBeginAllowThreads();
26898         (arg1)->_setCallbackInfo(arg2,arg3);
26899
26900         wxPyEndAllowThreads(__tstate);
26901         if (PyErr_Occurred()) SWIG_fail;
26902     }
26903     Py_INCREF(Py_None); resultobj = Py_None;
26904     return resultobj;
26905     fail:
26906     return NULL;
26907 }
26908
26909
26910 static PyObject *_wrap_PyPrintPreview_base_SetCurrentPage(PyObject *, PyObject *args, PyObject *kwargs) {
26911     PyObject *resultobj;
26912     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
26913     int arg2 ;
26914     bool result;
26915     PyObject * obj0 = 0 ;
26916     PyObject * obj1 = 0 ;
26917     char *kwnames[] = {
26918         (char *) "self",(char *) "pageNum", NULL
26919     };
26920
26921     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_SetCurrentPage",kwnames,&obj0,&obj1)) goto fail;
26922     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26923     if (SWIG_arg_fail(1)) SWIG_fail;
26924     {
26925         arg2 = (int)(SWIG_As_int(obj1));
26926         if (SWIG_arg_fail(2)) SWIG_fail;
26927     }
26928     {
26929         PyThreadState* __tstate = wxPyBeginAllowThreads();
26930         result = (bool)(arg1)->base_SetCurrentPage(arg2);
26931
26932         wxPyEndAllowThreads(__tstate);
26933         if (PyErr_Occurred()) SWIG_fail;
26934     }
26935     {
26936         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26937     }
26938     return resultobj;
26939     fail:
26940     return NULL;
26941 }
26942
26943
26944 static PyObject *_wrap_PyPrintPreview_base_PaintPage(PyObject *, PyObject *args, PyObject *kwargs) {
26945     PyObject *resultobj;
26946     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
26947     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26948     wxDC *arg3 = 0 ;
26949     bool result;
26950     PyObject * obj0 = 0 ;
26951     PyObject * obj1 = 0 ;
26952     PyObject * obj2 = 0 ;
26953     char *kwnames[] = {
26954         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26955     };
26956
26957     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview_base_PaintPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
26958     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
26959     if (SWIG_arg_fail(1)) SWIG_fail;
26960     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
26961     if (SWIG_arg_fail(2)) SWIG_fail;
26962     {
26963         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
26964         if (SWIG_arg_fail(3)) SWIG_fail;
26965         if (arg3 == NULL) {
26966             SWIG_null_ref("wxDC");
26967         }
26968         if (SWIG_arg_fail(3)) SWIG_fail;
26969     }
26970     {
26971         PyThreadState* __tstate = wxPyBeginAllowThreads();
26972         result = (bool)(arg1)->base_PaintPage(arg2,*arg3);
26973
26974         wxPyEndAllowThreads(__tstate);
26975         if (PyErr_Occurred()) SWIG_fail;
26976     }
26977     {
26978         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26979     }
26980     return resultobj;
26981     fail:
26982     return NULL;
26983 }
26984
26985
26986 static PyObject *_wrap_PyPrintPreview_base_DrawBlankPage(PyObject *, PyObject *args, PyObject *kwargs) {
26987     PyObject *resultobj;
26988     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
26989     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
26990     wxDC *arg3 = 0 ;
26991     bool result;
26992     PyObject * obj0 = 0 ;
26993     PyObject * obj1 = 0 ;
26994     PyObject * obj2 = 0 ;
26995     char *kwnames[] = {
26996         (char *) "self",(char *) "canvas",(char *) "dc", NULL
26997     };
26998
26999     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPrintPreview_base_DrawBlankPage",kwnames,&obj0,&obj1,&obj2)) goto fail;
27000     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27001     if (SWIG_arg_fail(1)) SWIG_fail;
27002     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27003     if (SWIG_arg_fail(2)) SWIG_fail;
27004     {
27005         SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
27006         if (SWIG_arg_fail(3)) SWIG_fail;
27007         if (arg3 == NULL) {
27008             SWIG_null_ref("wxDC");
27009         }
27010         if (SWIG_arg_fail(3)) SWIG_fail;
27011     }
27012     {
27013         PyThreadState* __tstate = wxPyBeginAllowThreads();
27014         result = (bool)(arg1)->base_DrawBlankPage(arg2,*arg3);
27015
27016         wxPyEndAllowThreads(__tstate);
27017         if (PyErr_Occurred()) SWIG_fail;
27018     }
27019     {
27020         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27021     }
27022     return resultobj;
27023     fail:
27024     return NULL;
27025 }
27026
27027
27028 static PyObject *_wrap_PyPrintPreview_base_RenderPage(PyObject *, PyObject *args, PyObject *kwargs) {
27029     PyObject *resultobj;
27030     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27031     int arg2 ;
27032     bool result;
27033     PyObject * obj0 = 0 ;
27034     PyObject * obj1 = 0 ;
27035     char *kwnames[] = {
27036         (char *) "self",(char *) "pageNum", NULL
27037     };
27038
27039     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_RenderPage",kwnames,&obj0,&obj1)) goto fail;
27040     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27041     if (SWIG_arg_fail(1)) SWIG_fail;
27042     {
27043         arg2 = (int)(SWIG_As_int(obj1));
27044         if (SWIG_arg_fail(2)) SWIG_fail;
27045     }
27046     {
27047         PyThreadState* __tstate = wxPyBeginAllowThreads();
27048         result = (bool)(arg1)->base_RenderPage(arg2);
27049
27050         wxPyEndAllowThreads(__tstate);
27051         if (PyErr_Occurred()) SWIG_fail;
27052     }
27053     {
27054         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27055     }
27056     return resultobj;
27057     fail:
27058     return NULL;
27059 }
27060
27061
27062 static PyObject *_wrap_PyPrintPreview_base_SetZoom(PyObject *, PyObject *args, PyObject *kwargs) {
27063     PyObject *resultobj;
27064     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27065     int arg2 ;
27066     PyObject * obj0 = 0 ;
27067     PyObject * obj1 = 0 ;
27068     char *kwnames[] = {
27069         (char *) "self",(char *) "percent", NULL
27070     };
27071
27072     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_SetZoom",kwnames,&obj0,&obj1)) goto fail;
27073     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27074     if (SWIG_arg_fail(1)) SWIG_fail;
27075     {
27076         arg2 = (int)(SWIG_As_int(obj1));
27077         if (SWIG_arg_fail(2)) SWIG_fail;
27078     }
27079     {
27080         PyThreadState* __tstate = wxPyBeginAllowThreads();
27081         (arg1)->base_SetZoom(arg2);
27082
27083         wxPyEndAllowThreads(__tstate);
27084         if (PyErr_Occurred()) SWIG_fail;
27085     }
27086     Py_INCREF(Py_None); resultobj = Py_None;
27087     return resultobj;
27088     fail:
27089     return NULL;
27090 }
27091
27092
27093 static PyObject *_wrap_PyPrintPreview_base_Print(PyObject *, PyObject *args, PyObject *kwargs) {
27094     PyObject *resultobj;
27095     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27096     bool arg2 ;
27097     bool result;
27098     PyObject * obj0 = 0 ;
27099     PyObject * obj1 = 0 ;
27100     char *kwnames[] = {
27101         (char *) "self",(char *) "interactive", NULL
27102     };
27103
27104     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPrintPreview_base_Print",kwnames,&obj0,&obj1)) goto fail;
27105     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27106     if (SWIG_arg_fail(1)) SWIG_fail;
27107     {
27108         arg2 = (bool)(SWIG_As_bool(obj1));
27109         if (SWIG_arg_fail(2)) SWIG_fail;
27110     }
27111     {
27112         PyThreadState* __tstate = wxPyBeginAllowThreads();
27113         result = (bool)(arg1)->base_Print(arg2);
27114
27115         wxPyEndAllowThreads(__tstate);
27116         if (PyErr_Occurred()) SWIG_fail;
27117     }
27118     {
27119         resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27120     }
27121     return resultobj;
27122     fail:
27123     return NULL;
27124 }
27125
27126
27127 static PyObject *_wrap_PyPrintPreview_base_DetermineScaling(PyObject *, PyObject *args, PyObject *kwargs) {
27128     PyObject *resultobj;
27129     wxPyPrintPreview *arg1 = (wxPyPrintPreview *) 0 ;
27130     PyObject * obj0 = 0 ;
27131     char *kwnames[] = {
27132         (char *) "self", NULL
27133     };
27134
27135     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPrintPreview_base_DetermineScaling",kwnames,&obj0)) goto fail;
27136     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27137     if (SWIG_arg_fail(1)) SWIG_fail;
27138     {
27139         PyThreadState* __tstate = wxPyBeginAllowThreads();
27140         (arg1)->base_DetermineScaling();
27141
27142         wxPyEndAllowThreads(__tstate);
27143         if (PyErr_Occurred()) SWIG_fail;
27144     }
27145     Py_INCREF(Py_None); resultobj = Py_None;
27146     return resultobj;
27147     fail:
27148     return NULL;
27149 }
27150
27151
27152 static PyObject * PyPrintPreview_swigregister(PyObject *, PyObject *args) {
27153     PyObject *obj;
27154     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27155     SWIG_TypeClientData(SWIGTYPE_p_wxPyPrintPreview, obj);
27156     Py_INCREF(obj);
27157     return Py_BuildValue((char *)"");
27158 }
27159 static PyObject *_wrap_new_PyPreviewFrame(PyObject *, PyObject *args, PyObject *kwargs) {
27160     PyObject *resultobj;
27161     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
27162     wxFrame *arg2 = (wxFrame *) 0 ;
27163     wxString *arg3 = 0 ;
27164     wxPoint const &arg4_defvalue = wxDefaultPosition ;
27165     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
27166     wxSize const &arg5_defvalue = wxDefaultSize ;
27167     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
27168     long arg6 = (long) wxDEFAULT_FRAME_STYLE ;
27169     wxString const &arg7_defvalue = wxPyFrameNameStr ;
27170     wxString *arg7 = (wxString *) &arg7_defvalue ;
27171     wxPyPreviewFrame *result;
27172     bool temp3 = false ;
27173     wxPoint temp4 ;
27174     wxSize temp5 ;
27175     bool temp7 = false ;
27176     PyObject * obj0 = 0 ;
27177     PyObject * obj1 = 0 ;
27178     PyObject * obj2 = 0 ;
27179     PyObject * obj3 = 0 ;
27180     PyObject * obj4 = 0 ;
27181     PyObject * obj5 = 0 ;
27182     PyObject * obj6 = 0 ;
27183     char *kwnames[] = {
27184         (char *) "preview",(char *) "parent",(char *) "title",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
27185     };
27186
27187     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PyPreviewFrame",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27188     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27189     if (SWIG_arg_fail(1)) SWIG_fail;
27190     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
27191     if (SWIG_arg_fail(2)) SWIG_fail;
27192     {
27193         arg3 = wxString_in_helper(obj2);
27194         if (arg3 == NULL) SWIG_fail;
27195         temp3 = true;
27196     }
27197     if (obj3) {
27198         {
27199             arg4 = &temp4;
27200             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
27201         }
27202     }
27203     if (obj4) {
27204         {
27205             arg5 = &temp5;
27206             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
27207         }
27208     }
27209     if (obj5) {
27210         {
27211             arg6 = (long)(SWIG_As_long(obj5));
27212             if (SWIG_arg_fail(6)) SWIG_fail;
27213         }
27214     }
27215     if (obj6) {
27216         {
27217             arg7 = wxString_in_helper(obj6);
27218             if (arg7 == NULL) SWIG_fail;
27219             temp7 = true;
27220         }
27221     }
27222     {
27223         if (!wxPyCheckForApp()) SWIG_fail;
27224         PyThreadState* __tstate = wxPyBeginAllowThreads();
27225         result = (wxPyPreviewFrame *)new wxPyPreviewFrame(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
27226
27227         wxPyEndAllowThreads(__tstate);
27228         if (PyErr_Occurred()) SWIG_fail;
27229     }
27230     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPreviewFrame, 1);
27231     {
27232         if (temp3)
27233         delete arg3;
27234     }
27235     {
27236         if (temp7)
27237         delete arg7;
27238     }
27239     return resultobj;
27240     fail:
27241     {
27242         if (temp3)
27243         delete arg3;
27244     }
27245     {
27246         if (temp7)
27247         delete arg7;
27248     }
27249     return NULL;
27250 }
27251
27252
27253 static PyObject *_wrap_PyPreviewFrame__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27254     PyObject *resultobj;
27255     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27256     PyObject *arg2 = (PyObject *) 0 ;
27257     PyObject *arg3 = (PyObject *) 0 ;
27258     PyObject * obj0 = 0 ;
27259     PyObject * obj1 = 0 ;
27260     PyObject * obj2 = 0 ;
27261     char *kwnames[] = {
27262         (char *) "self",(char *) "self",(char *) "_class", NULL
27263     };
27264
27265     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPreviewFrame__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27266     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27267     if (SWIG_arg_fail(1)) SWIG_fail;
27268     arg2 = obj1;
27269     arg3 = obj2;
27270     {
27271         PyThreadState* __tstate = wxPyBeginAllowThreads();
27272         (arg1)->_setCallbackInfo(arg2,arg3);
27273
27274         wxPyEndAllowThreads(__tstate);
27275         if (PyErr_Occurred()) SWIG_fail;
27276     }
27277     Py_INCREF(Py_None); resultobj = Py_None;
27278     return resultobj;
27279     fail:
27280     return NULL;
27281 }
27282
27283
27284 static PyObject *_wrap_PyPreviewFrame_SetPreviewCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
27285     PyObject *resultobj;
27286     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27287     wxPreviewCanvas *arg2 = (wxPreviewCanvas *) 0 ;
27288     PyObject * obj0 = 0 ;
27289     PyObject * obj1 = 0 ;
27290     char *kwnames[] = {
27291         (char *) "self",(char *) "canvas", NULL
27292     };
27293
27294     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewFrame_SetPreviewCanvas",kwnames,&obj0,&obj1)) goto fail;
27295     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27296     if (SWIG_arg_fail(1)) SWIG_fail;
27297     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewCanvas, SWIG_POINTER_EXCEPTION | 0);
27298     if (SWIG_arg_fail(2)) SWIG_fail;
27299     {
27300         PyThreadState* __tstate = wxPyBeginAllowThreads();
27301         (arg1)->SetPreviewCanvas(arg2);
27302
27303         wxPyEndAllowThreads(__tstate);
27304         if (PyErr_Occurred()) SWIG_fail;
27305     }
27306     Py_INCREF(Py_None); resultobj = Py_None;
27307     return resultobj;
27308     fail:
27309     return NULL;
27310 }
27311
27312
27313 static PyObject *_wrap_PyPreviewFrame_SetControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27314     PyObject *resultobj;
27315     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27316     wxPreviewControlBar *arg2 = (wxPreviewControlBar *) 0 ;
27317     PyObject * obj0 = 0 ;
27318     PyObject * obj1 = 0 ;
27319     char *kwnames[] = {
27320         (char *) "self",(char *) "bar", NULL
27321     };
27322
27323     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewFrame_SetControlBar",kwnames,&obj0,&obj1)) goto fail;
27324     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27325     if (SWIG_arg_fail(1)) SWIG_fail;
27326     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27327     if (SWIG_arg_fail(2)) SWIG_fail;
27328     {
27329         PyThreadState* __tstate = wxPyBeginAllowThreads();
27330         (arg1)->SetControlBar(arg2);
27331
27332         wxPyEndAllowThreads(__tstate);
27333         if (PyErr_Occurred()) SWIG_fail;
27334     }
27335     Py_INCREF(Py_None); resultobj = Py_None;
27336     return resultobj;
27337     fail:
27338     return NULL;
27339 }
27340
27341
27342 static PyObject *_wrap_PyPreviewFrame_base_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
27343     PyObject *resultobj;
27344     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27345     PyObject * obj0 = 0 ;
27346     char *kwnames[] = {
27347         (char *) "self", NULL
27348     };
27349
27350     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_Initialize",kwnames,&obj0)) goto fail;
27351     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27352     if (SWIG_arg_fail(1)) SWIG_fail;
27353     {
27354         PyThreadState* __tstate = wxPyBeginAllowThreads();
27355         (arg1)->base_Initialize();
27356
27357         wxPyEndAllowThreads(__tstate);
27358         if (PyErr_Occurred()) SWIG_fail;
27359     }
27360     Py_INCREF(Py_None); resultobj = Py_None;
27361     return resultobj;
27362     fail:
27363     return NULL;
27364 }
27365
27366
27367 static PyObject *_wrap_PyPreviewFrame_base_CreateCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
27368     PyObject *resultobj;
27369     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27370     PyObject * obj0 = 0 ;
27371     char *kwnames[] = {
27372         (char *) "self", NULL
27373     };
27374
27375     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_CreateCanvas",kwnames,&obj0)) goto fail;
27376     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27377     if (SWIG_arg_fail(1)) SWIG_fail;
27378     {
27379         PyThreadState* __tstate = wxPyBeginAllowThreads();
27380         (arg1)->base_CreateCanvas();
27381
27382         wxPyEndAllowThreads(__tstate);
27383         if (PyErr_Occurred()) SWIG_fail;
27384     }
27385     Py_INCREF(Py_None); resultobj = Py_None;
27386     return resultobj;
27387     fail:
27388     return NULL;
27389 }
27390
27391
27392 static PyObject *_wrap_PyPreviewFrame_base_CreateControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27393     PyObject *resultobj;
27394     wxPyPreviewFrame *arg1 = (wxPyPreviewFrame *) 0 ;
27395     PyObject * obj0 = 0 ;
27396     char *kwnames[] = {
27397         (char *) "self", NULL
27398     };
27399
27400     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewFrame_base_CreateControlBar",kwnames,&obj0)) goto fail;
27401     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewFrame, SWIG_POINTER_EXCEPTION | 0);
27402     if (SWIG_arg_fail(1)) SWIG_fail;
27403     {
27404         PyThreadState* __tstate = wxPyBeginAllowThreads();
27405         (arg1)->base_CreateControlBar();
27406
27407         wxPyEndAllowThreads(__tstate);
27408         if (PyErr_Occurred()) SWIG_fail;
27409     }
27410     Py_INCREF(Py_None); resultobj = Py_None;
27411     return resultobj;
27412     fail:
27413     return NULL;
27414 }
27415
27416
27417 static PyObject * PyPreviewFrame_swigregister(PyObject *, PyObject *args) {
27418     PyObject *obj;
27419     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27420     SWIG_TypeClientData(SWIGTYPE_p_wxPyPreviewFrame, obj);
27421     Py_INCREF(obj);
27422     return Py_BuildValue((char *)"");
27423 }
27424 static PyObject *_wrap_new_PyPreviewControlBar(PyObject *, PyObject *args, PyObject *kwargs) {
27425     PyObject *resultobj;
27426     wxPrintPreview *arg1 = (wxPrintPreview *) 0 ;
27427     long arg2 ;
27428     wxWindow *arg3 = (wxWindow *) 0 ;
27429     wxPoint const &arg4_defvalue = wxDefaultPosition ;
27430     wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
27431     wxSize const &arg5_defvalue = wxDefaultSize ;
27432     wxSize *arg5 = (wxSize *) &arg5_defvalue ;
27433     long arg6 = (long) 0 ;
27434     wxString const &arg7_defvalue = wxPyPanelNameStr ;
27435     wxString *arg7 = (wxString *) &arg7_defvalue ;
27436     wxPyPreviewControlBar *result;
27437     wxPoint temp4 ;
27438     wxSize temp5 ;
27439     bool temp7 = false ;
27440     PyObject * obj0 = 0 ;
27441     PyObject * obj1 = 0 ;
27442     PyObject * obj2 = 0 ;
27443     PyObject * obj3 = 0 ;
27444     PyObject * obj4 = 0 ;
27445     PyObject * obj5 = 0 ;
27446     PyObject * obj6 = 0 ;
27447     char *kwnames[] = {
27448         (char *) "preview",(char *) "buttons",(char *) "parent",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
27449     };
27450
27451     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:new_PyPreviewControlBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27452     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27453     if (SWIG_arg_fail(1)) SWIG_fail;
27454     {
27455         arg2 = (long)(SWIG_As_long(obj1));
27456         if (SWIG_arg_fail(2)) SWIG_fail;
27457     }
27458     SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27459     if (SWIG_arg_fail(3)) SWIG_fail;
27460     if (obj3) {
27461         {
27462             arg4 = &temp4;
27463             if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
27464         }
27465     }
27466     if (obj4) {
27467         {
27468             arg5 = &temp5;
27469             if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
27470         }
27471     }
27472     if (obj5) {
27473         {
27474             arg6 = (long)(SWIG_As_long(obj5));
27475             if (SWIG_arg_fail(6)) SWIG_fail;
27476         }
27477     }
27478     if (obj6) {
27479         {
27480             arg7 = wxString_in_helper(obj6);
27481             if (arg7 == NULL) SWIG_fail;
27482             temp7 = true;
27483         }
27484     }
27485     {
27486         if (!wxPyCheckForApp()) SWIG_fail;
27487         PyThreadState* __tstate = wxPyBeginAllowThreads();
27488         result = (wxPyPreviewControlBar *)new wxPyPreviewControlBar(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
27489
27490         wxPyEndAllowThreads(__tstate);
27491         if (PyErr_Occurred()) SWIG_fail;
27492     }
27493     resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyPreviewControlBar, 1);
27494     {
27495         if (temp7)
27496         delete arg7;
27497     }
27498     return resultobj;
27499     fail:
27500     {
27501         if (temp7)
27502         delete arg7;
27503     }
27504     return NULL;
27505 }
27506
27507
27508 static PyObject *_wrap_PyPreviewControlBar__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27509     PyObject *resultobj;
27510     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27511     PyObject *arg2 = (PyObject *) 0 ;
27512     PyObject *arg3 = (PyObject *) 0 ;
27513     PyObject * obj0 = 0 ;
27514     PyObject * obj1 = 0 ;
27515     PyObject * obj2 = 0 ;
27516     char *kwnames[] = {
27517         (char *) "self",(char *) "self",(char *) "_class", NULL
27518     };
27519
27520     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPreviewControlBar__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27521     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27522     if (SWIG_arg_fail(1)) SWIG_fail;
27523     arg2 = obj1;
27524     arg3 = obj2;
27525     {
27526         PyThreadState* __tstate = wxPyBeginAllowThreads();
27527         (arg1)->_setCallbackInfo(arg2,arg3);
27528
27529         wxPyEndAllowThreads(__tstate);
27530         if (PyErr_Occurred()) SWIG_fail;
27531     }
27532     Py_INCREF(Py_None); resultobj = Py_None;
27533     return resultobj;
27534     fail:
27535     return NULL;
27536 }
27537
27538
27539 static PyObject *_wrap_PyPreviewControlBar_SetPrintPreview(PyObject *, PyObject *args, PyObject *kwargs) {
27540     PyObject *resultobj;
27541     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27542     wxPrintPreview *arg2 = (wxPrintPreview *) 0 ;
27543     PyObject * obj0 = 0 ;
27544     PyObject * obj1 = 0 ;
27545     char *kwnames[] = {
27546         (char *) "self",(char *) "preview", NULL
27547     };
27548
27549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewControlBar_SetPrintPreview",kwnames,&obj0,&obj1)) goto fail;
27550     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27551     if (SWIG_arg_fail(1)) SWIG_fail;
27552     SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintPreview, SWIG_POINTER_EXCEPTION | 0);
27553     if (SWIG_arg_fail(2)) SWIG_fail;
27554     {
27555         PyThreadState* __tstate = wxPyBeginAllowThreads();
27556         (arg1)->SetPrintPreview(arg2);
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_PyPreviewControlBar_base_CreateButtons(PyObject *, PyObject *args, PyObject *kwargs) {
27569     PyObject *resultobj;
27570     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27571     PyObject * obj0 = 0 ;
27572     char *kwnames[] = {
27573         (char *) "self", NULL
27574     };
27575
27576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyPreviewControlBar_base_CreateButtons",kwnames,&obj0)) goto fail;
27577     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27578     if (SWIG_arg_fail(1)) SWIG_fail;
27579     {
27580         PyThreadState* __tstate = wxPyBeginAllowThreads();
27581         (arg1)->base_CreateButtons();
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 *_wrap_PyPreviewControlBar_base_SetZoomControl(PyObject *, PyObject *args, PyObject *kwargs) {
27594     PyObject *resultobj;
27595     wxPyPreviewControlBar *arg1 = (wxPyPreviewControlBar *) 0 ;
27596     int arg2 ;
27597     PyObject * obj0 = 0 ;
27598     PyObject * obj1 = 0 ;
27599     char *kwnames[] = {
27600         (char *) "self",(char *) "zoom", NULL
27601     };
27602
27603     if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPreviewControlBar_base_SetZoomControl",kwnames,&obj0,&obj1)) goto fail;
27604     SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyPreviewControlBar, SWIG_POINTER_EXCEPTION | 0);
27605     if (SWIG_arg_fail(1)) SWIG_fail;
27606     {
27607         arg2 = (int)(SWIG_As_int(obj1));
27608         if (SWIG_arg_fail(2)) SWIG_fail;
27609     }
27610     {
27611         PyThreadState* __tstate = wxPyBeginAllowThreads();
27612         (arg1)->base_SetZoomControl(arg2);
27613
27614         wxPyEndAllowThreads(__tstate);
27615         if (PyErr_Occurred()) SWIG_fail;
27616     }
27617     Py_INCREF(Py_None); resultobj = Py_None;
27618     return resultobj;
27619     fail:
27620     return NULL;
27621 }
27622
27623
27624 static PyObject * PyPreviewControlBar_swigregister(PyObject *, PyObject *args) {
27625     PyObject *obj;
27626     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27627     SWIG_TypeClientData(SWIGTYPE_p_wxPyPreviewControlBar, obj);
27628     Py_INCREF(obj);
27629     return Py_BuildValue((char *)"");
27630 }
27631 static PyMethodDef SwigMethods[] = {
27632          { (char *)"new_Panel", (PyCFunction) _wrap_new_Panel, METH_VARARGS | METH_KEYWORDS, NULL},
27633          { (char *)"new_PrePanel", (PyCFunction) _wrap_new_PrePanel, METH_VARARGS | METH_KEYWORDS, NULL},
27634          { (char *)"Panel_Create", (PyCFunction) _wrap_Panel_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27635          { (char *)"Panel_InitDialog", (PyCFunction) _wrap_Panel_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27636          { (char *)"Panel_SetFocus", (PyCFunction) _wrap_Panel_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
27637          { (char *)"Panel_SetFocusIgnoringChildren", (PyCFunction) _wrap_Panel_SetFocusIgnoringChildren, METH_VARARGS | METH_KEYWORDS, NULL},
27638          { (char *)"Panel_GetClassDefaultAttributes", (PyCFunction) _wrap_Panel_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27639          { (char *)"Panel_swigregister", Panel_swigregister, METH_VARARGS, NULL},
27640          { (char *)"new_ScrolledWindow", (PyCFunction) _wrap_new_ScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27641          { (char *)"new_PreScrolledWindow", (PyCFunction) _wrap_new_PreScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27642          { (char *)"ScrolledWindow_Create", (PyCFunction) _wrap_ScrolledWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27643          { (char *)"ScrolledWindow_SetScrollbars", (PyCFunction) _wrap_ScrolledWindow_SetScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
27644          { (char *)"ScrolledWindow_Scroll", (PyCFunction) _wrap_ScrolledWindow_Scroll, METH_VARARGS | METH_KEYWORDS, NULL},
27645          { (char *)"ScrolledWindow_GetScrollPageSize", (PyCFunction) _wrap_ScrolledWindow_GetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
27646          { (char *)"ScrolledWindow_SetScrollPageSize", (PyCFunction) _wrap_ScrolledWindow_SetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
27647          { (char *)"ScrolledWindow_SetScrollRate", (PyCFunction) _wrap_ScrolledWindow_SetScrollRate, METH_VARARGS | METH_KEYWORDS, NULL},
27648          { (char *)"ScrolledWindow_GetScrollPixelsPerUnit", (PyCFunction) _wrap_ScrolledWindow_GetScrollPixelsPerUnit, METH_VARARGS | METH_KEYWORDS, NULL},
27649          { (char *)"ScrolledWindow_EnableScrolling", (PyCFunction) _wrap_ScrolledWindow_EnableScrolling, METH_VARARGS | METH_KEYWORDS, NULL},
27650          { (char *)"ScrolledWindow_GetViewStart", (PyCFunction) _wrap_ScrolledWindow_GetViewStart, METH_VARARGS | METH_KEYWORDS, NULL},
27651          { (char *)"ScrolledWindow_SetScale", (PyCFunction) _wrap_ScrolledWindow_SetScale, METH_VARARGS | METH_KEYWORDS, NULL},
27652          { (char *)"ScrolledWindow_GetScaleX", (PyCFunction) _wrap_ScrolledWindow_GetScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
27653          { (char *)"ScrolledWindow_GetScaleY", (PyCFunction) _wrap_ScrolledWindow_GetScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
27654          { (char *)"ScrolledWindow_CalcScrolledPosition", _wrap_ScrolledWindow_CalcScrolledPosition, METH_VARARGS, NULL},
27655          { (char *)"ScrolledWindow_CalcUnscrolledPosition", _wrap_ScrolledWindow_CalcUnscrolledPosition, METH_VARARGS, NULL},
27656          { (char *)"ScrolledWindow_AdjustScrollbars", (PyCFunction) _wrap_ScrolledWindow_AdjustScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
27657          { (char *)"ScrolledWindow_CalcScrollInc", (PyCFunction) _wrap_ScrolledWindow_CalcScrollInc, METH_VARARGS | METH_KEYWORDS, NULL},
27658          { (char *)"ScrolledWindow_SetTargetWindow", (PyCFunction) _wrap_ScrolledWindow_SetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27659          { (char *)"ScrolledWindow_GetTargetWindow", (PyCFunction) _wrap_ScrolledWindow_GetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27660          { (char *)"ScrolledWindow_SetTargetRect", (PyCFunction) _wrap_ScrolledWindow_SetTargetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27661          { (char *)"ScrolledWindow_GetTargetRect", (PyCFunction) _wrap_ScrolledWindow_GetTargetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27662          { (char *)"ScrolledWindow_DoPrepareDC", (PyCFunction) _wrap_ScrolledWindow_DoPrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
27663          { (char *)"ScrolledWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_ScrolledWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27664          { (char *)"ScrolledWindow_swigregister", ScrolledWindow_swigregister, METH_VARARGS, NULL},
27665          { (char *)"TopLevelWindow_Maximize", (PyCFunction) _wrap_TopLevelWindow_Maximize, METH_VARARGS | METH_KEYWORDS, NULL},
27666          { (char *)"TopLevelWindow_Restore", (PyCFunction) _wrap_TopLevelWindow_Restore, METH_VARARGS | METH_KEYWORDS, NULL},
27667          { (char *)"TopLevelWindow_Iconize", (PyCFunction) _wrap_TopLevelWindow_Iconize, METH_VARARGS | METH_KEYWORDS, NULL},
27668          { (char *)"TopLevelWindow_IsMaximized", (PyCFunction) _wrap_TopLevelWindow_IsMaximized, METH_VARARGS | METH_KEYWORDS, NULL},
27669          { (char *)"TopLevelWindow_IsIconized", (PyCFunction) _wrap_TopLevelWindow_IsIconized, METH_VARARGS | METH_KEYWORDS, NULL},
27670          { (char *)"TopLevelWindow_GetIcon", (PyCFunction) _wrap_TopLevelWindow_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27671          { (char *)"TopLevelWindow_SetIcon", (PyCFunction) _wrap_TopLevelWindow_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27672          { (char *)"TopLevelWindow_SetIcons", (PyCFunction) _wrap_TopLevelWindow_SetIcons, METH_VARARGS | METH_KEYWORDS, NULL},
27673          { (char *)"TopLevelWindow_ShowFullScreen", (PyCFunction) _wrap_TopLevelWindow_ShowFullScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27674          { (char *)"TopLevelWindow_IsFullScreen", (PyCFunction) _wrap_TopLevelWindow_IsFullScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27675          { (char *)"TopLevelWindow_SetTitle", (PyCFunction) _wrap_TopLevelWindow_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
27676          { (char *)"TopLevelWindow_GetTitle", (PyCFunction) _wrap_TopLevelWindow_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
27677          { (char *)"TopLevelWindow_SetShape", (PyCFunction) _wrap_TopLevelWindow_SetShape, METH_VARARGS | METH_KEYWORDS, NULL},
27678          { (char *)"TopLevelWindow_RequestUserAttention", (PyCFunction) _wrap_TopLevelWindow_RequestUserAttention, METH_VARARGS | METH_KEYWORDS, NULL},
27679          { (char *)"TopLevelWindow_IsActive", (PyCFunction) _wrap_TopLevelWindow_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
27680          { (char *)"TopLevelWindow_MacSetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacSetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
27681          { (char *)"TopLevelWindow_MacGetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacGetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
27682          { (char *)"TopLevelWindow_swigregister", TopLevelWindow_swigregister, METH_VARARGS, NULL},
27683          { (char *)"new_Frame", (PyCFunction) _wrap_new_Frame, METH_VARARGS | METH_KEYWORDS, NULL},
27684          { (char *)"new_PreFrame", (PyCFunction) _wrap_new_PreFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27685          { (char *)"Frame_Create", (PyCFunction) _wrap_Frame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27686          { (char *)"Frame_GetClientAreaOrigin", (PyCFunction) _wrap_Frame_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
27687          { (char *)"Frame_SendSizeEvent", (PyCFunction) _wrap_Frame_SendSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27688          { (char *)"Frame_SetMenuBar", (PyCFunction) _wrap_Frame_SetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
27689          { (char *)"Frame_GetMenuBar", (PyCFunction) _wrap_Frame_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
27690          { (char *)"Frame_ProcessCommand", (PyCFunction) _wrap_Frame_ProcessCommand, METH_VARARGS | METH_KEYWORDS, NULL},
27691          { (char *)"Frame_CreateStatusBar", (PyCFunction) _wrap_Frame_CreateStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27692          { (char *)"Frame_GetStatusBar", (PyCFunction) _wrap_Frame_GetStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27693          { (char *)"Frame_SetStatusBar", (PyCFunction) _wrap_Frame_SetStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27694          { (char *)"Frame_SetStatusText", (PyCFunction) _wrap_Frame_SetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27695          { (char *)"Frame_SetStatusWidths", (PyCFunction) _wrap_Frame_SetStatusWidths, METH_VARARGS | METH_KEYWORDS, NULL},
27696          { (char *)"Frame_PushStatusText", (PyCFunction) _wrap_Frame_PushStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27697          { (char *)"Frame_PopStatusText", (PyCFunction) _wrap_Frame_PopStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27698          { (char *)"Frame_SetStatusBarPane", (PyCFunction) _wrap_Frame_SetStatusBarPane, METH_VARARGS | METH_KEYWORDS, NULL},
27699          { (char *)"Frame_GetStatusBarPane", (PyCFunction) _wrap_Frame_GetStatusBarPane, METH_VARARGS | METH_KEYWORDS, NULL},
27700          { (char *)"Frame_CreateToolBar", (PyCFunction) _wrap_Frame_CreateToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27701          { (char *)"Frame_GetToolBar", (PyCFunction) _wrap_Frame_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27702          { (char *)"Frame_SetToolBar", (PyCFunction) _wrap_Frame_SetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
27703          { (char *)"Frame_DoGiveHelp", (PyCFunction) _wrap_Frame_DoGiveHelp, METH_VARARGS | METH_KEYWORDS, NULL},
27704          { (char *)"Frame_DoMenuUpdates", (PyCFunction) _wrap_Frame_DoMenuUpdates, METH_VARARGS | METH_KEYWORDS, NULL},
27705          { (char *)"Frame_GetClassDefaultAttributes", (PyCFunction) _wrap_Frame_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27706          { (char *)"Frame_swigregister", Frame_swigregister, METH_VARARGS, NULL},
27707          { (char *)"new_Dialog", (PyCFunction) _wrap_new_Dialog, METH_VARARGS | METH_KEYWORDS, NULL},
27708          { (char *)"new_PreDialog", (PyCFunction) _wrap_new_PreDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27709          { (char *)"Dialog_Create", (PyCFunction) _wrap_Dialog_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27710          { (char *)"Dialog_SetReturnCode", (PyCFunction) _wrap_Dialog_SetReturnCode, METH_VARARGS | METH_KEYWORDS, NULL},
27711          { (char *)"Dialog_GetReturnCode", (PyCFunction) _wrap_Dialog_GetReturnCode, METH_VARARGS | METH_KEYWORDS, NULL},
27712          { (char *)"Dialog_CreateTextSizer", (PyCFunction) _wrap_Dialog_CreateTextSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27713          { (char *)"Dialog_CreateButtonSizer", (PyCFunction) _wrap_Dialog_CreateButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27714          { (char *)"Dialog_CreateStdDialogButtonSizer", (PyCFunction) _wrap_Dialog_CreateStdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
27715          { (char *)"Dialog_IsModal", (PyCFunction) _wrap_Dialog_IsModal, METH_VARARGS | METH_KEYWORDS, NULL},
27716          { (char *)"Dialog_ShowModal", (PyCFunction) _wrap_Dialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
27717          { (char *)"Dialog_EndModal", (PyCFunction) _wrap_Dialog_EndModal, METH_VARARGS | METH_KEYWORDS, NULL},
27718          { (char *)"Dialog_GetClassDefaultAttributes", (PyCFunction) _wrap_Dialog_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27719          { (char *)"Dialog_swigregister", Dialog_swigregister, METH_VARARGS, NULL},
27720          { (char *)"new_MiniFrame", (PyCFunction) _wrap_new_MiniFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27721          { (char *)"new_PreMiniFrame", (PyCFunction) _wrap_new_PreMiniFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27722          { (char *)"MiniFrame_Create", (PyCFunction) _wrap_MiniFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27723          { (char *)"MiniFrame_swigregister", MiniFrame_swigregister, METH_VARARGS, NULL},
27724          { (char *)"new_SplashScreenWindow", (PyCFunction) _wrap_new_SplashScreenWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27725          { (char *)"SplashScreenWindow_SetBitmap", (PyCFunction) _wrap_SplashScreenWindow_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
27726          { (char *)"SplashScreenWindow_GetBitmap", (PyCFunction) _wrap_SplashScreenWindow_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
27727          { (char *)"SplashScreenWindow_swigregister", SplashScreenWindow_swigregister, METH_VARARGS, NULL},
27728          { (char *)"new_SplashScreen", (PyCFunction) _wrap_new_SplashScreen, METH_VARARGS | METH_KEYWORDS, NULL},
27729          { (char *)"SplashScreen_GetSplashStyle", (PyCFunction) _wrap_SplashScreen_GetSplashStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27730          { (char *)"SplashScreen_GetSplashWindow", (PyCFunction) _wrap_SplashScreen_GetSplashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27731          { (char *)"SplashScreen_GetTimeout", (PyCFunction) _wrap_SplashScreen_GetTimeout, METH_VARARGS | METH_KEYWORDS, NULL},
27732          { (char *)"SplashScreen_swigregister", SplashScreen_swigregister, METH_VARARGS, NULL},
27733          { (char *)"new_StatusBar", (PyCFunction) _wrap_new_StatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27734          { (char *)"new_PreStatusBar", (PyCFunction) _wrap_new_PreStatusBar, METH_VARARGS | METH_KEYWORDS, NULL},
27735          { (char *)"StatusBar_Create", (PyCFunction) _wrap_StatusBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27736          { (char *)"StatusBar_SetFieldsCount", (PyCFunction) _wrap_StatusBar_SetFieldsCount, METH_VARARGS | METH_KEYWORDS, NULL},
27737          { (char *)"StatusBar_GetFieldsCount", (PyCFunction) _wrap_StatusBar_GetFieldsCount, METH_VARARGS | METH_KEYWORDS, NULL},
27738          { (char *)"StatusBar_SetStatusText", (PyCFunction) _wrap_StatusBar_SetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27739          { (char *)"StatusBar_GetStatusText", (PyCFunction) _wrap_StatusBar_GetStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27740          { (char *)"StatusBar_PushStatusText", (PyCFunction) _wrap_StatusBar_PushStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27741          { (char *)"StatusBar_PopStatusText", (PyCFunction) _wrap_StatusBar_PopStatusText, METH_VARARGS | METH_KEYWORDS, NULL},
27742          { (char *)"StatusBar_SetStatusWidths", (PyCFunction) _wrap_StatusBar_SetStatusWidths, METH_VARARGS | METH_KEYWORDS, NULL},
27743          { (char *)"StatusBar_SetStatusStyles", (PyCFunction) _wrap_StatusBar_SetStatusStyles, METH_VARARGS | METH_KEYWORDS, NULL},
27744          { (char *)"StatusBar_GetFieldRect", (PyCFunction) _wrap_StatusBar_GetFieldRect, METH_VARARGS | METH_KEYWORDS, NULL},
27745          { (char *)"StatusBar_SetMinHeight", (PyCFunction) _wrap_StatusBar_SetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
27746          { (char *)"StatusBar_GetBorderX", (PyCFunction) _wrap_StatusBar_GetBorderX, METH_VARARGS | METH_KEYWORDS, NULL},
27747          { (char *)"StatusBar_GetBorderY", (PyCFunction) _wrap_StatusBar_GetBorderY, METH_VARARGS | METH_KEYWORDS, NULL},
27748          { (char *)"StatusBar_GetClassDefaultAttributes", (PyCFunction) _wrap_StatusBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27749          { (char *)"StatusBar_swigregister", StatusBar_swigregister, METH_VARARGS, NULL},
27750          { (char *)"new_SplitterWindow", (PyCFunction) _wrap_new_SplitterWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27751          { (char *)"new_PreSplitterWindow", (PyCFunction) _wrap_new_PreSplitterWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27752          { (char *)"SplitterWindow_Create", (PyCFunction) _wrap_SplitterWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27753          { (char *)"SplitterWindow_GetWindow1", (PyCFunction) _wrap_SplitterWindow_GetWindow1, METH_VARARGS | METH_KEYWORDS, NULL},
27754          { (char *)"SplitterWindow_GetWindow2", (PyCFunction) _wrap_SplitterWindow_GetWindow2, METH_VARARGS | METH_KEYWORDS, NULL},
27755          { (char *)"SplitterWindow_SetSplitMode", (PyCFunction) _wrap_SplitterWindow_SetSplitMode, METH_VARARGS | METH_KEYWORDS, NULL},
27756          { (char *)"SplitterWindow_GetSplitMode", (PyCFunction) _wrap_SplitterWindow_GetSplitMode, METH_VARARGS | METH_KEYWORDS, NULL},
27757          { (char *)"SplitterWindow_Initialize", (PyCFunction) _wrap_SplitterWindow_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
27758          { (char *)"SplitterWindow_SplitVertically", (PyCFunction) _wrap_SplitterWindow_SplitVertically, METH_VARARGS | METH_KEYWORDS, NULL},
27759          { (char *)"SplitterWindow_SplitHorizontally", (PyCFunction) _wrap_SplitterWindow_SplitHorizontally, METH_VARARGS | METH_KEYWORDS, NULL},
27760          { (char *)"SplitterWindow_Unsplit", (PyCFunction) _wrap_SplitterWindow_Unsplit, METH_VARARGS | METH_KEYWORDS, NULL},
27761          { (char *)"SplitterWindow_ReplaceWindow", (PyCFunction) _wrap_SplitterWindow_ReplaceWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27762          { (char *)"SplitterWindow_UpdateSize", (PyCFunction) _wrap_SplitterWindow_UpdateSize, METH_VARARGS | METH_KEYWORDS, NULL},
27763          { (char *)"SplitterWindow_IsSplit", (PyCFunction) _wrap_SplitterWindow_IsSplit, METH_VARARGS | METH_KEYWORDS, NULL},
27764          { (char *)"SplitterWindow_SetSashSize", (PyCFunction) _wrap_SplitterWindow_SetSashSize, METH_VARARGS | METH_KEYWORDS, NULL},
27765          { (char *)"SplitterWindow_SetBorderSize", (PyCFunction) _wrap_SplitterWindow_SetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27766          { (char *)"SplitterWindow_GetSashSize", (PyCFunction) _wrap_SplitterWindow_GetSashSize, METH_VARARGS | METH_KEYWORDS, NULL},
27767          { (char *)"SplitterWindow_GetBorderSize", (PyCFunction) _wrap_SplitterWindow_GetBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27768          { (char *)"SplitterWindow_SetSashPosition", (PyCFunction) _wrap_SplitterWindow_SetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27769          { (char *)"SplitterWindow_GetSashPosition", (PyCFunction) _wrap_SplitterWindow_GetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27770          { (char *)"SplitterWindow_SetSashGravity", (PyCFunction) _wrap_SplitterWindow_SetSashGravity, METH_VARARGS | METH_KEYWORDS, NULL},
27771          { (char *)"SplitterWindow_GetSashGravity", (PyCFunction) _wrap_SplitterWindow_GetSashGravity, METH_VARARGS | METH_KEYWORDS, NULL},
27772          { (char *)"SplitterWindow_SetMinimumPaneSize", (PyCFunction) _wrap_SplitterWindow_SetMinimumPaneSize, METH_VARARGS | METH_KEYWORDS, NULL},
27773          { (char *)"SplitterWindow_GetMinimumPaneSize", (PyCFunction) _wrap_SplitterWindow_GetMinimumPaneSize, METH_VARARGS | METH_KEYWORDS, NULL},
27774          { (char *)"SplitterWindow_SashHitTest", (PyCFunction) _wrap_SplitterWindow_SashHitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27775          { (char *)"SplitterWindow_SizeWindows", (PyCFunction) _wrap_SplitterWindow_SizeWindows, METH_VARARGS | METH_KEYWORDS, NULL},
27776          { (char *)"SplitterWindow_SetNeedUpdating", (PyCFunction) _wrap_SplitterWindow_SetNeedUpdating, METH_VARARGS | METH_KEYWORDS, NULL},
27777          { (char *)"SplitterWindow_GetNeedUpdating", (PyCFunction) _wrap_SplitterWindow_GetNeedUpdating, METH_VARARGS | METH_KEYWORDS, NULL},
27778          { (char *)"SplitterWindow_GetClassDefaultAttributes", (PyCFunction) _wrap_SplitterWindow_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
27779          { (char *)"SplitterWindow_swigregister", SplitterWindow_swigregister, METH_VARARGS, NULL},
27780          { (char *)"new_SplitterEvent", (PyCFunction) _wrap_new_SplitterEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27781          { (char *)"SplitterEvent_SetSashPosition", (PyCFunction) _wrap_SplitterEvent_SetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27782          { (char *)"SplitterEvent_GetSashPosition", (PyCFunction) _wrap_SplitterEvent_GetSashPosition, METH_VARARGS | METH_KEYWORDS, NULL},
27783          { (char *)"SplitterEvent_GetWindowBeingRemoved", (PyCFunction) _wrap_SplitterEvent_GetWindowBeingRemoved, METH_VARARGS | METH_KEYWORDS, NULL},
27784          { (char *)"SplitterEvent_GetX", (PyCFunction) _wrap_SplitterEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
27785          { (char *)"SplitterEvent_GetY", (PyCFunction) _wrap_SplitterEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
27786          { (char *)"SplitterEvent_swigregister", SplitterEvent_swigregister, METH_VARARGS, NULL},
27787          { (char *)"new_SashWindow", (PyCFunction) _wrap_new_SashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27788          { (char *)"new_PreSashWindow", (PyCFunction) _wrap_new_PreSashWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27789          { (char *)"SashWindow_Create", (PyCFunction) _wrap_SashWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27790          { (char *)"SashWindow_SetSashVisible", (PyCFunction) _wrap_SashWindow_SetSashVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27791          { (char *)"SashWindow_GetSashVisible", (PyCFunction) _wrap_SashWindow_GetSashVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27792          { (char *)"SashWindow_SetSashBorder", (PyCFunction) _wrap_SashWindow_SetSashBorder, METH_VARARGS | METH_KEYWORDS, NULL},
27793          { (char *)"SashWindow_HasBorder", (PyCFunction) _wrap_SashWindow_HasBorder, METH_VARARGS | METH_KEYWORDS, NULL},
27794          { (char *)"SashWindow_GetEdgeMargin", (PyCFunction) _wrap_SashWindow_GetEdgeMargin, METH_VARARGS | METH_KEYWORDS, NULL},
27795          { (char *)"SashWindow_SetDefaultBorderSize", (PyCFunction) _wrap_SashWindow_SetDefaultBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27796          { (char *)"SashWindow_GetDefaultBorderSize", (PyCFunction) _wrap_SashWindow_GetDefaultBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27797          { (char *)"SashWindow_SetExtraBorderSize", (PyCFunction) _wrap_SashWindow_SetExtraBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27798          { (char *)"SashWindow_GetExtraBorderSize", (PyCFunction) _wrap_SashWindow_GetExtraBorderSize, METH_VARARGS | METH_KEYWORDS, NULL},
27799          { (char *)"SashWindow_SetMinimumSizeX", (PyCFunction) _wrap_SashWindow_SetMinimumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27800          { (char *)"SashWindow_SetMinimumSizeY", (PyCFunction) _wrap_SashWindow_SetMinimumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27801          { (char *)"SashWindow_GetMinimumSizeX", (PyCFunction) _wrap_SashWindow_GetMinimumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27802          { (char *)"SashWindow_GetMinimumSizeY", (PyCFunction) _wrap_SashWindow_GetMinimumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27803          { (char *)"SashWindow_SetMaximumSizeX", (PyCFunction) _wrap_SashWindow_SetMaximumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27804          { (char *)"SashWindow_SetMaximumSizeY", (PyCFunction) _wrap_SashWindow_SetMaximumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27805          { (char *)"SashWindow_GetMaximumSizeX", (PyCFunction) _wrap_SashWindow_GetMaximumSizeX, METH_VARARGS | METH_KEYWORDS, NULL},
27806          { (char *)"SashWindow_GetMaximumSizeY", (PyCFunction) _wrap_SashWindow_GetMaximumSizeY, METH_VARARGS | METH_KEYWORDS, NULL},
27807          { (char *)"SashWindow_SashHitTest", (PyCFunction) _wrap_SashWindow_SashHitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27808          { (char *)"SashWindow_SizeWindows", (PyCFunction) _wrap_SashWindow_SizeWindows, METH_VARARGS | METH_KEYWORDS, NULL},
27809          { (char *)"SashWindow_swigregister", SashWindow_swigregister, METH_VARARGS, NULL},
27810          { (char *)"new_SashEvent", (PyCFunction) _wrap_new_SashEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27811          { (char *)"SashEvent_SetEdge", (PyCFunction) _wrap_SashEvent_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
27812          { (char *)"SashEvent_GetEdge", (PyCFunction) _wrap_SashEvent_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
27813          { (char *)"SashEvent_SetDragRect", (PyCFunction) _wrap_SashEvent_SetDragRect, METH_VARARGS | METH_KEYWORDS, NULL},
27814          { (char *)"SashEvent_GetDragRect", (PyCFunction) _wrap_SashEvent_GetDragRect, METH_VARARGS | METH_KEYWORDS, NULL},
27815          { (char *)"SashEvent_SetDragStatus", (PyCFunction) _wrap_SashEvent_SetDragStatus, METH_VARARGS | METH_KEYWORDS, NULL},
27816          { (char *)"SashEvent_GetDragStatus", (PyCFunction) _wrap_SashEvent_GetDragStatus, METH_VARARGS | METH_KEYWORDS, NULL},
27817          { (char *)"SashEvent_swigregister", SashEvent_swigregister, METH_VARARGS, NULL},
27818          { (char *)"new_QueryLayoutInfoEvent", (PyCFunction) _wrap_new_QueryLayoutInfoEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27819          { (char *)"QueryLayoutInfoEvent_SetRequestedLength", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetRequestedLength, METH_VARARGS | METH_KEYWORDS, NULL},
27820          { (char *)"QueryLayoutInfoEvent_GetRequestedLength", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetRequestedLength, METH_VARARGS | METH_KEYWORDS, NULL},
27821          { (char *)"QueryLayoutInfoEvent_SetFlags", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27822          { (char *)"QueryLayoutInfoEvent_GetFlags", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27823          { (char *)"QueryLayoutInfoEvent_SetSize", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
27824          { (char *)"QueryLayoutInfoEvent_GetSize", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
27825          { (char *)"QueryLayoutInfoEvent_SetOrientation", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27826          { (char *)"QueryLayoutInfoEvent_GetOrientation", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27827          { (char *)"QueryLayoutInfoEvent_SetAlignment", (PyCFunction) _wrap_QueryLayoutInfoEvent_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27828          { (char *)"QueryLayoutInfoEvent_GetAlignment", (PyCFunction) _wrap_QueryLayoutInfoEvent_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27829          { (char *)"QueryLayoutInfoEvent_swigregister", QueryLayoutInfoEvent_swigregister, METH_VARARGS, NULL},
27830          { (char *)"new_CalculateLayoutEvent", (PyCFunction) _wrap_new_CalculateLayoutEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27831          { (char *)"CalculateLayoutEvent_SetFlags", (PyCFunction) _wrap_CalculateLayoutEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27832          { (char *)"CalculateLayoutEvent_GetFlags", (PyCFunction) _wrap_CalculateLayoutEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
27833          { (char *)"CalculateLayoutEvent_SetRect", (PyCFunction) _wrap_CalculateLayoutEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27834          { (char *)"CalculateLayoutEvent_GetRect", (PyCFunction) _wrap_CalculateLayoutEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
27835          { (char *)"CalculateLayoutEvent_swigregister", CalculateLayoutEvent_swigregister, METH_VARARGS, NULL},
27836          { (char *)"new_SashLayoutWindow", (PyCFunction) _wrap_new_SashLayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27837          { (char *)"new_PreSashLayoutWindow", (PyCFunction) _wrap_new_PreSashLayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27838          { (char *)"SashLayoutWindow_Create", (PyCFunction) _wrap_SashLayoutWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27839          { (char *)"SashLayoutWindow_GetAlignment", (PyCFunction) _wrap_SashLayoutWindow_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27840          { (char *)"SashLayoutWindow_GetOrientation", (PyCFunction) _wrap_SashLayoutWindow_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27841          { (char *)"SashLayoutWindow_SetAlignment", (PyCFunction) _wrap_SashLayoutWindow_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
27842          { (char *)"SashLayoutWindow_SetDefaultSize", (PyCFunction) _wrap_SashLayoutWindow_SetDefaultSize, METH_VARARGS | METH_KEYWORDS, NULL},
27843          { (char *)"SashLayoutWindow_SetOrientation", (PyCFunction) _wrap_SashLayoutWindow_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
27844          { (char *)"SashLayoutWindow_swigregister", SashLayoutWindow_swigregister, METH_VARARGS, NULL},
27845          { (char *)"new_LayoutAlgorithm", (PyCFunction) _wrap_new_LayoutAlgorithm, METH_VARARGS | METH_KEYWORDS, NULL},
27846          { (char *)"delete_LayoutAlgorithm", (PyCFunction) _wrap_delete_LayoutAlgorithm, METH_VARARGS | METH_KEYWORDS, NULL},
27847          { (char *)"LayoutAlgorithm_LayoutMDIFrame", (PyCFunction) _wrap_LayoutAlgorithm_LayoutMDIFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27848          { (char *)"LayoutAlgorithm_LayoutFrame", (PyCFunction) _wrap_LayoutAlgorithm_LayoutFrame, METH_VARARGS | METH_KEYWORDS, NULL},
27849          { (char *)"LayoutAlgorithm_LayoutWindow", (PyCFunction) _wrap_LayoutAlgorithm_LayoutWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27850          { (char *)"LayoutAlgorithm_swigregister", LayoutAlgorithm_swigregister, METH_VARARGS, NULL},
27851          { (char *)"new_PopupWindow", (PyCFunction) _wrap_new_PopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27852          { (char *)"new_PrePopupWindow", (PyCFunction) _wrap_new_PrePopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27853          { (char *)"PopupWindow_swigregister", PopupWindow_swigregister, METH_VARARGS, NULL},
27854          { (char *)"new_PopupTransientWindow", (PyCFunction) _wrap_new_PopupTransientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27855          { (char *)"new_PrePopupTransientWindow", (PyCFunction) _wrap_new_PrePopupTransientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27856          { (char *)"PopupTransientWindow_swigregister", PopupTransientWindow_swigregister, METH_VARARGS, NULL},
27857          { (char *)"new_TipWindow", (PyCFunction) _wrap_new_TipWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27858          { (char *)"TipWindow_SetBoundingRect", (PyCFunction) _wrap_TipWindow_SetBoundingRect, METH_VARARGS | METH_KEYWORDS, NULL},
27859          { (char *)"TipWindow_Close", (PyCFunction) _wrap_TipWindow_Close, METH_VARARGS | METH_KEYWORDS, NULL},
27860          { (char *)"TipWindow_swigregister", TipWindow_swigregister, METH_VARARGS, NULL},
27861          { (char *)"new_VScrolledWindow", (PyCFunction) _wrap_new_VScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27862          { (char *)"new_PreVScrolledWindow", (PyCFunction) _wrap_new_PreVScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
27863          { (char *)"VScrolledWindow__setCallbackInfo", (PyCFunction) _wrap_VScrolledWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27864          { (char *)"VScrolledWindow_Create", (PyCFunction) _wrap_VScrolledWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27865          { (char *)"VScrolledWindow_SetLineCount", (PyCFunction) _wrap_VScrolledWindow_SetLineCount, METH_VARARGS | METH_KEYWORDS, NULL},
27866          { (char *)"VScrolledWindow_ScrollToLine", (PyCFunction) _wrap_VScrolledWindow_ScrollToLine, METH_VARARGS | METH_KEYWORDS, NULL},
27867          { (char *)"VScrolledWindow_ScrollLines", (PyCFunction) _wrap_VScrolledWindow_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
27868          { (char *)"VScrolledWindow_ScrollPages", (PyCFunction) _wrap_VScrolledWindow_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
27869          { (char *)"VScrolledWindow_RefreshLine", (PyCFunction) _wrap_VScrolledWindow_RefreshLine, METH_VARARGS | METH_KEYWORDS, NULL},
27870          { (char *)"VScrolledWindow_RefreshLines", (PyCFunction) _wrap_VScrolledWindow_RefreshLines, METH_VARARGS | METH_KEYWORDS, NULL},
27871          { (char *)"VScrolledWindow_HitTestXY", (PyCFunction) _wrap_VScrolledWindow_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
27872          { (char *)"VScrolledWindow_HitTest", (PyCFunction) _wrap_VScrolledWindow_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
27873          { (char *)"VScrolledWindow_RefreshAll", (PyCFunction) _wrap_VScrolledWindow_RefreshAll, METH_VARARGS | METH_KEYWORDS, NULL},
27874          { (char *)"VScrolledWindow_GetLineCount", (PyCFunction) _wrap_VScrolledWindow_GetLineCount, METH_VARARGS | METH_KEYWORDS, NULL},
27875          { (char *)"VScrolledWindow_GetVisibleBegin", (PyCFunction) _wrap_VScrolledWindow_GetVisibleBegin, METH_VARARGS | METH_KEYWORDS, NULL},
27876          { (char *)"VScrolledWindow_GetVisibleEnd", (PyCFunction) _wrap_VScrolledWindow_GetVisibleEnd, METH_VARARGS | METH_KEYWORDS, NULL},
27877          { (char *)"VScrolledWindow_IsVisible", (PyCFunction) _wrap_VScrolledWindow_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
27878          { (char *)"VScrolledWindow_GetFirstVisibleLine", (PyCFunction) _wrap_VScrolledWindow_GetFirstVisibleLine, METH_VARARGS | METH_KEYWORDS, NULL},
27879          { (char *)"VScrolledWindow_GetLastVisibleLine", (PyCFunction) _wrap_VScrolledWindow_GetLastVisibleLine, METH_VARARGS | METH_KEYWORDS, NULL},
27880          { (char *)"VScrolledWindow_swigregister", VScrolledWindow_swigregister, METH_VARARGS, NULL},
27881          { (char *)"new_VListBox", (PyCFunction) _wrap_new_VListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27882          { (char *)"new_PreVListBox", (PyCFunction) _wrap_new_PreVListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27883          { (char *)"VListBox__setCallbackInfo", (PyCFunction) _wrap_VListBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27884          { (char *)"VListBox_Create", (PyCFunction) _wrap_VListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27885          { (char *)"VListBox_GetItemCount", (PyCFunction) _wrap_VListBox_GetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
27886          { (char *)"VListBox_HasMultipleSelection", (PyCFunction) _wrap_VListBox_HasMultipleSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27887          { (char *)"VListBox_GetSelection", (PyCFunction) _wrap_VListBox_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27888          { (char *)"VListBox_IsCurrent", (PyCFunction) _wrap_VListBox_IsCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
27889          { (char *)"VListBox_IsSelected", (PyCFunction) _wrap_VListBox_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
27890          { (char *)"VListBox_GetSelectedCount", (PyCFunction) _wrap_VListBox_GetSelectedCount, METH_VARARGS | METH_KEYWORDS, NULL},
27891          { (char *)"VListBox_GetFirstSelected", (PyCFunction) _wrap_VListBox_GetFirstSelected, METH_VARARGS | METH_KEYWORDS, NULL},
27892          { (char *)"VListBox_GetNextSelected", (PyCFunction) _wrap_VListBox_GetNextSelected, METH_VARARGS | METH_KEYWORDS, NULL},
27893          { (char *)"VListBox_GetMargins", (PyCFunction) _wrap_VListBox_GetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
27894          { (char *)"VListBox_GetSelectionBackground", (PyCFunction) _wrap_VListBox_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
27895          { (char *)"VListBox_SetItemCount", (PyCFunction) _wrap_VListBox_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
27896          { (char *)"VListBox_Clear", (PyCFunction) _wrap_VListBox_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
27897          { (char *)"VListBox_SetSelection", (PyCFunction) _wrap_VListBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27898          { (char *)"VListBox_Select", (PyCFunction) _wrap_VListBox_Select, METH_VARARGS | METH_KEYWORDS, NULL},
27899          { (char *)"VListBox_SelectRange", (PyCFunction) _wrap_VListBox_SelectRange, METH_VARARGS | METH_KEYWORDS, NULL},
27900          { (char *)"VListBox_Toggle", (PyCFunction) _wrap_VListBox_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
27901          { (char *)"VListBox_SelectAll", (PyCFunction) _wrap_VListBox_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
27902          { (char *)"VListBox_DeselectAll", (PyCFunction) _wrap_VListBox_DeselectAll, METH_VARARGS | METH_KEYWORDS, NULL},
27903          { (char *)"VListBox_SetMargins", (PyCFunction) _wrap_VListBox_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
27904          { (char *)"VListBox_SetMarginsXY", (PyCFunction) _wrap_VListBox_SetMarginsXY, METH_VARARGS | METH_KEYWORDS, NULL},
27905          { (char *)"VListBox_SetSelectionBackground", (PyCFunction) _wrap_VListBox_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
27906          { (char *)"VListBox_swigregister", VListBox_swigregister, METH_VARARGS, NULL},
27907          { (char *)"new_HtmlListBox", (PyCFunction) _wrap_new_HtmlListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27908          { (char *)"new_PreHtmlListBox", (PyCFunction) _wrap_new_PreHtmlListBox, METH_VARARGS | METH_KEYWORDS, NULL},
27909          { (char *)"HtmlListBox__setCallbackInfo", (PyCFunction) _wrap_HtmlListBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27910          { (char *)"HtmlListBox_Create", (PyCFunction) _wrap_HtmlListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
27911          { (char *)"HtmlListBox_RefreshAll", (PyCFunction) _wrap_HtmlListBox_RefreshAll, METH_VARARGS | METH_KEYWORDS, NULL},
27912          { (char *)"HtmlListBox_SetItemCount", (PyCFunction) _wrap_HtmlListBox_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
27913          { (char *)"HtmlListBox_GetFileSystem", (PyCFunction) _wrap_HtmlListBox_GetFileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
27914          { (char *)"HtmlListBox_swigregister", HtmlListBox_swigregister, METH_VARARGS, NULL},
27915          { (char *)"new_TaskBarIcon", (PyCFunction) _wrap_new_TaskBarIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27916          { (char *)"TaskBarIcon__setCallbackInfo", (PyCFunction) _wrap_TaskBarIcon__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
27917          { (char *)"TaskBarIcon_Destroy", (PyCFunction) _wrap_TaskBarIcon_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
27918          { (char *)"TaskBarIcon_IsOk", (PyCFunction) _wrap_TaskBarIcon_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
27919          { (char *)"TaskBarIcon_IsIconInstalled", (PyCFunction) _wrap_TaskBarIcon_IsIconInstalled, METH_VARARGS | METH_KEYWORDS, NULL},
27920          { (char *)"TaskBarIcon_SetIcon", (PyCFunction) _wrap_TaskBarIcon_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27921          { (char *)"TaskBarIcon_RemoveIcon", (PyCFunction) _wrap_TaskBarIcon_RemoveIcon, METH_VARARGS | METH_KEYWORDS, NULL},
27922          { (char *)"TaskBarIcon_PopupMenu", (PyCFunction) _wrap_TaskBarIcon_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
27923          { (char *)"TaskBarIcon_swigregister", TaskBarIcon_swigregister, METH_VARARGS, NULL},
27924          { (char *)"new_TaskBarIconEvent", (PyCFunction) _wrap_new_TaskBarIconEvent, METH_VARARGS | METH_KEYWORDS, NULL},
27925          { (char *)"TaskBarIconEvent_swigregister", TaskBarIconEvent_swigregister, METH_VARARGS, NULL},
27926          { (char *)"new_ColourData", (PyCFunction) _wrap_new_ColourData, METH_VARARGS | METH_KEYWORDS, NULL},
27927          { (char *)"delete_ColourData", (PyCFunction) _wrap_delete_ColourData, METH_VARARGS | METH_KEYWORDS, NULL},
27928          { (char *)"ColourData_GetChooseFull", (PyCFunction) _wrap_ColourData_GetChooseFull, METH_VARARGS | METH_KEYWORDS, NULL},
27929          { (char *)"ColourData_GetColour", (PyCFunction) _wrap_ColourData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
27930          { (char *)"ColourData_GetCustomColour", (PyCFunction) _wrap_ColourData_GetCustomColour, METH_VARARGS | METH_KEYWORDS, NULL},
27931          { (char *)"ColourData_SetChooseFull", (PyCFunction) _wrap_ColourData_SetChooseFull, METH_VARARGS | METH_KEYWORDS, NULL},
27932          { (char *)"ColourData_SetColour", (PyCFunction) _wrap_ColourData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
27933          { (char *)"ColourData_SetCustomColour", (PyCFunction) _wrap_ColourData_SetCustomColour, METH_VARARGS | METH_KEYWORDS, NULL},
27934          { (char *)"ColourData_swigregister", ColourData_swigregister, METH_VARARGS, NULL},
27935          { (char *)"new_ColourDialog", (PyCFunction) _wrap_new_ColourDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27936          { (char *)"ColourDialog_GetColourData", (PyCFunction) _wrap_ColourDialog_GetColourData, METH_VARARGS | METH_KEYWORDS, NULL},
27937          { (char *)"ColourDialog_swigregister", ColourDialog_swigregister, METH_VARARGS, NULL},
27938          { (char *)"new_DirDialog", (PyCFunction) _wrap_new_DirDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27939          { (char *)"DirDialog_GetPath", (PyCFunction) _wrap_DirDialog_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27940          { (char *)"DirDialog_GetMessage", (PyCFunction) _wrap_DirDialog_GetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27941          { (char *)"DirDialog_GetStyle", (PyCFunction) _wrap_DirDialog_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27942          { (char *)"DirDialog_SetMessage", (PyCFunction) _wrap_DirDialog_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27943          { (char *)"DirDialog_SetPath", (PyCFunction) _wrap_DirDialog_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27944          { (char *)"DirDialog_swigregister", DirDialog_swigregister, METH_VARARGS, NULL},
27945          { (char *)"new_FileDialog", (PyCFunction) _wrap_new_FileDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27946          { (char *)"FileDialog_SetMessage", (PyCFunction) _wrap_FileDialog_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27947          { (char *)"FileDialog_SetPath", (PyCFunction) _wrap_FileDialog_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27948          { (char *)"FileDialog_SetDirectory", (PyCFunction) _wrap_FileDialog_SetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
27949          { (char *)"FileDialog_SetFilename", (PyCFunction) _wrap_FileDialog_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
27950          { (char *)"FileDialog_SetWildcard", (PyCFunction) _wrap_FileDialog_SetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
27951          { (char *)"FileDialog_SetStyle", (PyCFunction) _wrap_FileDialog_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27952          { (char *)"FileDialog_SetFilterIndex", (PyCFunction) _wrap_FileDialog_SetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
27953          { (char *)"FileDialog_GetMessage", (PyCFunction) _wrap_FileDialog_GetMessage, METH_VARARGS | METH_KEYWORDS, NULL},
27954          { (char *)"FileDialog_GetPath", (PyCFunction) _wrap_FileDialog_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
27955          { (char *)"FileDialog_GetDirectory", (PyCFunction) _wrap_FileDialog_GetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
27956          { (char *)"FileDialog_GetFilename", (PyCFunction) _wrap_FileDialog_GetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
27957          { (char *)"FileDialog_GetWildcard", (PyCFunction) _wrap_FileDialog_GetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
27958          { (char *)"FileDialog_GetStyle", (PyCFunction) _wrap_FileDialog_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
27959          { (char *)"FileDialog_GetFilterIndex", (PyCFunction) _wrap_FileDialog_GetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
27960          { (char *)"FileDialog_GetFilenames", (PyCFunction) _wrap_FileDialog_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
27961          { (char *)"FileDialog_GetPaths", (PyCFunction) _wrap_FileDialog_GetPaths, METH_VARARGS | METH_KEYWORDS, NULL},
27962          { (char *)"FileDialog_swigregister", FileDialog_swigregister, METH_VARARGS, NULL},
27963          { (char *)"new_MultiChoiceDialog", (PyCFunction) _wrap_new_MultiChoiceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27964          { (char *)"MultiChoiceDialog_SetSelections", (PyCFunction) _wrap_MultiChoiceDialog_SetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
27965          { (char *)"MultiChoiceDialog_GetSelections", (PyCFunction) _wrap_MultiChoiceDialog_GetSelections, METH_VARARGS | METH_KEYWORDS, NULL},
27966          { (char *)"MultiChoiceDialog_swigregister", MultiChoiceDialog_swigregister, METH_VARARGS, NULL},
27967          { (char *)"new_SingleChoiceDialog", (PyCFunction) _wrap_new_SingleChoiceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27968          { (char *)"SingleChoiceDialog_GetSelection", (PyCFunction) _wrap_SingleChoiceDialog_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27969          { (char *)"SingleChoiceDialog_GetStringSelection", (PyCFunction) _wrap_SingleChoiceDialog_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27970          { (char *)"SingleChoiceDialog_SetSelection", (PyCFunction) _wrap_SingleChoiceDialog_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
27971          { (char *)"SingleChoiceDialog_swigregister", SingleChoiceDialog_swigregister, METH_VARARGS, NULL},
27972          { (char *)"new_TextEntryDialog", (PyCFunction) _wrap_new_TextEntryDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27973          { (char *)"TextEntryDialog_GetValue", (PyCFunction) _wrap_TextEntryDialog_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
27974          { (char *)"TextEntryDialog_SetValue", (PyCFunction) _wrap_TextEntryDialog_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
27975          { (char *)"TextEntryDialog_swigregister", TextEntryDialog_swigregister, METH_VARARGS, NULL},
27976          { (char *)"new_PasswordEntryDialog", (PyCFunction) _wrap_new_PasswordEntryDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27977          { (char *)"PasswordEntryDialog_swigregister", PasswordEntryDialog_swigregister, METH_VARARGS, NULL},
27978          { (char *)"new_FontData", (PyCFunction) _wrap_new_FontData, METH_VARARGS | METH_KEYWORDS, NULL},
27979          { (char *)"delete_FontData", (PyCFunction) _wrap_delete_FontData, METH_VARARGS | METH_KEYWORDS, NULL},
27980          { (char *)"FontData_EnableEffects", (PyCFunction) _wrap_FontData_EnableEffects, METH_VARARGS | METH_KEYWORDS, NULL},
27981          { (char *)"FontData_GetAllowSymbols", (PyCFunction) _wrap_FontData_GetAllowSymbols, METH_VARARGS | METH_KEYWORDS, NULL},
27982          { (char *)"FontData_GetColour", (PyCFunction) _wrap_FontData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
27983          { (char *)"FontData_GetChosenFont", (PyCFunction) _wrap_FontData_GetChosenFont, METH_VARARGS | METH_KEYWORDS, NULL},
27984          { (char *)"FontData_GetEnableEffects", (PyCFunction) _wrap_FontData_GetEnableEffects, METH_VARARGS | METH_KEYWORDS, NULL},
27985          { (char *)"FontData_GetInitialFont", (PyCFunction) _wrap_FontData_GetInitialFont, METH_VARARGS | METH_KEYWORDS, NULL},
27986          { (char *)"FontData_GetShowHelp", (PyCFunction) _wrap_FontData_GetShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
27987          { (char *)"FontData_SetAllowSymbols", (PyCFunction) _wrap_FontData_SetAllowSymbols, METH_VARARGS | METH_KEYWORDS, NULL},
27988          { (char *)"FontData_SetChosenFont", (PyCFunction) _wrap_FontData_SetChosenFont, METH_VARARGS | METH_KEYWORDS, NULL},
27989          { (char *)"FontData_SetColour", (PyCFunction) _wrap_FontData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
27990          { (char *)"FontData_SetInitialFont", (PyCFunction) _wrap_FontData_SetInitialFont, METH_VARARGS | METH_KEYWORDS, NULL},
27991          { (char *)"FontData_SetRange", (PyCFunction) _wrap_FontData_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
27992          { (char *)"FontData_SetShowHelp", (PyCFunction) _wrap_FontData_SetShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
27993          { (char *)"FontData_swigregister", FontData_swigregister, METH_VARARGS, NULL},
27994          { (char *)"new_FontDialog", (PyCFunction) _wrap_new_FontDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27995          { (char *)"FontDialog_GetFontData", (PyCFunction) _wrap_FontDialog_GetFontData, METH_VARARGS | METH_KEYWORDS, NULL},
27996          { (char *)"FontDialog_swigregister", FontDialog_swigregister, METH_VARARGS, NULL},
27997          { (char *)"new_MessageDialog", (PyCFunction) _wrap_new_MessageDialog, METH_VARARGS | METH_KEYWORDS, NULL},
27998          { (char *)"MessageDialog_swigregister", MessageDialog_swigregister, METH_VARARGS, NULL},
27999          { (char *)"new_ProgressDialog", (PyCFunction) _wrap_new_ProgressDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28000          { (char *)"ProgressDialog_Update", (PyCFunction) _wrap_ProgressDialog_Update, METH_VARARGS | METH_KEYWORDS, NULL},
28001          { (char *)"ProgressDialog_Resume", (PyCFunction) _wrap_ProgressDialog_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
28002          { (char *)"ProgressDialog_swigregister", ProgressDialog_swigregister, METH_VARARGS, NULL},
28003          { (char *)"new_FindDialogEvent", (PyCFunction) _wrap_new_FindDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
28004          { (char *)"FindDialogEvent_GetFlags", (PyCFunction) _wrap_FindDialogEvent_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28005          { (char *)"FindDialogEvent_GetFindString", (PyCFunction) _wrap_FindDialogEvent_GetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28006          { (char *)"FindDialogEvent_GetReplaceString", (PyCFunction) _wrap_FindDialogEvent_GetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28007          { (char *)"FindDialogEvent_GetDialog", (PyCFunction) _wrap_FindDialogEvent_GetDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28008          { (char *)"FindDialogEvent_SetFlags", (PyCFunction) _wrap_FindDialogEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28009          { (char *)"FindDialogEvent_SetFindString", (PyCFunction) _wrap_FindDialogEvent_SetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28010          { (char *)"FindDialogEvent_SetReplaceString", (PyCFunction) _wrap_FindDialogEvent_SetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28011          { (char *)"FindDialogEvent_swigregister", FindDialogEvent_swigregister, METH_VARARGS, NULL},
28012          { (char *)"new_FindReplaceData", (PyCFunction) _wrap_new_FindReplaceData, METH_VARARGS | METH_KEYWORDS, NULL},
28013          { (char *)"delete_FindReplaceData", (PyCFunction) _wrap_delete_FindReplaceData, METH_VARARGS | METH_KEYWORDS, NULL},
28014          { (char *)"FindReplaceData_GetFindString", (PyCFunction) _wrap_FindReplaceData_GetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28015          { (char *)"FindReplaceData_GetReplaceString", (PyCFunction) _wrap_FindReplaceData_GetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28016          { (char *)"FindReplaceData_GetFlags", (PyCFunction) _wrap_FindReplaceData_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28017          { (char *)"FindReplaceData_SetFlags", (PyCFunction) _wrap_FindReplaceData_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
28018          { (char *)"FindReplaceData_SetFindString", (PyCFunction) _wrap_FindReplaceData_SetFindString, METH_VARARGS | METH_KEYWORDS, NULL},
28019          { (char *)"FindReplaceData_SetReplaceString", (PyCFunction) _wrap_FindReplaceData_SetReplaceString, METH_VARARGS | METH_KEYWORDS, NULL},
28020          { (char *)"FindReplaceData_swigregister", FindReplaceData_swigregister, METH_VARARGS, NULL},
28021          { (char *)"new_FindReplaceDialog", (PyCFunction) _wrap_new_FindReplaceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28022          { (char *)"new_PreFindReplaceDialog", (PyCFunction) _wrap_new_PreFindReplaceDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28023          { (char *)"FindReplaceDialog_Create", (PyCFunction) _wrap_FindReplaceDialog_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28024          { (char *)"FindReplaceDialog_GetData", (PyCFunction) _wrap_FindReplaceDialog_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
28025          { (char *)"FindReplaceDialog_SetData", (PyCFunction) _wrap_FindReplaceDialog_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
28026          { (char *)"FindReplaceDialog_swigregister", FindReplaceDialog_swigregister, METH_VARARGS, NULL},
28027          { (char *)"new_MDIParentFrame", (PyCFunction) _wrap_new_MDIParentFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28028          { (char *)"new_PreMDIParentFrame", (PyCFunction) _wrap_new_PreMDIParentFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28029          { (char *)"MDIParentFrame_Create", (PyCFunction) _wrap_MDIParentFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28030          { (char *)"MDIParentFrame_ActivateNext", (PyCFunction) _wrap_MDIParentFrame_ActivateNext, METH_VARARGS | METH_KEYWORDS, NULL},
28031          { (char *)"MDIParentFrame_ActivatePrevious", (PyCFunction) _wrap_MDIParentFrame_ActivatePrevious, METH_VARARGS | METH_KEYWORDS, NULL},
28032          { (char *)"MDIParentFrame_ArrangeIcons", (PyCFunction) _wrap_MDIParentFrame_ArrangeIcons, METH_VARARGS | METH_KEYWORDS, NULL},
28033          { (char *)"MDIParentFrame_Cascade", (PyCFunction) _wrap_MDIParentFrame_Cascade, METH_VARARGS | METH_KEYWORDS, NULL},
28034          { (char *)"MDIParentFrame_GetActiveChild", (PyCFunction) _wrap_MDIParentFrame_GetActiveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28035          { (char *)"MDIParentFrame_GetClientWindow", (PyCFunction) _wrap_MDIParentFrame_GetClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28036          { (char *)"MDIParentFrame_GetToolBar", (PyCFunction) _wrap_MDIParentFrame_GetToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
28037          { (char *)"MDIParentFrame_Tile", (PyCFunction) _wrap_MDIParentFrame_Tile, METH_VARARGS | METH_KEYWORDS, NULL},
28038          { (char *)"MDIParentFrame_swigregister", MDIParentFrame_swigregister, METH_VARARGS, NULL},
28039          { (char *)"new_MDIChildFrame", (PyCFunction) _wrap_new_MDIChildFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28040          { (char *)"new_PreMDIChildFrame", (PyCFunction) _wrap_new_PreMDIChildFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28041          { (char *)"MDIChildFrame_Create", (PyCFunction) _wrap_MDIChildFrame_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28042          { (char *)"MDIChildFrame_Activate", (PyCFunction) _wrap_MDIChildFrame_Activate, METH_VARARGS | METH_KEYWORDS, NULL},
28043          { (char *)"MDIChildFrame_Maximize", (PyCFunction) _wrap_MDIChildFrame_Maximize, METH_VARARGS | METH_KEYWORDS, NULL},
28044          { (char *)"MDIChildFrame_Restore", (PyCFunction) _wrap_MDIChildFrame_Restore, METH_VARARGS | METH_KEYWORDS, NULL},
28045          { (char *)"MDIChildFrame_swigregister", MDIChildFrame_swigregister, METH_VARARGS, NULL},
28046          { (char *)"new_MDIClientWindow", (PyCFunction) _wrap_new_MDIClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28047          { (char *)"new_PreMDIClientWindow", (PyCFunction) _wrap_new_PreMDIClientWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28048          { (char *)"MDIClientWindow_Create", (PyCFunction) _wrap_MDIClientWindow_Create, METH_VARARGS | METH_KEYWORDS, NULL},
28049          { (char *)"MDIClientWindow_swigregister", MDIClientWindow_swigregister, METH_VARARGS, NULL},
28050          { (char *)"new_PyWindow", (PyCFunction) _wrap_new_PyWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28051          { (char *)"new_PrePyWindow", (PyCFunction) _wrap_new_PrePyWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28052          { (char *)"PyWindow__setCallbackInfo", (PyCFunction) _wrap_PyWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28053          { (char *)"PyWindow_SetBestSize", (PyCFunction) _wrap_PyWindow_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28054          { (char *)"PyWindow_DoEraseBackground", (PyCFunction) _wrap_PyWindow_DoEraseBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28055          { (char *)"PyWindow_base_DoMoveWindow", (PyCFunction) _wrap_PyWindow_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28056          { (char *)"PyWindow_base_DoSetSize", (PyCFunction) _wrap_PyWindow_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28057          { (char *)"PyWindow_base_DoSetClientSize", (PyCFunction) _wrap_PyWindow_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28058          { (char *)"PyWindow_base_DoSetVirtualSize", (PyCFunction) _wrap_PyWindow_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28059          { (char *)"PyWindow_base_DoGetSize", (PyCFunction) _wrap_PyWindow_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28060          { (char *)"PyWindow_base_DoGetClientSize", (PyCFunction) _wrap_PyWindow_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28061          { (char *)"PyWindow_base_DoGetPosition", (PyCFunction) _wrap_PyWindow_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28062          { (char *)"PyWindow_base_DoGetVirtualSize", (PyCFunction) _wrap_PyWindow_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28063          { (char *)"PyWindow_base_DoGetBestSize", (PyCFunction) _wrap_PyWindow_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28064          { (char *)"PyWindow_base_InitDialog", (PyCFunction) _wrap_PyWindow_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28065          { (char *)"PyWindow_base_TransferDataToWindow", (PyCFunction) _wrap_PyWindow_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28066          { (char *)"PyWindow_base_TransferDataFromWindow", (PyCFunction) _wrap_PyWindow_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28067          { (char *)"PyWindow_base_Validate", (PyCFunction) _wrap_PyWindow_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28068          { (char *)"PyWindow_base_AcceptsFocus", (PyCFunction) _wrap_PyWindow_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28069          { (char *)"PyWindow_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyWindow_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28070          { (char *)"PyWindow_base_GetMaxSize", (PyCFunction) _wrap_PyWindow_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28071          { (char *)"PyWindow_base_AddChild", (PyCFunction) _wrap_PyWindow_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28072          { (char *)"PyWindow_base_RemoveChild", (PyCFunction) _wrap_PyWindow_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28073          { (char *)"PyWindow_base_ShouldInheritColours", (PyCFunction) _wrap_PyWindow_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28074          { (char *)"PyWindow_base_GetDefaultAttributes", (PyCFunction) _wrap_PyWindow_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28075          { (char *)"PyWindow_swigregister", PyWindow_swigregister, METH_VARARGS, NULL},
28076          { (char *)"new_PyPanel", (PyCFunction) _wrap_new_PyPanel, METH_VARARGS | METH_KEYWORDS, NULL},
28077          { (char *)"new_PrePyPanel", (PyCFunction) _wrap_new_PrePyPanel, METH_VARARGS | METH_KEYWORDS, NULL},
28078          { (char *)"PyPanel__setCallbackInfo", (PyCFunction) _wrap_PyPanel__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28079          { (char *)"PyPanel_SetBestSize", (PyCFunction) _wrap_PyPanel_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28080          { (char *)"PyPanel_DoEraseBackground", (PyCFunction) _wrap_PyPanel_DoEraseBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28081          { (char *)"PyPanel_base_DoMoveWindow", (PyCFunction) _wrap_PyPanel_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28082          { (char *)"PyPanel_base_DoSetSize", (PyCFunction) _wrap_PyPanel_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28083          { (char *)"PyPanel_base_DoSetClientSize", (PyCFunction) _wrap_PyPanel_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28084          { (char *)"PyPanel_base_DoSetVirtualSize", (PyCFunction) _wrap_PyPanel_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28085          { (char *)"PyPanel_base_DoGetSize", (PyCFunction) _wrap_PyPanel_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28086          { (char *)"PyPanel_base_DoGetClientSize", (PyCFunction) _wrap_PyPanel_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28087          { (char *)"PyPanel_base_DoGetPosition", (PyCFunction) _wrap_PyPanel_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28088          { (char *)"PyPanel_base_DoGetVirtualSize", (PyCFunction) _wrap_PyPanel_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28089          { (char *)"PyPanel_base_DoGetBestSize", (PyCFunction) _wrap_PyPanel_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28090          { (char *)"PyPanel_base_InitDialog", (PyCFunction) _wrap_PyPanel_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28091          { (char *)"PyPanel_base_TransferDataToWindow", (PyCFunction) _wrap_PyPanel_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28092          { (char *)"PyPanel_base_TransferDataFromWindow", (PyCFunction) _wrap_PyPanel_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28093          { (char *)"PyPanel_base_Validate", (PyCFunction) _wrap_PyPanel_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28094          { (char *)"PyPanel_base_AcceptsFocus", (PyCFunction) _wrap_PyPanel_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28095          { (char *)"PyPanel_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyPanel_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28096          { (char *)"PyPanel_base_GetMaxSize", (PyCFunction) _wrap_PyPanel_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28097          { (char *)"PyPanel_base_AddChild", (PyCFunction) _wrap_PyPanel_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28098          { (char *)"PyPanel_base_RemoveChild", (PyCFunction) _wrap_PyPanel_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28099          { (char *)"PyPanel_base_ShouldInheritColours", (PyCFunction) _wrap_PyPanel_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28100          { (char *)"PyPanel_base_GetDefaultAttributes", (PyCFunction) _wrap_PyPanel_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28101          { (char *)"PyPanel_swigregister", PyPanel_swigregister, METH_VARARGS, NULL},
28102          { (char *)"new_PyScrolledWindow", (PyCFunction) _wrap_new_PyScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28103          { (char *)"new_PrePyScrolledWindow", (PyCFunction) _wrap_new_PrePyScrolledWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28104          { (char *)"PyScrolledWindow__setCallbackInfo", (PyCFunction) _wrap_PyScrolledWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28105          { (char *)"PyScrolledWindow_SetBestSize", (PyCFunction) _wrap_PyScrolledWindow_SetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28106          { (char *)"PyScrolledWindow_DoEraseBackground", (PyCFunction) _wrap_PyScrolledWindow_DoEraseBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28107          { (char *)"PyScrolledWindow_base_DoMoveWindow", (PyCFunction) _wrap_PyScrolledWindow_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28108          { (char *)"PyScrolledWindow_base_DoSetSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28109          { (char *)"PyScrolledWindow_base_DoSetClientSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28110          { (char *)"PyScrolledWindow_base_DoSetVirtualSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28111          { (char *)"PyScrolledWindow_base_DoGetSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28112          { (char *)"PyScrolledWindow_base_DoGetClientSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
28113          { (char *)"PyScrolledWindow_base_DoGetPosition", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
28114          { (char *)"PyScrolledWindow_base_DoGetVirtualSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
28115          { (char *)"PyScrolledWindow_base_DoGetBestSize", (PyCFunction) _wrap_PyScrolledWindow_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
28116          { (char *)"PyScrolledWindow_base_InitDialog", (PyCFunction) _wrap_PyScrolledWindow_base_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28117          { (char *)"PyScrolledWindow_base_TransferDataToWindow", (PyCFunction) _wrap_PyScrolledWindow_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28118          { (char *)"PyScrolledWindow_base_TransferDataFromWindow", (PyCFunction) _wrap_PyScrolledWindow_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28119          { (char *)"PyScrolledWindow_base_Validate", (PyCFunction) _wrap_PyScrolledWindow_base_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
28120          { (char *)"PyScrolledWindow_base_AcceptsFocus", (PyCFunction) _wrap_PyScrolledWindow_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
28121          { (char *)"PyScrolledWindow_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_PyScrolledWindow_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
28122          { (char *)"PyScrolledWindow_base_GetMaxSize", (PyCFunction) _wrap_PyScrolledWindow_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
28123          { (char *)"PyScrolledWindow_base_AddChild", (PyCFunction) _wrap_PyScrolledWindow_base_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
28124          { (char *)"PyScrolledWindow_base_RemoveChild", (PyCFunction) _wrap_PyScrolledWindow_base_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
28125          { (char *)"PyScrolledWindow_base_ShouldInheritColours", (PyCFunction) _wrap_PyScrolledWindow_base_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
28126          { (char *)"PyScrolledWindow_base_GetDefaultAttributes", (PyCFunction) _wrap_PyScrolledWindow_base_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
28127          { (char *)"PyScrolledWindow_swigregister", PyScrolledWindow_swigregister, METH_VARARGS, NULL},
28128          { (char *)"new_PrintData", _wrap_new_PrintData, METH_VARARGS, NULL},
28129          { (char *)"delete_PrintData", (PyCFunction) _wrap_delete_PrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28130          { (char *)"PrintData_GetNoCopies", (PyCFunction) _wrap_PrintData_GetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28131          { (char *)"PrintData_GetCollate", (PyCFunction) _wrap_PrintData_GetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28132          { (char *)"PrintData_GetOrientation", (PyCFunction) _wrap_PrintData_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28133          { (char *)"PrintData_Ok", (PyCFunction) _wrap_PrintData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28134          { (char *)"PrintData_GetPrinterName", (PyCFunction) _wrap_PrintData_GetPrinterName, METH_VARARGS | METH_KEYWORDS, NULL},
28135          { (char *)"PrintData_GetColour", (PyCFunction) _wrap_PrintData_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28136          { (char *)"PrintData_GetDuplex", (PyCFunction) _wrap_PrintData_GetDuplex, METH_VARARGS | METH_KEYWORDS, NULL},
28137          { (char *)"PrintData_GetPaperId", (PyCFunction) _wrap_PrintData_GetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28138          { (char *)"PrintData_GetPaperSize", (PyCFunction) _wrap_PrintData_GetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28139          { (char *)"PrintData_GetQuality", (PyCFunction) _wrap_PrintData_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
28140          { (char *)"PrintData_GetBin", (PyCFunction) _wrap_PrintData_GetBin, METH_VARARGS | METH_KEYWORDS, NULL},
28141          { (char *)"PrintData_GetPrintMode", (PyCFunction) _wrap_PrintData_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
28142          { (char *)"PrintData_SetNoCopies", (PyCFunction) _wrap_PrintData_SetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28143          { (char *)"PrintData_SetCollate", (PyCFunction) _wrap_PrintData_SetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28144          { (char *)"PrintData_SetOrientation", (PyCFunction) _wrap_PrintData_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28145          { (char *)"PrintData_SetPrinterName", (PyCFunction) _wrap_PrintData_SetPrinterName, METH_VARARGS | METH_KEYWORDS, NULL},
28146          { (char *)"PrintData_SetColour", (PyCFunction) _wrap_PrintData_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28147          { (char *)"PrintData_SetDuplex", (PyCFunction) _wrap_PrintData_SetDuplex, METH_VARARGS | METH_KEYWORDS, NULL},
28148          { (char *)"PrintData_SetPaperId", (PyCFunction) _wrap_PrintData_SetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28149          { (char *)"PrintData_SetPaperSize", (PyCFunction) _wrap_PrintData_SetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28150          { (char *)"PrintData_SetQuality", (PyCFunction) _wrap_PrintData_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
28151          { (char *)"PrintData_SetBin", (PyCFunction) _wrap_PrintData_SetBin, METH_VARARGS | METH_KEYWORDS, NULL},
28152          { (char *)"PrintData_SetPrintMode", (PyCFunction) _wrap_PrintData_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
28153          { (char *)"PrintData_GetFilename", (PyCFunction) _wrap_PrintData_GetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28154          { (char *)"PrintData_SetFilename", (PyCFunction) _wrap_PrintData_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
28155          { (char *)"PrintData_GetPrivData", (PyCFunction) _wrap_PrintData_GetPrivData, METH_VARARGS | METH_KEYWORDS, NULL},
28156          { (char *)"PrintData_SetPrivData", (PyCFunction) _wrap_PrintData_SetPrivData, METH_VARARGS | METH_KEYWORDS, NULL},
28157          { (char *)"PrintData_GetPrinterCommand", (PyCFunction) _wrap_PrintData_GetPrinterCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28158          { (char *)"PrintData_GetPrinterOptions", (PyCFunction) _wrap_PrintData_GetPrinterOptions, METH_VARARGS | METH_KEYWORDS, NULL},
28159          { (char *)"PrintData_GetPreviewCommand", (PyCFunction) _wrap_PrintData_GetPreviewCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28160          { (char *)"PrintData_GetFontMetricPath", (PyCFunction) _wrap_PrintData_GetFontMetricPath, METH_VARARGS | METH_KEYWORDS, NULL},
28161          { (char *)"PrintData_GetPrinterScaleX", (PyCFunction) _wrap_PrintData_GetPrinterScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
28162          { (char *)"PrintData_GetPrinterScaleY", (PyCFunction) _wrap_PrintData_GetPrinterScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
28163          { (char *)"PrintData_GetPrinterTranslateX", (PyCFunction) _wrap_PrintData_GetPrinterTranslateX, METH_VARARGS | METH_KEYWORDS, NULL},
28164          { (char *)"PrintData_GetPrinterTranslateY", (PyCFunction) _wrap_PrintData_GetPrinterTranslateY, METH_VARARGS | METH_KEYWORDS, NULL},
28165          { (char *)"PrintData_SetPrinterCommand", (PyCFunction) _wrap_PrintData_SetPrinterCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28166          { (char *)"PrintData_SetPrinterOptions", (PyCFunction) _wrap_PrintData_SetPrinterOptions, METH_VARARGS | METH_KEYWORDS, NULL},
28167          { (char *)"PrintData_SetPreviewCommand", (PyCFunction) _wrap_PrintData_SetPreviewCommand, METH_VARARGS | METH_KEYWORDS, NULL},
28168          { (char *)"PrintData_SetFontMetricPath", (PyCFunction) _wrap_PrintData_SetFontMetricPath, METH_VARARGS | METH_KEYWORDS, NULL},
28169          { (char *)"PrintData_SetPrinterScaleX", (PyCFunction) _wrap_PrintData_SetPrinterScaleX, METH_VARARGS | METH_KEYWORDS, NULL},
28170          { (char *)"PrintData_SetPrinterScaleY", (PyCFunction) _wrap_PrintData_SetPrinterScaleY, METH_VARARGS | METH_KEYWORDS, NULL},
28171          { (char *)"PrintData_SetPrinterScaling", (PyCFunction) _wrap_PrintData_SetPrinterScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28172          { (char *)"PrintData_SetPrinterTranslateX", (PyCFunction) _wrap_PrintData_SetPrinterTranslateX, METH_VARARGS | METH_KEYWORDS, NULL},
28173          { (char *)"PrintData_SetPrinterTranslateY", (PyCFunction) _wrap_PrintData_SetPrinterTranslateY, METH_VARARGS | METH_KEYWORDS, NULL},
28174          { (char *)"PrintData_SetPrinterTranslation", (PyCFunction) _wrap_PrintData_SetPrinterTranslation, METH_VARARGS | METH_KEYWORDS, NULL},
28175          { (char *)"PrintData_swigregister", PrintData_swigregister, METH_VARARGS, NULL},
28176          { (char *)"new_PageSetupDialogData", _wrap_new_PageSetupDialogData, METH_VARARGS, NULL},
28177          { (char *)"delete_PageSetupDialogData", (PyCFunction) _wrap_delete_PageSetupDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28178          { (char *)"PageSetupDialogData_EnableHelp", (PyCFunction) _wrap_PageSetupDialogData_EnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28179          { (char *)"PageSetupDialogData_EnableMargins", (PyCFunction) _wrap_PageSetupDialogData_EnableMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28180          { (char *)"PageSetupDialogData_EnableOrientation", (PyCFunction) _wrap_PageSetupDialogData_EnableOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28181          { (char *)"PageSetupDialogData_EnablePaper", (PyCFunction) _wrap_PageSetupDialogData_EnablePaper, METH_VARARGS | METH_KEYWORDS, NULL},
28182          { (char *)"PageSetupDialogData_EnablePrinter", (PyCFunction) _wrap_PageSetupDialogData_EnablePrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28183          { (char *)"PageSetupDialogData_GetDefaultMinMargins", (PyCFunction) _wrap_PageSetupDialogData_GetDefaultMinMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28184          { (char *)"PageSetupDialogData_GetEnableMargins", (PyCFunction) _wrap_PageSetupDialogData_GetEnableMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28185          { (char *)"PageSetupDialogData_GetEnableOrientation", (PyCFunction) _wrap_PageSetupDialogData_GetEnableOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28186          { (char *)"PageSetupDialogData_GetEnablePaper", (PyCFunction) _wrap_PageSetupDialogData_GetEnablePaper, METH_VARARGS | METH_KEYWORDS, NULL},
28187          { (char *)"PageSetupDialogData_GetEnablePrinter", (PyCFunction) _wrap_PageSetupDialogData_GetEnablePrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28188          { (char *)"PageSetupDialogData_GetEnableHelp", (PyCFunction) _wrap_PageSetupDialogData_GetEnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28189          { (char *)"PageSetupDialogData_GetDefaultInfo", (PyCFunction) _wrap_PageSetupDialogData_GetDefaultInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28190          { (char *)"PageSetupDialogData_GetMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_GetMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28191          { (char *)"PageSetupDialogData_GetMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_GetMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28192          { (char *)"PageSetupDialogData_GetMinMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_GetMinMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28193          { (char *)"PageSetupDialogData_GetMinMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_GetMinMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28194          { (char *)"PageSetupDialogData_GetPaperId", (PyCFunction) _wrap_PageSetupDialogData_GetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28195          { (char *)"PageSetupDialogData_GetPaperSize", (PyCFunction) _wrap_PageSetupDialogData_GetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28196          { (char *)"PageSetupDialogData_GetPrintData", (PyCFunction) _wrap_PageSetupDialogData_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28197          { (char *)"PageSetupDialogData_Ok", (PyCFunction) _wrap_PageSetupDialogData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28198          { (char *)"PageSetupDialogData_SetDefaultInfo", (PyCFunction) _wrap_PageSetupDialogData_SetDefaultInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28199          { (char *)"PageSetupDialogData_SetDefaultMinMargins", (PyCFunction) _wrap_PageSetupDialogData_SetDefaultMinMargins, METH_VARARGS | METH_KEYWORDS, NULL},
28200          { (char *)"PageSetupDialogData_SetMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_SetMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28201          { (char *)"PageSetupDialogData_SetMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_SetMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28202          { (char *)"PageSetupDialogData_SetMinMarginTopLeft", (PyCFunction) _wrap_PageSetupDialogData_SetMinMarginTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
28203          { (char *)"PageSetupDialogData_SetMinMarginBottomRight", (PyCFunction) _wrap_PageSetupDialogData_SetMinMarginBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
28204          { (char *)"PageSetupDialogData_SetPaperId", (PyCFunction) _wrap_PageSetupDialogData_SetPaperId, METH_VARARGS | METH_KEYWORDS, NULL},
28205          { (char *)"PageSetupDialogData_SetPaperSize", (PyCFunction) _wrap_PageSetupDialogData_SetPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28206          { (char *)"PageSetupDialogData_SetPrintData", (PyCFunction) _wrap_PageSetupDialogData_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28207          { (char *)"PageSetupDialogData_CalculateIdFromPaperSize", (PyCFunction) _wrap_PageSetupDialogData_CalculateIdFromPaperSize, METH_VARARGS | METH_KEYWORDS, NULL},
28208          { (char *)"PageSetupDialogData_CalculatePaperSizeFromId", (PyCFunction) _wrap_PageSetupDialogData_CalculatePaperSizeFromId, METH_VARARGS | METH_KEYWORDS, NULL},
28209          { (char *)"PageSetupDialogData_swigregister", PageSetupDialogData_swigregister, METH_VARARGS, NULL},
28210          { (char *)"new_PageSetupDialog", (PyCFunction) _wrap_new_PageSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28211          { (char *)"PageSetupDialog_GetPageSetupData", (PyCFunction) _wrap_PageSetupDialog_GetPageSetupData, METH_VARARGS | METH_KEYWORDS, NULL},
28212          { (char *)"PageSetupDialog_GetPageSetupDialogData", (PyCFunction) _wrap_PageSetupDialog_GetPageSetupDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28213          { (char *)"PageSetupDialog_ShowModal", (PyCFunction) _wrap_PageSetupDialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
28214          { (char *)"PageSetupDialog_swigregister", PageSetupDialog_swigregister, METH_VARARGS, NULL},
28215          { (char *)"new_PrintDialogData", _wrap_new_PrintDialogData, METH_VARARGS, NULL},
28216          { (char *)"delete_PrintDialogData", (PyCFunction) _wrap_delete_PrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28217          { (char *)"PrintDialogData_GetFromPage", (PyCFunction) _wrap_PrintDialogData_GetFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
28218          { (char *)"PrintDialogData_GetToPage", (PyCFunction) _wrap_PrintDialogData_GetToPage, METH_VARARGS | METH_KEYWORDS, NULL},
28219          { (char *)"PrintDialogData_GetMinPage", (PyCFunction) _wrap_PrintDialogData_GetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28220          { (char *)"PrintDialogData_GetMaxPage", (PyCFunction) _wrap_PrintDialogData_GetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28221          { (char *)"PrintDialogData_GetNoCopies", (PyCFunction) _wrap_PrintDialogData_GetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28222          { (char *)"PrintDialogData_GetAllPages", (PyCFunction) _wrap_PrintDialogData_GetAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
28223          { (char *)"PrintDialogData_GetSelection", (PyCFunction) _wrap_PrintDialogData_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28224          { (char *)"PrintDialogData_GetCollate", (PyCFunction) _wrap_PrintDialogData_GetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28225          { (char *)"PrintDialogData_GetPrintToFile", (PyCFunction) _wrap_PrintDialogData_GetPrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28226          { (char *)"PrintDialogData_GetSetupDialog", (PyCFunction) _wrap_PrintDialogData_GetSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28227          { (char *)"PrintDialogData_SetSetupDialog", (PyCFunction) _wrap_PrintDialogData_SetSetupDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28228          { (char *)"PrintDialogData_SetFromPage", (PyCFunction) _wrap_PrintDialogData_SetFromPage, METH_VARARGS | METH_KEYWORDS, NULL},
28229          { (char *)"PrintDialogData_SetToPage", (PyCFunction) _wrap_PrintDialogData_SetToPage, METH_VARARGS | METH_KEYWORDS, NULL},
28230          { (char *)"PrintDialogData_SetMinPage", (PyCFunction) _wrap_PrintDialogData_SetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28231          { (char *)"PrintDialogData_SetMaxPage", (PyCFunction) _wrap_PrintDialogData_SetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28232          { (char *)"PrintDialogData_SetNoCopies", (PyCFunction) _wrap_PrintDialogData_SetNoCopies, METH_VARARGS | METH_KEYWORDS, NULL},
28233          { (char *)"PrintDialogData_SetAllPages", (PyCFunction) _wrap_PrintDialogData_SetAllPages, METH_VARARGS | METH_KEYWORDS, NULL},
28234          { (char *)"PrintDialogData_SetSelection", (PyCFunction) _wrap_PrintDialogData_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28235          { (char *)"PrintDialogData_SetCollate", (PyCFunction) _wrap_PrintDialogData_SetCollate, METH_VARARGS | METH_KEYWORDS, NULL},
28236          { (char *)"PrintDialogData_SetPrintToFile", (PyCFunction) _wrap_PrintDialogData_SetPrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28237          { (char *)"PrintDialogData_EnablePrintToFile", (PyCFunction) _wrap_PrintDialogData_EnablePrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28238          { (char *)"PrintDialogData_EnableSelection", (PyCFunction) _wrap_PrintDialogData_EnableSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28239          { (char *)"PrintDialogData_EnablePageNumbers", (PyCFunction) _wrap_PrintDialogData_EnablePageNumbers, METH_VARARGS | METH_KEYWORDS, NULL},
28240          { (char *)"PrintDialogData_EnableHelp", (PyCFunction) _wrap_PrintDialogData_EnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28241          { (char *)"PrintDialogData_GetEnablePrintToFile", (PyCFunction) _wrap_PrintDialogData_GetEnablePrintToFile, METH_VARARGS | METH_KEYWORDS, NULL},
28242          { (char *)"PrintDialogData_GetEnableSelection", (PyCFunction) _wrap_PrintDialogData_GetEnableSelection, METH_VARARGS | METH_KEYWORDS, NULL},
28243          { (char *)"PrintDialogData_GetEnablePageNumbers", (PyCFunction) _wrap_PrintDialogData_GetEnablePageNumbers, METH_VARARGS | METH_KEYWORDS, NULL},
28244          { (char *)"PrintDialogData_GetEnableHelp", (PyCFunction) _wrap_PrintDialogData_GetEnableHelp, METH_VARARGS | METH_KEYWORDS, NULL},
28245          { (char *)"PrintDialogData_Ok", (PyCFunction) _wrap_PrintDialogData_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28246          { (char *)"PrintDialogData_GetPrintData", (PyCFunction) _wrap_PrintDialogData_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28247          { (char *)"PrintDialogData_SetPrintData", (PyCFunction) _wrap_PrintDialogData_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28248          { (char *)"PrintDialogData_swigregister", PrintDialogData_swigregister, METH_VARARGS, NULL},
28249          { (char *)"new_PrintDialog", (PyCFunction) _wrap_new_PrintDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28250          { (char *)"PrintDialog_ShowModal", (PyCFunction) _wrap_PrintDialog_ShowModal, METH_VARARGS | METH_KEYWORDS, NULL},
28251          { (char *)"PrintDialog_GetPrintDialogData", (PyCFunction) _wrap_PrintDialog_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28252          { (char *)"PrintDialog_GetPrintData", (PyCFunction) _wrap_PrintDialog_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28253          { (char *)"PrintDialog_GetPrintDC", (PyCFunction) _wrap_PrintDialog_GetPrintDC, METH_VARARGS | METH_KEYWORDS, NULL},
28254          { (char *)"PrintDialog_swigregister", PrintDialog_swigregister, METH_VARARGS, NULL},
28255          { (char *)"new_Printer", (PyCFunction) _wrap_new_Printer, METH_VARARGS | METH_KEYWORDS, NULL},
28256          { (char *)"delete_Printer", (PyCFunction) _wrap_delete_Printer, METH_VARARGS | METH_KEYWORDS, NULL},
28257          { (char *)"Printer_CreateAbortWindow", (PyCFunction) _wrap_Printer_CreateAbortWindow, METH_VARARGS | METH_KEYWORDS, NULL},
28258          { (char *)"Printer_ReportError", (PyCFunction) _wrap_Printer_ReportError, METH_VARARGS | METH_KEYWORDS, NULL},
28259          { (char *)"Printer_Setup", (PyCFunction) _wrap_Printer_Setup, METH_VARARGS | METH_KEYWORDS, NULL},
28260          { (char *)"Printer_Print", (PyCFunction) _wrap_Printer_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28261          { (char *)"Printer_PrintDialog", (PyCFunction) _wrap_Printer_PrintDialog, METH_VARARGS | METH_KEYWORDS, NULL},
28262          { (char *)"Printer_GetPrintDialogData", (PyCFunction) _wrap_Printer_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28263          { (char *)"Printer_GetAbort", (PyCFunction) _wrap_Printer_GetAbort, METH_VARARGS | METH_KEYWORDS, NULL},
28264          { (char *)"Printer_GetLastError", (PyCFunction) _wrap_Printer_GetLastError, METH_VARARGS | METH_KEYWORDS, NULL},
28265          { (char *)"Printer_swigregister", Printer_swigregister, METH_VARARGS, NULL},
28266          { (char *)"new_Printout", (PyCFunction) _wrap_new_Printout, METH_VARARGS | METH_KEYWORDS, NULL},
28267          { (char *)"Printout__setCallbackInfo", (PyCFunction) _wrap_Printout__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28268          { (char *)"Printout_GetTitle", (PyCFunction) _wrap_Printout_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
28269          { (char *)"Printout_GetDC", (PyCFunction) _wrap_Printout_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
28270          { (char *)"Printout_SetDC", (PyCFunction) _wrap_Printout_SetDC, METH_VARARGS | METH_KEYWORDS, NULL},
28271          { (char *)"Printout_SetPageSizePixels", (PyCFunction) _wrap_Printout_SetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
28272          { (char *)"Printout_GetPageSizePixels", (PyCFunction) _wrap_Printout_GetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
28273          { (char *)"Printout_SetPageSizeMM", (PyCFunction) _wrap_Printout_SetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
28274          { (char *)"Printout_GetPageSizeMM", (PyCFunction) _wrap_Printout_GetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
28275          { (char *)"Printout_SetPPIScreen", (PyCFunction) _wrap_Printout_SetPPIScreen, METH_VARARGS | METH_KEYWORDS, NULL},
28276          { (char *)"Printout_GetPPIScreen", (PyCFunction) _wrap_Printout_GetPPIScreen, METH_VARARGS | METH_KEYWORDS, NULL},
28277          { (char *)"Printout_SetPPIPrinter", (PyCFunction) _wrap_Printout_SetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28278          { (char *)"Printout_GetPPIPrinter", (PyCFunction) _wrap_Printout_GetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
28279          { (char *)"Printout_IsPreview", (PyCFunction) _wrap_Printout_IsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28280          { (char *)"Printout_SetIsPreview", (PyCFunction) _wrap_Printout_SetIsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28281          { (char *)"Printout_base_OnBeginDocument", (PyCFunction) _wrap_Printout_base_OnBeginDocument, METH_VARARGS | METH_KEYWORDS, NULL},
28282          { (char *)"Printout_base_OnEndDocument", (PyCFunction) _wrap_Printout_base_OnEndDocument, METH_VARARGS | METH_KEYWORDS, NULL},
28283          { (char *)"Printout_base_OnBeginPrinting", (PyCFunction) _wrap_Printout_base_OnBeginPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28284          { (char *)"Printout_base_OnEndPrinting", (PyCFunction) _wrap_Printout_base_OnEndPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28285          { (char *)"Printout_base_OnPreparePrinting", (PyCFunction) _wrap_Printout_base_OnPreparePrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28286          { (char *)"Printout_base_HasPage", (PyCFunction) _wrap_Printout_base_HasPage, METH_VARARGS | METH_KEYWORDS, NULL},
28287          { (char *)"Printout_base_GetPageInfo", (PyCFunction) _wrap_Printout_base_GetPageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28288          { (char *)"Printout_swigregister", Printout_swigregister, METH_VARARGS, NULL},
28289          { (char *)"new_PreviewCanvas", (PyCFunction) _wrap_new_PreviewCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28290          { (char *)"PreviewCanvas_swigregister", PreviewCanvas_swigregister, METH_VARARGS, NULL},
28291          { (char *)"new_PreviewFrame", (PyCFunction) _wrap_new_PreviewFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28292          { (char *)"PreviewFrame_Initialize", (PyCFunction) _wrap_PreviewFrame_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
28293          { (char *)"PreviewFrame_CreateControlBar", (PyCFunction) _wrap_PreviewFrame_CreateControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28294          { (char *)"PreviewFrame_CreateCanvas", (PyCFunction) _wrap_PreviewFrame_CreateCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28295          { (char *)"PreviewFrame_GetControlBar", (PyCFunction) _wrap_PreviewFrame_GetControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28296          { (char *)"PreviewFrame_swigregister", PreviewFrame_swigregister, METH_VARARGS, NULL},
28297          { (char *)"new_PreviewControlBar", (PyCFunction) _wrap_new_PreviewControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28298          { (char *)"PreviewControlBar_GetZoomControl", (PyCFunction) _wrap_PreviewControlBar_GetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28299          { (char *)"PreviewControlBar_SetZoomControl", (PyCFunction) _wrap_PreviewControlBar_SetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28300          { (char *)"PreviewControlBar_GetPrintPreview", (PyCFunction) _wrap_PreviewControlBar_GetPrintPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28301          { (char *)"PreviewControlBar_OnNext", (PyCFunction) _wrap_PreviewControlBar_OnNext, METH_VARARGS | METH_KEYWORDS, NULL},
28302          { (char *)"PreviewControlBar_OnPrevious", (PyCFunction) _wrap_PreviewControlBar_OnPrevious, METH_VARARGS | METH_KEYWORDS, NULL},
28303          { (char *)"PreviewControlBar_OnFirst", (PyCFunction) _wrap_PreviewControlBar_OnFirst, METH_VARARGS | METH_KEYWORDS, NULL},
28304          { (char *)"PreviewControlBar_OnLast", (PyCFunction) _wrap_PreviewControlBar_OnLast, METH_VARARGS | METH_KEYWORDS, NULL},
28305          { (char *)"PreviewControlBar_OnGoto", (PyCFunction) _wrap_PreviewControlBar_OnGoto, METH_VARARGS | METH_KEYWORDS, NULL},
28306          { (char *)"PreviewControlBar_swigregister", PreviewControlBar_swigregister, METH_VARARGS, NULL},
28307          { (char *)"new_PrintPreview", _wrap_new_PrintPreview, METH_VARARGS, NULL},
28308          { (char *)"PrintPreview_SetCurrentPage", (PyCFunction) _wrap_PrintPreview_SetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28309          { (char *)"PrintPreview_GetCurrentPage", (PyCFunction) _wrap_PrintPreview_GetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28310          { (char *)"PrintPreview_SetPrintout", (PyCFunction) _wrap_PrintPreview_SetPrintout, METH_VARARGS | METH_KEYWORDS, NULL},
28311          { (char *)"PrintPreview_GetPrintout", (PyCFunction) _wrap_PrintPreview_GetPrintout, METH_VARARGS | METH_KEYWORDS, NULL},
28312          { (char *)"PrintPreview_GetPrintoutForPrinting", (PyCFunction) _wrap_PrintPreview_GetPrintoutForPrinting, METH_VARARGS | METH_KEYWORDS, NULL},
28313          { (char *)"PrintPreview_SetFrame", (PyCFunction) _wrap_PrintPreview_SetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28314          { (char *)"PrintPreview_SetCanvas", (PyCFunction) _wrap_PrintPreview_SetCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28315          { (char *)"PrintPreview_GetFrame", (PyCFunction) _wrap_PrintPreview_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28316          { (char *)"PrintPreview_GetCanvas", (PyCFunction) _wrap_PrintPreview_GetCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28317          { (char *)"PrintPreview_PaintPage", (PyCFunction) _wrap_PrintPreview_PaintPage, METH_VARARGS | METH_KEYWORDS, NULL},
28318          { (char *)"PrintPreview_DrawBlankPage", (PyCFunction) _wrap_PrintPreview_DrawBlankPage, METH_VARARGS | METH_KEYWORDS, NULL},
28319          { (char *)"PrintPreview_RenderPage", (PyCFunction) _wrap_PrintPreview_RenderPage, METH_VARARGS | METH_KEYWORDS, NULL},
28320          { (char *)"PrintPreview_AdjustScrollbars", (PyCFunction) _wrap_PrintPreview_AdjustScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},
28321          { (char *)"PrintPreview_GetPrintDialogData", (PyCFunction) _wrap_PrintPreview_GetPrintDialogData, METH_VARARGS | METH_KEYWORDS, NULL},
28322          { (char *)"PrintPreview_SetZoom", (PyCFunction) _wrap_PrintPreview_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28323          { (char *)"PrintPreview_GetZoom", (PyCFunction) _wrap_PrintPreview_GetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28324          { (char *)"PrintPreview_GetMaxPage", (PyCFunction) _wrap_PrintPreview_GetMaxPage, METH_VARARGS | METH_KEYWORDS, NULL},
28325          { (char *)"PrintPreview_GetMinPage", (PyCFunction) _wrap_PrintPreview_GetMinPage, METH_VARARGS | METH_KEYWORDS, NULL},
28326          { (char *)"PrintPreview_Ok", (PyCFunction) _wrap_PrintPreview_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
28327          { (char *)"PrintPreview_SetOk", (PyCFunction) _wrap_PrintPreview_SetOk, METH_VARARGS | METH_KEYWORDS, NULL},
28328          { (char *)"PrintPreview_Print", (PyCFunction) _wrap_PrintPreview_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28329          { (char *)"PrintPreview_DetermineScaling", (PyCFunction) _wrap_PrintPreview_DetermineScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28330          { (char *)"PrintPreview_swigregister", PrintPreview_swigregister, METH_VARARGS, NULL},
28331          { (char *)"new_PyPrintPreview", _wrap_new_PyPrintPreview, METH_VARARGS, NULL},
28332          { (char *)"PyPrintPreview__setCallbackInfo", (PyCFunction) _wrap_PyPrintPreview__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28333          { (char *)"PyPrintPreview_base_SetCurrentPage", (PyCFunction) _wrap_PyPrintPreview_base_SetCurrentPage, METH_VARARGS | METH_KEYWORDS, NULL},
28334          { (char *)"PyPrintPreview_base_PaintPage", (PyCFunction) _wrap_PyPrintPreview_base_PaintPage, METH_VARARGS | METH_KEYWORDS, NULL},
28335          { (char *)"PyPrintPreview_base_DrawBlankPage", (PyCFunction) _wrap_PyPrintPreview_base_DrawBlankPage, METH_VARARGS | METH_KEYWORDS, NULL},
28336          { (char *)"PyPrintPreview_base_RenderPage", (PyCFunction) _wrap_PyPrintPreview_base_RenderPage, METH_VARARGS | METH_KEYWORDS, NULL},
28337          { (char *)"PyPrintPreview_base_SetZoom", (PyCFunction) _wrap_PyPrintPreview_base_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},
28338          { (char *)"PyPrintPreview_base_Print", (PyCFunction) _wrap_PyPrintPreview_base_Print, METH_VARARGS | METH_KEYWORDS, NULL},
28339          { (char *)"PyPrintPreview_base_DetermineScaling", (PyCFunction) _wrap_PyPrintPreview_base_DetermineScaling, METH_VARARGS | METH_KEYWORDS, NULL},
28340          { (char *)"PyPrintPreview_swigregister", PyPrintPreview_swigregister, METH_VARARGS, NULL},
28341          { (char *)"new_PyPreviewFrame", (PyCFunction) _wrap_new_PyPreviewFrame, METH_VARARGS | METH_KEYWORDS, NULL},
28342          { (char *)"PyPreviewFrame__setCallbackInfo", (PyCFunction) _wrap_PyPreviewFrame__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28343          { (char *)"PyPreviewFrame_SetPreviewCanvas", (PyCFunction) _wrap_PyPreviewFrame_SetPreviewCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28344          { (char *)"PyPreviewFrame_SetControlBar", (PyCFunction) _wrap_PyPreviewFrame_SetControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28345          { (char *)"PyPreviewFrame_base_Initialize", (PyCFunction) _wrap_PyPreviewFrame_base_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
28346          { (char *)"PyPreviewFrame_base_CreateCanvas", (PyCFunction) _wrap_PyPreviewFrame_base_CreateCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
28347          { (char *)"PyPreviewFrame_base_CreateControlBar", (PyCFunction) _wrap_PyPreviewFrame_base_CreateControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28348          { (char *)"PyPreviewFrame_swigregister", PyPreviewFrame_swigregister, METH_VARARGS, NULL},
28349          { (char *)"new_PyPreviewControlBar", (PyCFunction) _wrap_new_PyPreviewControlBar, METH_VARARGS | METH_KEYWORDS, NULL},
28350          { (char *)"PyPreviewControlBar__setCallbackInfo", (PyCFunction) _wrap_PyPreviewControlBar__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28351          { (char *)"PyPreviewControlBar_SetPrintPreview", (PyCFunction) _wrap_PyPreviewControlBar_SetPrintPreview, METH_VARARGS | METH_KEYWORDS, NULL},
28352          { (char *)"PyPreviewControlBar_base_CreateButtons", (PyCFunction) _wrap_PyPreviewControlBar_base_CreateButtons, METH_VARARGS | METH_KEYWORDS, NULL},
28353          { (char *)"PyPreviewControlBar_base_SetZoomControl", (PyCFunction) _wrap_PyPreviewControlBar_base_SetZoomControl, METH_VARARGS | METH_KEYWORDS, NULL},
28354          { (char *)"PyPreviewControlBar_swigregister", PyPreviewControlBar_swigregister, METH_VARARGS, NULL},
28355          { NULL, NULL, 0, NULL }
28356 };
28357
28358
28359 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
28360
28361 static void *_p_wxPyPreviewFrameTo_p_wxPreviewFrame(void *x) {
28362     return (void *)((wxPreviewFrame *)  ((wxPyPreviewFrame *) x));
28363 }
28364 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
28365     return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
28366 }
28367 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
28368     return (void *)((wxEvent *)  ((wxMenuEvent *) x));
28369 }
28370 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
28371     return (void *)((wxEvent *)  ((wxCloseEvent *) x));
28372 }
28373 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
28374     return (void *)((wxEvent *)  ((wxMouseEvent *) x));
28375 }
28376 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
28377     return (void *)((wxEvent *)  ((wxEraseEvent *) x));
28378 }
28379 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
28380     return (void *)((wxEvent *)  ((wxSetCursorEvent *) x));
28381 }
28382 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
28383     return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
28384 }
28385 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
28386     return (void *)((wxEvent *)  ((wxInitDialogEvent *) x));
28387 }
28388 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
28389     return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
28390 }
28391 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
28392     return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
28393 }
28394 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
28395     return (void *)((wxEvent *)  ((wxPyEvent *) x));
28396 }
28397 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
28398     return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
28399 }
28400 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
28401     return (void *)((wxEvent *)  ((wxCalculateLayoutEvent *) x));
28402 }
28403 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
28404     return (void *)((wxEvent *)  ((wxIdleEvent *) x));
28405 }
28406 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
28407     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
28408 }
28409 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
28410     return (void *)((wxEvent *)  ((wxQueryNewPaletteEvent *) x));
28411 }
28412 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
28413     return (void *)((wxEvent *)  ((wxMaximizeEvent *) x));
28414 }
28415 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
28416     return (void *)((wxEvent *)  ((wxIconizeEvent *) x));
28417 }
28418 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
28419     return (void *)((wxEvent *)  ((wxActivateEvent *) x));
28420 }
28421 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
28422     return (void *)((wxEvent *)  ((wxSizeEvent *) x));
28423 }
28424 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
28425     return (void *)((wxEvent *)  ((wxMoveEvent *) x));
28426 }
28427 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
28428     return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
28429 }
28430 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
28431     return (void *)((wxEvent *)  ((wxPaintEvent *) x));
28432 }
28433 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
28434     return (void *)((wxEvent *)  ((wxNcPaintEvent *) x));
28435 }
28436 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
28437     return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
28438 }
28439 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
28440     return (void *)((wxEvent *)  ((wxPaletteChangedEvent *) x));
28441 }
28442 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
28443     return (void *)((wxEvent *)  ((wxDisplayChangedEvent *) x));
28444 }
28445 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
28446     return (void *)((wxEvent *)  ((wxMouseCaptureChangedEvent *) x));
28447 }
28448 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
28449     return (void *)((wxEvent *)  ((wxSysColourChangedEvent *) x));
28450 }
28451 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
28452     return (void *)((wxEvent *)  ((wxDropFilesEvent *) x));
28453 }
28454 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
28455     return (void *)((wxEvent *)  ((wxFocusEvent *) x));
28456 }
28457 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
28458     return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
28459 }
28460 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
28461     return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
28462 }
28463 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
28464     return (void *)((wxEvent *)  ((wxQueryLayoutInfoEvent *) x));
28465 }
28466 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
28467     return (void *)((wxEvent *)  ((wxShowEvent *) x));
28468 }
28469 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
28470     return (void *)((wxEvent *)  ((wxCommandEvent *) x));
28471 }
28472 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
28473     return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
28474 }
28475 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
28476     return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
28477 }
28478 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
28479     return (void *)((wxEvent *)  ((wxNavigationKeyEvent *) x));
28480 }
28481 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
28482     return (void *)((wxEvent *)  ((wxKeyEvent *) x));
28483 }
28484 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
28485     return (void *)((wxEvent *)  ((wxScrollWinEvent *) x));
28486 }
28487 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
28488     return (void *)((wxEvent *)  ((wxTaskBarIconEvent *) x));
28489 }
28490 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
28491     return (void *)((wxNotifyEvent *)  ((wxSplitterEvent *) x));
28492 }
28493 static void *_p_wxPasswordEntryDialogTo_p_wxTextEntryDialog(void *x) {
28494     return (void *)((wxTextEntryDialog *)  ((wxPasswordEntryDialog *) x));
28495 }
28496 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
28497     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
28498 }
28499 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
28500     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
28501 }
28502 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
28503     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
28504 }
28505 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
28506     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
28507 }
28508 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
28509     return (void *)((wxEvtHandler *)  ((wxValidator *) x));
28510 }
28511 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
28512     return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
28513 }
28514 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
28515     return (void *)((wxEvtHandler *)  ((wxMenu *) x));
28516 }
28517 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
28518     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
28519 }
28520 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
28521     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
28522 }
28523 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
28524     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
28525 }
28526 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
28527     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
28528 }
28529 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
28530     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
28531 }
28532 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
28533     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
28534 }
28535 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
28536     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
28537 }
28538 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
28539     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
28540 }
28541 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
28542     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
28543 }
28544 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
28545     return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
28546 }
28547 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
28548     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
28549 }
28550 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
28551     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
28552 }
28553 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
28554     return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
28555 }
28556 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
28557     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
28558 }
28559 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
28560     return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
28561 }
28562 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
28563     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
28564 }
28565 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
28566     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
28567 }
28568 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
28569     return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
28570 }
28571 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
28572     return (void *)((wxEvtHandler *)  ((wxWindow *) x));
28573 }
28574 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
28575     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
28576 }
28577 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
28578     return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
28579 }
28580 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
28581     return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
28582 }
28583 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
28584     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
28585 }
28586 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
28587     return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
28588 }
28589 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
28590     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
28591 }
28592 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
28593     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28594 }
28595 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
28596     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
28597 }
28598 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
28599     return (void *)((wxEvtHandler *)  ((wxPyApp *) x));
28600 }
28601 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
28602     return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
28603 }
28604 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
28605     return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
28606 }
28607 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
28608     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
28609 }
28610 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
28611     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
28612 }
28613 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
28614     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
28615 }
28616 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
28617     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
28618 }
28619 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
28620     return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
28621 }
28622 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
28623     return (void *)((wxEvtHandler *)  ((wxPyTaskBarIcon *) x));
28624 }
28625 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
28626     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
28627 }
28628 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
28629     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
28630 }
28631 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
28632     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
28633 }
28634 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
28635     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
28636 }
28637 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
28638     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
28639 }
28640 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
28641     return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
28642 }
28643 static void *_p_wxPyHtmlListBoxTo_p_wxPyVListBox(void *x) {
28644     return (void *)((wxPyVListBox *)  ((wxPyHtmlListBox *) x));
28645 }
28646 static void *_p_wxMDIChildFrameTo_p_wxFrame(void *x) {
28647     return (void *)((wxFrame *)  ((wxMDIChildFrame *) x));
28648 }
28649 static void *_p_wxProgressDialogTo_p_wxFrame(void *x) {
28650     return (void *)((wxFrame *)  ((wxProgressDialog *) x));
28651 }
28652 static void *_p_wxTipWindowTo_p_wxFrame(void *x) {
28653     return (void *)((wxFrame *)  ((wxTipWindow *) x));
28654 }
28655 static void *_p_wxPreviewFrameTo_p_wxFrame(void *x) {
28656     return (void *)((wxFrame *)  ((wxPreviewFrame *) x));
28657 }
28658 static void *_p_wxPyPreviewFrameTo_p_wxFrame(void *x) {
28659     return (void *)((wxFrame *) (wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28660 }
28661 static void *_p_wxMiniFrameTo_p_wxFrame(void *x) {
28662     return (void *)((wxFrame *)  ((wxMiniFrame *) x));
28663 }
28664 static void *_p_wxSplashScreenTo_p_wxFrame(void *x) {
28665     return (void *)((wxFrame *)  ((wxSplashScreen *) x));
28666 }
28667 static void *_p_wxMDIParentFrameTo_p_wxFrame(void *x) {
28668     return (void *)((wxFrame *)  ((wxMDIParentFrame *) x));
28669 }
28670 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
28671     return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
28672 }
28673 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
28674     return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
28675 }
28676 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
28677     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
28678 }
28679 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
28680     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
28681 }
28682 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
28683     return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
28684 }
28685 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
28686     return (void *)((wxObject *)  ((wxSizerItem *) x));
28687 }
28688 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
28689     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
28690 }
28691 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
28692     return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
28693 }
28694 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
28695     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
28696 }
28697 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
28698     return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
28699 }
28700 static void *_p_wxSizerTo_p_wxObject(void *x) {
28701     return (void *)((wxObject *)  ((wxSizer *) x));
28702 }
28703 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
28704     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
28705 }
28706 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
28707     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
28708 }
28709 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
28710     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
28711 }
28712 static void *_p_wxEventTo_p_wxObject(void *x) {
28713     return (void *)((wxObject *)  ((wxEvent *) x));
28714 }
28715 static void *_p_wxFontDataTo_p_wxObject(void *x) {
28716     return (void *)((wxObject *)  ((wxFontData *) x));
28717 }
28718 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
28719     return (void *)((wxObject *)  ((wxPrintData *) x));
28720 }
28721 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
28722     return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
28723 }
28724 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
28725     return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
28726 }
28727 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
28728     return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
28729 }
28730 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
28731     return (void *)((wxObject *)  ((wxLayoutAlgorithm *) x));
28732 }
28733 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
28734     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
28735 }
28736 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
28737     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
28738 }
28739 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
28740     return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
28741 }
28742 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
28743     return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
28744 }
28745 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
28746     return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
28747 }
28748 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
28749     return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
28750 }
28751 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
28752     return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
28753 }
28754 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
28755     return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
28756 }
28757 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
28758     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
28759 }
28760 static void *_p_wxControlTo_p_wxObject(void *x) {
28761     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
28762 }
28763 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
28764     return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
28765 }
28766 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
28767     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
28768 }
28769 static void *_p_wxFSFileTo_p_wxObject(void *x) {
28770     return (void *)((wxObject *)  ((wxFSFile *) x));
28771 }
28772 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
28773     return (void *)((wxObject *)  ((wxFindReplaceData *) x));
28774 }
28775 static void *_p_wxPySizerTo_p_wxObject(void *x) {
28776     return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
28777 }
28778 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
28779     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
28780 }
28781 static void *_p_wxColourDataTo_p_wxObject(void *x) {
28782     return (void *)((wxObject *)  ((wxColourData *) x));
28783 }
28784 static void *_p_wxPyEventTo_p_wxObject(void *x) {
28785     return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
28786 }
28787 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
28788     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
28789 }
28790 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
28791     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
28792 }
28793 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
28794     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
28795 }
28796 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
28797     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
28798 }
28799 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
28800     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
28801 }
28802 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
28803     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
28804 }
28805 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
28806     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
28807 }
28808 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
28809     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
28810 }
28811 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
28812     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
28813 }
28814 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
28815     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
28816 }
28817 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
28818     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
28819 }
28820 static void *_p_wxShowEventTo_p_wxObject(void *x) {
28821     return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
28822 }
28823 static void *_p_wxPrinterTo_p_wxObject(void *x) {
28824     return (void *)((wxObject *)  ((wxPrinter *) x));
28825 }
28826 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
28827     return (void *)((wxObject *)  ((wxMenuItem *) x));
28828 }
28829 static void *_p_wxDateEventTo_p_wxObject(void *x) {
28830     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
28831 }
28832 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
28833     return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
28834 }
28835 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
28836     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
28837 }
28838 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
28839     return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
28840 }
28841 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
28842     return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
28843 }
28844 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
28845     return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
28846 }
28847 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
28848     return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
28849 }
28850 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
28851     return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
28852 }
28853 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
28854     return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
28855 }
28856 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
28857     return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
28858 }
28859 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
28860     return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
28861 }
28862 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
28863     return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
28864 }
28865 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
28866     return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
28867 }
28868 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
28869     return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
28870 }
28871 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
28872     return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
28873 }
28874 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
28875     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
28876 }
28877 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
28878     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
28879 }
28880 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
28881     return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
28882 }
28883 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
28884     return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
28885 }
28886 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
28887     return (void *)((wxObject *)  ((wxImageHandler *) x));
28888 }
28889 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
28890     return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
28891 }
28892 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
28893     return (void *)((wxObject *)  ((wxEvtHandler *) x));
28894 }
28895 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
28896     return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
28897 }
28898 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
28899     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
28900 }
28901 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
28902     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
28903 }
28904 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
28905     return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
28906 }
28907 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
28908     return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
28909 }
28910 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
28911     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
28912 }
28913 static void *_p_wxImageTo_p_wxObject(void *x) {
28914     return (void *)((wxObject *)  ((wxImage *) x));
28915 }
28916 static void *_p_wxFrameTo_p_wxObject(void *x) {
28917     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
28918 }
28919 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
28920     return (void *)((wxObject *)  ((wxPyPrintout *) x));
28921 }
28922 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
28923     return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
28924 }
28925 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
28926     return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
28927 }
28928 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
28929     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
28930 }
28931 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
28932     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
28933 }
28934 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
28935     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
28936 }
28937 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
28938     return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
28939 }
28940 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
28941     return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
28942 }
28943 static void *_p_wxWindowTo_p_wxObject(void *x) {
28944     return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
28945 }
28946 static void *_p_wxMenuTo_p_wxObject(void *x) {
28947     return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
28948 }
28949 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
28950     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
28951 }
28952 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
28953     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
28954 }
28955 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
28956     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
28957 }
28958 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
28959     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
28960 }
28961 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
28962     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
28963 }
28964 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
28965     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
28966 }
28967 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
28968     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
28969 }
28970 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
28971     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
28972 }
28973 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
28974     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
28975 }
28976 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
28977     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
28978 }
28979 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
28980     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
28981 }
28982 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
28983     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
28984 }
28985 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
28986     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
28987 }
28988 static void *_p_wxSashEventTo_p_wxObject(void *x) {
28989     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
28990 }
28991 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
28992     return (void *)((wxObject *)  ((wxPrintPreview *) x));
28993 }
28994 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
28995     return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
28996 }
28997 static void *_p_wxPanelTo_p_wxObject(void *x) {
28998     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
28999 }
29000 static void *_p_wxDialogTo_p_wxObject(void *x) {
29001     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
29002 }
29003 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
29004     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
29005 }
29006 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
29007     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
29008 }
29009 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
29010     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
29011 }
29012 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
29013     return (void *)((wxObject *)  ((wxPageSetupDialog *) x));
29014 }
29015 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
29016     return (void *)((wxObject *)  ((wxPrintDialog *) x));
29017 }
29018 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
29019     return (void *)((wxObject *)  ((wxFileSystem *) x));
29020 }
29021 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
29022     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
29023 }
29024 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
29025     return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
29026 }
29027 static void *_p_wxPyAppTo_p_wxObject(void *x) {
29028     return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
29029 }
29030 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
29031     return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
29032 }
29033 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
29034     return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
29035 }
29036 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
29037     return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
29038 }
29039 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
29040     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
29041 }
29042 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
29043     return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
29044 }
29045 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
29046     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
29047 }
29048 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
29049     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29050 }
29051 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
29052     return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
29053 }
29054 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
29055     return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
29056 }
29057 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
29058     return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
29059 }
29060 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
29061     return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
29062 }
29063 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
29064     return (void *)((wxObject *)  ((wxPageSetupDialogData *) x));
29065 }
29066 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
29067     return (void *)((wxObject *)  ((wxPrintDialogData *) x));
29068 }
29069 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
29070     return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
29071 }
29072 static void *_p_wxValidatorTo_p_wxObject(void *x) {
29073     return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
29074 }
29075 static void *_p_wxPyVListBoxTo_p_wxPyVScrolledWindow(void *x) {
29076     return (void *)((wxPyVScrolledWindow *)  ((wxPyVListBox *) x));
29077 }
29078 static void *_p_wxPyHtmlListBoxTo_p_wxPyVScrolledWindow(void *x) {
29079     return (void *)((wxPyVScrolledWindow *) (wxPyVListBox *) ((wxPyHtmlListBox *) x));
29080 }
29081 static void *_p_wxPyPopupTransientWindowTo_p_wxPopupWindow(void *x) {
29082     return (void *)((wxPopupWindow *)  ((wxPyPopupTransientWindow *) x));
29083 }
29084 static void *_p_wxSashLayoutWindowTo_p_wxSashWindow(void *x) {
29085     return (void *)((wxSashWindow *)  ((wxSashLayoutWindow *) x));
29086 }
29087 static void *_p_wxFrameTo_p_wxTopLevelWindow(void *x) {
29088     return (void *)((wxTopLevelWindow *)  ((wxFrame *) x));
29089 }
29090 static void *_p_wxMiniFrameTo_p_wxTopLevelWindow(void *x) {
29091     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMiniFrame *) x));
29092 }
29093 static void *_p_wxFontDialogTo_p_wxTopLevelWindow(void *x) {
29094     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFontDialog *) x));
29095 }
29096 static void *_p_wxDirDialogTo_p_wxTopLevelWindow(void *x) {
29097     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxDirDialog *) x));
29098 }
29099 static void *_p_wxColourDialogTo_p_wxTopLevelWindow(void *x) {
29100     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxColourDialog *) x));
29101 }
29102 static void *_p_wxDialogTo_p_wxTopLevelWindow(void *x) {
29103     return (void *)((wxTopLevelWindow *)  ((wxDialog *) x));
29104 }
29105 static void *_p_wxSplashScreenTo_p_wxTopLevelWindow(void *x) {
29106     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxSplashScreen *) x));
29107 }
29108 static void *_p_wxTipWindowTo_p_wxTopLevelWindow(void *x) {
29109     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxTipWindow *) x));
29110 }
29111 static void *_p_wxMDIParentFrameTo_p_wxTopLevelWindow(void *x) {
29112     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIParentFrame *) x));
29113 }
29114 static void *_p_wxMDIChildFrameTo_p_wxTopLevelWindow(void *x) {
29115     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIChildFrame *) x));
29116 }
29117 static void *_p_wxMessageDialogTo_p_wxTopLevelWindow(void *x) {
29118     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMessageDialog *) x));
29119 }
29120 static void *_p_wxPasswordEntryDialogTo_p_wxTopLevelWindow(void *x) {
29121     return (void *)((wxTopLevelWindow *) (wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29122 }
29123 static void *_p_wxTextEntryDialogTo_p_wxTopLevelWindow(void *x) {
29124     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxTextEntryDialog *) x));
29125 }
29126 static void *_p_wxSingleChoiceDialogTo_p_wxTopLevelWindow(void *x) {
29127     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxSingleChoiceDialog *) x));
29128 }
29129 static void *_p_wxMultiChoiceDialogTo_p_wxTopLevelWindow(void *x) {
29130     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMultiChoiceDialog *) x));
29131 }
29132 static void *_p_wxFileDialogTo_p_wxTopLevelWindow(void *x) {
29133     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFileDialog *) x));
29134 }
29135 static void *_p_wxProgressDialogTo_p_wxTopLevelWindow(void *x) {
29136     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxProgressDialog *) x));
29137 }
29138 static void *_p_wxFindReplaceDialogTo_p_wxTopLevelWindow(void *x) {
29139     return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFindReplaceDialog *) x));
29140 }
29141 static void *_p_wxPreviewFrameTo_p_wxTopLevelWindow(void *x) {
29142     return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxPreviewFrame *) x));
29143 }
29144 static void *_p_wxPyPreviewFrameTo_p_wxTopLevelWindow(void *x) {
29145     return (void *)((wxTopLevelWindow *) (wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
29146 }
29147 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
29148     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
29149 }
29150 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
29151     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
29152 }
29153 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
29154     return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
29155 }
29156 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
29157     return (void *)((wxWindow *)  ((wxMenuBar *) x));
29158 }
29159 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
29160     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
29161 }
29162 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
29163     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
29164 }
29165 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
29166     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
29167 }
29168 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
29169     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29170 }
29171 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
29172     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
29173 }
29174 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
29175     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
29176 }
29177 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
29178     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
29179 }
29180 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
29181     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
29182 }
29183 static void *_p_wxPanelTo_p_wxWindow(void *x) {
29184     return (void *)((wxWindow *)  ((wxPanel *) x));
29185 }
29186 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
29187     return (void *)((wxWindow *)  ((wxStatusBar *) x));
29188 }
29189 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
29190     return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
29191 }
29192 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
29193     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
29194 }
29195 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
29196     return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
29197 }
29198 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
29199     return (void *)((wxWindow *)  ((wxPopupWindow *) x));
29200 }
29201 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
29202     return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
29203 }
29204 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
29205     return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
29206 }
29207 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
29208     return (void *)((wxWindow *)  ((wxTopLevelWindow *) x));
29209 }
29210 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
29211     return (void *)((wxWindow *)  ((wxSplashScreenWindow *) x));
29212 }
29213 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
29214     return (void *)((wxWindow *)  ((wxSplitterWindow *) x));
29215 }
29216 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
29217     return (void *)((wxWindow *)  ((wxSashWindow *) x));
29218 }
29219 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
29220     return (void *)((wxWindow *)  ((wxMDIClientWindow *) x));
29221 }
29222 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
29223     return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29224 }
29225 static void *_p_wxControlTo_p_wxWindow(void *x) {
29226     return (void *)((wxWindow *)  ((wxControl *) x));
29227 }
29228 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
29229     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
29230 }
29231 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
29232     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
29233 }
29234 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
29235     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
29236 }
29237 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
29238     return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
29239 }
29240 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
29241     return (void *)((wxWindow *)  ((wxPyWindow *) x));
29242 }
29243 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
29244     return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
29245 }
29246 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
29247     return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29248 }
29249 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
29250     return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29251 }
29252 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
29253     return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
29254 }
29255 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
29256     return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29257 }
29258 static void *_p_wxFrameTo_p_wxWindow(void *x) {
29259     return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
29260 }
29261 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
29262     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
29263 }
29264 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
29265     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
29266 }
29267 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
29268     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
29269 }
29270 static void *_p_wxDialogTo_p_wxWindow(void *x) {
29271     return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
29272 }
29273 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
29274     return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
29275 }
29276 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
29277     return (void *)((wxScrolledWindow *)  ((wxPyScrolledWindow *) x));
29278 }
29279 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
29280     return (void *)((wxScrolledWindow *)  ((wxPreviewCanvas *) x));
29281 }
29282 static void *_p_wxPyPrintPreviewTo_p_wxPrintPreview(void *x) {
29283     return (void *)((wxPrintPreview *)  ((wxPyPrintPreview *) x));
29284 }
29285 static void *_p_wxColourDialogTo_p_wxDialog(void *x) {
29286     return (void *)((wxDialog *)  ((wxColourDialog *) x));
29287 }
29288 static void *_p_wxDirDialogTo_p_wxDialog(void *x) {
29289     return (void *)((wxDialog *)  ((wxDirDialog *) x));
29290 }
29291 static void *_p_wxFontDialogTo_p_wxDialog(void *x) {
29292     return (void *)((wxDialog *)  ((wxFontDialog *) x));
29293 }
29294 static void *_p_wxFileDialogTo_p_wxDialog(void *x) {
29295     return (void *)((wxDialog *)  ((wxFileDialog *) x));
29296 }
29297 static void *_p_wxMultiChoiceDialogTo_p_wxDialog(void *x) {
29298     return (void *)((wxDialog *)  ((wxMultiChoiceDialog *) x));
29299 }
29300 static void *_p_wxSingleChoiceDialogTo_p_wxDialog(void *x) {
29301     return (void *)((wxDialog *)  ((wxSingleChoiceDialog *) x));
29302 }
29303 static void *_p_wxTextEntryDialogTo_p_wxDialog(void *x) {
29304     return (void *)((wxDialog *)  ((wxTextEntryDialog *) x));
29305 }
29306 static void *_p_wxPasswordEntryDialogTo_p_wxDialog(void *x) {
29307     return (void *)((wxDialog *) (wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
29308 }
29309 static void *_p_wxMessageDialogTo_p_wxDialog(void *x) {
29310     return (void *)((wxDialog *)  ((wxMessageDialog *) x));
29311 }
29312 static void *_p_wxFindReplaceDialogTo_p_wxDialog(void *x) {
29313     return (void *)((wxDialog *)  ((wxFindReplaceDialog *) x));
29314 }
29315 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
29316     return (void *)((wxPanel *)  ((wxScrolledWindow *) x));
29317 }
29318 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
29319     return (void *)((wxPanel *)  ((wxPyVScrolledWindow *) x));
29320 }
29321 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
29322     return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
29323 }
29324 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
29325     return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
29326 }
29327 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
29328     return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
29329 }
29330 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
29331     return (void *)((wxPanel *)  ((wxPyPanel *) x));
29332 }
29333 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
29334     return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
29335 }
29336 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
29337     return (void *)((wxPanel *)  ((wxPreviewControlBar *) x));
29338 }
29339 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
29340     return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
29341 }
29342 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
29343     return (void *)((wxCommandEvent *)  ((wxChildFocusEvent *) x));
29344 }
29345 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
29346     return (void *)((wxCommandEvent *)  ((wxScrollEvent *) x));
29347 }
29348 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
29349     return (void *)((wxCommandEvent *)  ((wxWindowCreateEvent *) x));
29350 }
29351 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
29352     return (void *)((wxCommandEvent *)  ((wxDateEvent *) x));
29353 }
29354 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
29355     return (void *)((wxCommandEvent *)  ((wxUpdateUIEvent *) x));
29356 }
29357 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
29358     return (void *)((wxCommandEvent *)  ((wxFindDialogEvent *) x));
29359 }
29360 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
29361     return (void *)((wxCommandEvent *)  ((wxWindowDestroyEvent *) x));
29362 }
29363 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
29364     return (void *)((wxCommandEvent *)  ((wxContextMenuEvent *) x));
29365 }
29366 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
29367     return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
29368 }
29369 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
29370     return (void *)((wxCommandEvent *)  ((wxNotifyEvent *) x));
29371 }
29372 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
29373     return (void *)((wxCommandEvent *)  ((wxPyCommandEvent *) x));
29374 }
29375 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
29376     return (void *)((wxCommandEvent *)  ((wxSashEvent *) x));
29377 }
29378 static void *_p_wxPyPreviewControlBarTo_p_wxPreviewControlBar(void *x) {
29379     return (void *)((wxPreviewControlBar *)  ((wxPyPreviewControlBar *) x));
29380 }
29381 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}};
29382 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}};
29383 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}};
29384 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}};
29385 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}};
29386 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}};
29387 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}};
29388 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}};
29389 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}};
29390 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}};
29391 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}};
29392 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}};
29393 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}};
29394 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}};
29395 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}};
29396 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}};
29397 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}};
29398 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}};
29399 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}};
29400 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}};
29401 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}};
29402 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}};
29403 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}};
29404 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}};
29405 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}};
29406 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}};
29407 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}};
29408 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}};
29409 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}};
29410 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}};
29411 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}};
29412 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}};
29413 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}};
29414 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}};
29415 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}};
29416 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}};
29417 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}};
29418 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}};
29419 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}};
29420 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}};
29421 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}};
29422 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}};
29423 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_wxTipWindow", _p_wxTipWindowTo_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_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_wxDialog", _p_wxDialogTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxColourDialog", _p_wxColourDialogTo_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}};
29424 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}};
29425 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}};
29426 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}};
29427 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}};
29428 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}};
29429 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}};
29430 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}};
29431 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_wxTipWindow", _p_wxTipWindowTo_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}};
29432 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}};
29433 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}};
29434 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}};
29435 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}};
29436 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}};
29437 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}};
29438 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}};
29439 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_wxTipWindow", _p_wxTipWindowTo_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_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}};
29440 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}};
29441 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}};
29442 static swig_type_info _swigt__p_wxPyPopupTransientWindow[] = {{"_p_wxPyPopupTransientWindow", 0, "wxPyPopupTransientWindow *", 0, 0, 0, 0},{"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
29443 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}};
29444 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}};
29445 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}};
29446 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}};
29447 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},{0, 0, 0, 0, 0, 0, 0}};
29448 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}};
29449 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_wxTipWindow", _p_wxTipWindowTo_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_wxProgressDialog", _p_wxProgressDialogTo_p_wxTopLevelWindow, 0, 0, 0, 0, 0},{"_p_wxFileDialog", _p_wxFileDialogTo_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}};
29450 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_wxTipWindow", _p_wxTipWindowTo_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_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}};
29451 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}};
29452 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}};
29453 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}};
29454 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}};
29455 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}};
29456 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}};
29457 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}};
29458 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}};
29459 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}};
29460 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}};
29461 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}};
29462 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}};
29463 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}};
29464 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}};
29465 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}};
29466 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}};
29467 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}};
29468 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}};
29469 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}};
29470 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}};
29471 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}};
29472 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}};
29473 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}};
29474 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}};
29475 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}};
29476 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}};
29477 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}};
29478
29479 static swig_type_info *swig_types_initial[] = {
29480 _swigt__p_wxQueryLayoutInfoEvent,
29481 _swigt__p_wxPreviewFrame,
29482 _swigt__p_wxPyPreviewFrame,
29483 _swigt__p_wxPyPanel,
29484 _swigt__p_wxMenu,
29485 _swigt__p_wxFontData,
29486 _swigt__p_wxEvent,
29487 _swigt__p_wxPrintData,
29488 _swigt__p_wxTaskBarIcon,
29489 _swigt__p_wxPyTaskBarIcon,
29490 _swigt__p_wxIconBundle,
29491 _swigt__p_wxLayoutAlgorithm,
29492 _swigt__p_wxFindDialogEvent,
29493 _swigt__p_wxPreviewCanvas,
29494 _swigt__p_wxFont,
29495 _swigt__p_wxSplitterEvent,
29496 _swigt__p_wxRegion,
29497 _swigt__ptrdiff_t,
29498 _swigt__std__ptrdiff_t,
29499 _swigt__p_wxFindReplaceData,
29500 _swigt__p_int,
29501 _swigt__p_wxSize,
29502 _swigt__p_wxDC,
29503 _swigt__p_wxIcon,
29504 _swigt__p_wxVisualAttributes,
29505 _swigt__p_wxMDIChildFrame,
29506 _swigt__p_wxColourData,
29507 _swigt__p_wxNotifyEvent,
29508 _swigt__p_wxPyWindow,
29509 _swigt__p_form_ops_t,
29510 _swigt__p_wxSplashScreen,
29511 _swigt__p_wxPasswordEntryDialog,
29512 _swigt__p_wxSingleChoiceDialog,
29513 _swigt__p_wxMultiChoiceDialog,
29514 _swigt__p_wxFileDialog,
29515 _swigt__p_wxTextEntryDialog,
29516 _swigt__p_wxMessageDialog,
29517 _swigt__p_wxProgressDialog,
29518 _swigt__p_wxFindReplaceDialog,
29519 _swigt__p_wxPrinter,
29520 _swigt__p_wxArrayInt,
29521 _swigt__p_wxDuplexMode,
29522 _swigt__p_wxEvtHandler,
29523 _swigt__p_wxCalculateLayoutEvent,
29524 _swigt__p_wxPyHtmlListBox,
29525 _swigt__p_wxPyVListBox,
29526 _swigt__p_wxRect,
29527 _swigt__p_wxStdDialogButtonSizer,
29528 _swigt__p_char,
29529 _swigt__p_wxMiniFrame,
29530 _swigt__p_wxFrame,
29531 _swigt__p_wxPyPrintout,
29532 _swigt__p_wxTaskBarIconEvent,
29533 _swigt__p_wxScrollWinEvent,
29534 _swigt__p_wxPaperSize,
29535 _swigt__p_wxStatusBar,
29536 _swigt__p_wxMDIParentFrame,
29537 _swigt__p_wxPoint,
29538 _swigt__p_wxObject,
29539 _swigt__p_unsigned_long,
29540 _swigt__p_wxTipWindow,
29541 _swigt__p_wxPyPopupTransientWindow,
29542 _swigt__p_wxSashLayoutWindow,
29543 _swigt__p_wxSplitterWindow,
29544 _swigt__p_wxSplashScreenWindow,
29545 _swigt__p_wxPyVScrolledWindow,
29546 _swigt__p_wxPopupWindow,
29547 _swigt__p_wxSashWindow,
29548 _swigt__p_wxTopLevelWindow,
29549 _swigt__p_wxWindow,
29550 _swigt__p_wxScrolledWindow,
29551 _swigt__p_wxMenuBar,
29552 _swigt__p_wxMDIClientWindow,
29553 _swigt__p_wxPyScrolledWindow,
29554 _swigt__p_wxPrintPreview,
29555 _swigt__p_wxSashEvent,
29556 _swigt__p_wxString,
29557 _swigt__p_wxPyPrintPreview,
29558 _swigt__p_wxDirDialog,
29559 _swigt__p_wxColourDialog,
29560 _swigt__p_wxDialog,
29561 _swigt__p_wxPanel,
29562 _swigt__p_wxFontDialog,
29563 _swigt__p_wxPageSetupDialog,
29564 _swigt__p_wxPrintDialog,
29565 _swigt__p_wxFileSystem,
29566 _swigt__p_wxBitmap,
29567 _swigt__unsigned_int,
29568 _swigt__p_unsigned_int,
29569 _swigt__p_unsigned_char,
29570 _swigt__p_wxCommandEvent,
29571 _swigt__p_wxPreviewControlBar,
29572 _swigt__p_wxPyPreviewControlBar,
29573 _swigt__p_wxColour,
29574 _swigt__p_wxToolBar,
29575 _swigt__p_wxPageSetupDialogData,
29576 _swigt__p_wxPrintDialogData,
29577 0
29578 };
29579
29580
29581 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
29582
29583 static swig_const_info swig_const_table[] = {
29584 {0, 0, 0, 0.0, 0, 0}};
29585
29586 #ifdef __cplusplus
29587 }
29588 #endif
29589
29590
29591 #ifdef __cplusplus
29592 extern "C" {
29593 #endif
29594
29595     /* Python-specific SWIG API */
29596 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
29597 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
29598 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
29599
29600     /* -----------------------------------------------------------------------------
29601      * global variable support code.
29602      * ----------------------------------------------------------------------------- */
29603
29604     typedef struct swig_globalvar {
29605         char       *name;                  /* Name of global variable */
29606         PyObject *(*get_attr)();           /* Return the current value */
29607         int       (*set_attr)(PyObject *); /* Set the value */
29608         struct swig_globalvar *next;
29609     } swig_globalvar;
29610
29611     typedef struct swig_varlinkobject {
29612         PyObject_HEAD
29613         swig_globalvar *vars;
29614     } swig_varlinkobject;
29615
29616     static PyObject *
29617     swig_varlink_repr(swig_varlinkobject *v) {
29618         v = v;
29619         return PyString_FromString("<Swig global variables>");
29620     }
29621
29622     static int
29623     swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
29624         swig_globalvar  *var;
29625         flags = flags;
29626         fprintf(fp,"Swig global variables { ");
29627         for (var = v->vars; var; var=var->next) {
29628             fprintf(fp,"%s", var->name);
29629             if (var->next) fprintf(fp,", ");
29630         }
29631         fprintf(fp," }\n");
29632         return 0;
29633     }
29634
29635     static PyObject *
29636     swig_varlink_getattr(swig_varlinkobject *v, char *n) {
29637         swig_globalvar *var = v->vars;
29638         while (var) {
29639             if (strcmp(var->name,n) == 0) {
29640                 return (*var->get_attr)();
29641             }
29642             var = var->next;
29643         }
29644         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29645         return NULL;
29646     }
29647
29648     static int
29649     swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
29650         swig_globalvar *var = v->vars;
29651         while (var) {
29652             if (strcmp(var->name,n) == 0) {
29653                 return (*var->set_attr)(p);
29654             }
29655             var = var->next;
29656         }
29657         PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29658         return 1;
29659     }
29660
29661     static PyTypeObject varlinktype = {
29662         PyObject_HEAD_INIT(0)
29663         0,                                  /* Number of items in variable part (ob_size) */
29664         (char *)"swigvarlink",              /* Type name (tp_name) */
29665         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
29666         0,                                  /* Itemsize (tp_itemsize) */
29667         0,                                  /* Deallocator (tp_dealloc) */
29668         (printfunc) swig_varlink_print,     /* Print (tp_print) */
29669         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
29670         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
29671         0,                                  /* tp_compare */
29672         (reprfunc) swig_varlink_repr,       /* tp_repr */
29673         0,                                  /* tp_as_number */
29674         0,                                  /* tp_as_sequence */
29675         0,                                  /* tp_as_mapping */
29676         0,                                  /* tp_hash */
29677         0,                                  /* tp_call */
29678         0,                                  /* tp_str */
29679         0,                                  /* tp_getattro */
29680         0,                                  /* tp_setattro */
29681         0,                                  /* tp_as_buffer */
29682         0,                                  /* tp_flags */
29683         0,                                  /* tp_doc */
29684 #if PY_VERSION_HEX >= 0x02000000
29685         0,                                  /* tp_traverse */
29686         0,                                  /* tp_clear */
29687 #endif
29688 #if PY_VERSION_HEX >= 0x02010000
29689         0,                                  /* tp_richcompare */
29690         0,                                  /* tp_weaklistoffset */
29691 #endif
29692 #if PY_VERSION_HEX >= 0x02020000
29693         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
29694 #endif
29695 #if PY_VERSION_HEX >= 0x02030000
29696         0,                                  /* tp_del */
29697 #endif
29698 #ifdef COUNT_ALLOCS
29699         0,0,0,0                             /* tp_alloc -> tp_next */
29700 #endif
29701     };
29702
29703     /* Create a variable linking object for use later */
29704     static PyObject *
29705     SWIG_Python_newvarlink(void) {
29706         swig_varlinkobject *result = 0;
29707         result = PyMem_NEW(swig_varlinkobject,1);
29708         varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
29709         result->ob_type = &varlinktype;
29710         result->vars = 0;
29711         result->ob_refcnt = 0;
29712         Py_XINCREF((PyObject *) result);
29713         return ((PyObject*) result);
29714     }
29715
29716     static void
29717     SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
29718         swig_varlinkobject *v;
29719         swig_globalvar *gv;
29720         v= (swig_varlinkobject *) p;
29721         gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
29722         gv->name = (char *) malloc(strlen(name)+1);
29723         strcpy(gv->name,name);
29724         gv->get_attr = get_attr;
29725         gv->set_attr = set_attr;
29726         gv->next = v->vars;
29727         v->vars = gv;
29728     }
29729
29730     /* -----------------------------------------------------------------------------
29731      * constants/methods manipulation
29732      * ----------------------------------------------------------------------------- */
29733
29734     /* Install Constants */
29735     static void
29736     SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
29737         PyObject *obj = 0;
29738         size_t i;
29739         for (i = 0; constants[i].type; i++) {
29740             switch(constants[i].type) {
29741                 case SWIG_PY_INT:
29742                 obj = PyInt_FromLong(constants[i].lvalue);
29743                 break;
29744                 case SWIG_PY_FLOAT:
29745                 obj = PyFloat_FromDouble(constants[i].dvalue);
29746                 break;
29747                 case SWIG_PY_STRING:
29748                 if (constants[i].pvalue) {
29749                     obj = PyString_FromString((char *) constants[i].pvalue);
29750                 } else {
29751                     Py_INCREF(Py_None);
29752                     obj = Py_None;
29753                 }
29754                 break;
29755                 case SWIG_PY_POINTER:
29756                 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
29757                 break;
29758                 case SWIG_PY_BINARY:
29759                 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
29760                 break;
29761                 default:
29762                 obj = 0;
29763                 break;
29764             }
29765             if (obj) {
29766                 PyDict_SetItemString(d,constants[i].name,obj);
29767                 Py_DECREF(obj);
29768             }
29769         }
29770     }
29771
29772     /* -----------------------------------------------------------------------------*/
29773     /* Fix SwigMethods to carry the callback ptrs when needed */
29774     /* -----------------------------------------------------------------------------*/
29775
29776     static void
29777     SWIG_Python_FixMethods(PyMethodDef *methods,
29778     swig_const_info *const_table,
29779     swig_type_info **types,
29780     swig_type_info **types_initial) {
29781         size_t i;
29782         for (i = 0; methods[i].ml_name; ++i) {
29783             char *c = methods[i].ml_doc;
29784             if (c && (c = strstr(c, "swig_ptr: "))) {
29785                 int j;
29786                 swig_const_info *ci = 0;
29787                 char *name = c + 10;
29788                 for (j = 0; const_table[j].type; j++) {
29789                     if (strncmp(const_table[j].name, name,
29790                     strlen(const_table[j].name)) == 0) {
29791                         ci = &(const_table[j]);
29792                         break;
29793                     }
29794                 }
29795                 if (ci) {
29796                     size_t shift = (ci->ptype) - types;
29797                     swig_type_info *ty = types_initial[shift];
29798                     size_t ldoc = (c - methods[i].ml_doc);
29799                     size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
29800                     char *ndoc = (char*)malloc(ldoc + lptr + 10);
29801                     char *buff = ndoc;
29802                     void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
29803                     strncpy(buff, methods[i].ml_doc, ldoc);
29804                     buff += ldoc;
29805                     strncpy(buff, "swig_ptr: ", 10);
29806                     buff += 10;
29807                     SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
29808                     methods[i].ml_doc = ndoc;
29809                 }
29810             }
29811         }
29812     }
29813
29814     /* -----------------------------------------------------------------------------*
29815      *  Initialize type list
29816      * -----------------------------------------------------------------------------*/
29817
29818 #if PY_MAJOR_VERSION < 2
29819     /* PyModule_AddObject function was introduced in Python 2.0.  The following function
29820     is copied out of Python/modsupport.c in python version 2.3.4 */
29821     static int
29822     PyModule_AddObject(PyObject *m, char *name, PyObject *o)
29823     {
29824         PyObject *dict;
29825         if (!PyModule_Check(m)) {
29826             PyErr_SetString(PyExc_TypeError,
29827             "PyModule_AddObject() needs module as first arg");
29828             return -1;
29829         }
29830         if (!o) {
29831             PyErr_SetString(PyExc_TypeError,
29832             "PyModule_AddObject() needs non-NULL value");
29833             return -1;
29834         }
29835
29836         dict = PyModule_GetDict(m);
29837         if (dict == NULL) {
29838             /* Internal error -- modules must have a dict! */
29839             PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
29840             PyModule_GetName(m));
29841             return -1;
29842         }
29843         if (PyDict_SetItemString(dict, name, o))
29844         return -1;
29845         Py_DECREF(o);
29846         return 0;
29847     }
29848 #endif
29849
29850     static swig_type_info **
29851     SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
29852         static PyMethodDef swig_empty_runtime_method_table[] = {
29853             {
29854                 NULL, NULL, 0, NULL
29855             }
29856         };/* Sentinel */
29857
29858         PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
29859         swig_empty_runtime_method_table);
29860         PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
29861         if (pointer && module) {
29862             PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
29863         }
29864         return type_list_handle;
29865     }
29866
29867     static swig_type_info **
29868     SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
29869         swig_type_info **type_pointer;
29870
29871         /* first check if module already created */
29872         type_pointer = SWIG_Python_GetTypeListHandle();
29873         if (type_pointer) {
29874             return type_pointer;
29875         } else {
29876             /* create a new module and variable */
29877             return SWIG_Python_SetTypeListHandle(type_list_handle);
29878         }
29879     }
29880
29881 #ifdef __cplusplus
29882 }
29883 #endif
29884
29885 /* -----------------------------------------------------------------------------*
29886  *  Partial Init method
29887  * -----------------------------------------------------------------------------*/
29888
29889 #ifdef SWIG_LINK_RUNTIME
29890 #ifdef __cplusplus
29891 extern "C"
29892 #endif
29893 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
29894 #endif
29895
29896 #ifdef __cplusplus
29897 extern "C"
29898 #endif
29899 SWIGEXPORT(void) SWIG_init(void) {
29900     static PyObject *SWIG_globals = 0;
29901     static int       typeinit = 0;
29902     PyObject *m, *d;
29903     int       i;
29904     if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
29905
29906     /* Fix SwigMethods to carry the callback ptrs when needed */
29907     SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
29908
29909     m = Py_InitModule((char *) SWIG_name, SwigMethods);
29910     d = PyModule_GetDict(m);
29911
29912     if (!typeinit) {
29913 #ifdef SWIG_LINK_RUNTIME
29914         swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
29915 #else
29916 #  ifndef SWIG_STATIC_RUNTIME
29917         swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
29918 #  endif
29919 #endif
29920         for (i = 0; swig_types_initial[i]; i++) {
29921             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
29922         }
29923         typeinit = 1;
29924     }
29925     SWIG_InstallConstants(d,swig_const_table);
29926
29927     PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
29928     SWIG_addvarlink(SWIG_globals,(char*)"FrameNameStr",_wrap_FrameNameStr_get, _wrap_FrameNameStr_set);
29929     SWIG_addvarlink(SWIG_globals,(char*)"DialogNameStr",_wrap_DialogNameStr_get, _wrap_DialogNameStr_set);
29930     SWIG_addvarlink(SWIG_globals,(char*)"StatusLineNameStr",_wrap_StatusLineNameStr_get, _wrap_StatusLineNameStr_set);
29931     SWIG_addvarlink(SWIG_globals,(char*)"ToolBarNameStr",_wrap_ToolBarNameStr_get, _wrap_ToolBarNameStr_set);
29932     {
29933         PyDict_SetItemString(d,"STAY_ON_TOP", SWIG_From_int((int)(wxSTAY_ON_TOP)));
29934     }
29935     {
29936         PyDict_SetItemString(d,"ICONIZE", SWIG_From_int((int)(wxICONIZE)));
29937     }
29938     {
29939         PyDict_SetItemString(d,"MINIMIZE", SWIG_From_int((int)(wxMINIMIZE)));
29940     }
29941     {
29942         PyDict_SetItemString(d,"MAXIMIZE", SWIG_From_int((int)(wxMAXIMIZE)));
29943     }
29944     {
29945         PyDict_SetItemString(d,"CLOSE_BOX", SWIG_From_int((int)(wxCLOSE_BOX)));
29946     }
29947     {
29948         PyDict_SetItemString(d,"THICK_FRAME", SWIG_From_int((int)(wxTHICK_FRAME)));
29949     }
29950     {
29951         PyDict_SetItemString(d,"SYSTEM_MENU", SWIG_From_int((int)(wxSYSTEM_MENU)));
29952     }
29953     {
29954         PyDict_SetItemString(d,"MINIMIZE_BOX", SWIG_From_int((int)(wxMINIMIZE_BOX)));
29955     }
29956     {
29957         PyDict_SetItemString(d,"MAXIMIZE_BOX", SWIG_From_int((int)(wxMAXIMIZE_BOX)));
29958     }
29959     {
29960         PyDict_SetItemString(d,"TINY_CAPTION_HORIZ", SWIG_From_int((int)(wxTINY_CAPTION_HORIZ)));
29961     }
29962     {
29963         PyDict_SetItemString(d,"TINY_CAPTION_VERT", SWIG_From_int((int)(wxTINY_CAPTION_VERT)));
29964     }
29965     {
29966         PyDict_SetItemString(d,"RESIZE_BOX", SWIG_From_int((int)(wxRESIZE_BOX)));
29967     }
29968     {
29969         PyDict_SetItemString(d,"RESIZE_BORDER", SWIG_From_int((int)(wxRESIZE_BORDER)));
29970     }
29971     {
29972         PyDict_SetItemString(d,"DIALOG_NO_PARENT", SWIG_From_int((int)(wxDIALOG_NO_PARENT)));
29973     }
29974     {
29975         PyDict_SetItemString(d,"DEFAULT_FRAME_STYLE", SWIG_From_int((int)(wxDEFAULT_FRAME_STYLE)));
29976     }
29977     {
29978         PyDict_SetItemString(d,"DEFAULT_DIALOG_STYLE", SWIG_From_int((int)(wxDEFAULT_DIALOG_STYLE)));
29979     }
29980     {
29981         PyDict_SetItemString(d,"FRAME_TOOL_WINDOW", SWIG_From_int((int)(wxFRAME_TOOL_WINDOW)));
29982     }
29983     {
29984         PyDict_SetItemString(d,"FRAME_FLOAT_ON_PARENT", SWIG_From_int((int)(wxFRAME_FLOAT_ON_PARENT)));
29985     }
29986     {
29987         PyDict_SetItemString(d,"FRAME_NO_WINDOW_MENU", SWIG_From_int((int)(wxFRAME_NO_WINDOW_MENU)));
29988     }
29989     {
29990         PyDict_SetItemString(d,"FRAME_NO_TASKBAR", SWIG_From_int((int)(wxFRAME_NO_TASKBAR)));
29991     }
29992     {
29993         PyDict_SetItemString(d,"FRAME_SHAPED", SWIG_From_int((int)(wxFRAME_SHAPED)));
29994     }
29995     {
29996         PyDict_SetItemString(d,"FRAME_DRAWER", SWIG_From_int((int)(wxFRAME_DRAWER)));
29997     }
29998     {
29999         PyDict_SetItemString(d,"FRAME_EX_METAL", SWIG_From_int((int)(wxFRAME_EX_METAL)));
30000     }
30001     {
30002         PyDict_SetItemString(d,"DIALOG_EX_METAL", SWIG_From_int((int)(wxDIALOG_EX_METAL)));
30003     }
30004     {
30005         PyDict_SetItemString(d,"DIALOG_MODAL", SWIG_From_int((int)(wxDIALOG_MODAL)));
30006     }
30007     {
30008         PyDict_SetItemString(d,"DIALOG_MODELESS", SWIG_From_int((int)(wxDIALOG_MODELESS)));
30009     }
30010     {
30011         PyDict_SetItemString(d,"USER_COLOURS", SWIG_From_int((int)(wxUSER_COLOURS)));
30012     }
30013     {
30014         PyDict_SetItemString(d,"NO_3D", SWIG_From_int((int)(wxNO_3D)));
30015     }
30016     {
30017         PyDict_SetItemString(d,"FULLSCREEN_NOMENUBAR", SWIG_From_int((int)(wxFULLSCREEN_NOMENUBAR)));
30018     }
30019     {
30020         PyDict_SetItemString(d,"FULLSCREEN_NOTOOLBAR", SWIG_From_int((int)(wxFULLSCREEN_NOTOOLBAR)));
30021     }
30022     {
30023         PyDict_SetItemString(d,"FULLSCREEN_NOSTATUSBAR", SWIG_From_int((int)(wxFULLSCREEN_NOSTATUSBAR)));
30024     }
30025     {
30026         PyDict_SetItemString(d,"FULLSCREEN_NOBORDER", SWIG_From_int((int)(wxFULLSCREEN_NOBORDER)));
30027     }
30028     {
30029         PyDict_SetItemString(d,"FULLSCREEN_NOCAPTION", SWIG_From_int((int)(wxFULLSCREEN_NOCAPTION)));
30030     }
30031     {
30032         PyDict_SetItemString(d,"FULLSCREEN_ALL", SWIG_From_int((int)(wxFULLSCREEN_ALL)));
30033     }
30034     {
30035         PyDict_SetItemString(d,"TOPLEVEL_EX_DIALOG", SWIG_From_int((int)(wxTOPLEVEL_EX_DIALOG)));
30036     }
30037     {
30038         PyDict_SetItemString(d,"USER_ATTENTION_INFO", SWIG_From_int((int)(wxUSER_ATTENTION_INFO)));
30039     }
30040     {
30041         PyDict_SetItemString(d,"USER_ATTENTION_ERROR", SWIG_From_int((int)(wxUSER_ATTENTION_ERROR)));
30042     }
30043     {
30044         PyDict_SetItemString(d,"SPLASH_CENTRE_ON_PARENT", SWIG_From_int((int)(wxSPLASH_CENTRE_ON_PARENT)));
30045     }
30046     {
30047         PyDict_SetItemString(d,"SPLASH_CENTRE_ON_SCREEN", SWIG_From_int((int)(wxSPLASH_CENTRE_ON_SCREEN)));
30048     }
30049     {
30050         PyDict_SetItemString(d,"SPLASH_NO_CENTRE", SWIG_From_int((int)(wxSPLASH_NO_CENTRE)));
30051     }
30052     {
30053         PyDict_SetItemString(d,"SPLASH_TIMEOUT", SWIG_From_int((int)(wxSPLASH_TIMEOUT)));
30054     }
30055     {
30056         PyDict_SetItemString(d,"SPLASH_NO_TIMEOUT", SWIG_From_int((int)(wxSPLASH_NO_TIMEOUT)));
30057     }
30058     {
30059         PyDict_SetItemString(d,"SB_NORMAL", SWIG_From_int((int)(wxSB_NORMAL)));
30060     }
30061     {
30062         PyDict_SetItemString(d,"SB_FLAT", SWIG_From_int((int)(wxSB_FLAT)));
30063     }
30064     {
30065         PyDict_SetItemString(d,"SB_RAISED", SWIG_From_int((int)(wxSB_RAISED)));
30066     }
30067     SWIG_addvarlink(SWIG_globals,(char*)"SplitterNameStr",_wrap_SplitterNameStr_get, _wrap_SplitterNameStr_set);
30068     {
30069         PyDict_SetItemString(d,"SP_NOBORDER", SWIG_From_int((int)(wxSP_NOBORDER)));
30070     }
30071     {
30072         PyDict_SetItemString(d,"SP_NOSASH", SWIG_From_int((int)(wxSP_NOSASH)));
30073     }
30074     {
30075         PyDict_SetItemString(d,"SP_PERMIT_UNSPLIT", SWIG_From_int((int)(wxSP_PERMIT_UNSPLIT)));
30076     }
30077     {
30078         PyDict_SetItemString(d,"SP_LIVE_UPDATE", SWIG_From_int((int)(wxSP_LIVE_UPDATE)));
30079     }
30080     {
30081         PyDict_SetItemString(d,"SP_3DSASH", SWIG_From_int((int)(wxSP_3DSASH)));
30082     }
30083     {
30084         PyDict_SetItemString(d,"SP_3DBORDER", SWIG_From_int((int)(wxSP_3DBORDER)));
30085     }
30086     {
30087         PyDict_SetItemString(d,"SP_NO_XP_THEME", SWIG_From_int((int)(wxSP_NO_XP_THEME)));
30088     }
30089     {
30090         PyDict_SetItemString(d,"SP_BORDER", SWIG_From_int((int)(wxSP_BORDER)));
30091     }
30092     {
30093         PyDict_SetItemString(d,"SP_3D", SWIG_From_int((int)(wxSP_3D)));
30094     }
30095     {
30096         PyDict_SetItemString(d,"SPLIT_HORIZONTAL", SWIG_From_int((int)(wxSPLIT_HORIZONTAL)));
30097     }
30098     {
30099         PyDict_SetItemString(d,"SPLIT_VERTICAL", SWIG_From_int((int)(wxSPLIT_VERTICAL)));
30100     }
30101     {
30102         PyDict_SetItemString(d,"SPLIT_DRAG_NONE", SWIG_From_int((int)(wxSPLIT_DRAG_NONE)));
30103     }
30104     {
30105         PyDict_SetItemString(d,"SPLIT_DRAG_DRAGGING", SWIG_From_int((int)(wxSPLIT_DRAG_DRAGGING)));
30106     }
30107     {
30108         PyDict_SetItemString(d,"SPLIT_DRAG_LEFT_DOWN", SWIG_From_int((int)(wxSPLIT_DRAG_LEFT_DOWN)));
30109     }
30110     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED));
30111     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING));
30112     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_DOUBLECLICKED));
30113     PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_UNSPLIT", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_UNSPLIT));
30114     SWIG_addvarlink(SWIG_globals,(char*)"SashNameStr",_wrap_SashNameStr_get, _wrap_SashNameStr_set);
30115     SWIG_addvarlink(SWIG_globals,(char*)"SashLayoutNameStr",_wrap_SashLayoutNameStr_get, _wrap_SashLayoutNameStr_set);
30116     {
30117         PyDict_SetItemString(d,"SASH_DRAG_NONE", SWIG_From_int((int)(wxSASH_DRAG_NONE)));
30118     }
30119     {
30120         PyDict_SetItemString(d,"SASH_DRAG_DRAGGING", SWIG_From_int((int)(wxSASH_DRAG_DRAGGING)));
30121     }
30122     {
30123         PyDict_SetItemString(d,"SASH_DRAG_LEFT_DOWN", SWIG_From_int((int)(wxSASH_DRAG_LEFT_DOWN)));
30124     }
30125     {
30126         PyDict_SetItemString(d,"SW_NOBORDER", SWIG_From_int((int)(wxSW_NOBORDER)));
30127     }
30128     {
30129         PyDict_SetItemString(d,"SW_BORDER", SWIG_From_int((int)(wxSW_BORDER)));
30130     }
30131     {
30132         PyDict_SetItemString(d,"SW_3DSASH", SWIG_From_int((int)(wxSW_3DSASH)));
30133     }
30134     {
30135         PyDict_SetItemString(d,"SW_3DBORDER", SWIG_From_int((int)(wxSW_3DBORDER)));
30136     }
30137     {
30138         PyDict_SetItemString(d,"SW_3D", SWIG_From_int((int)(wxSW_3D)));
30139     }
30140     {
30141         PyDict_SetItemString(d,"SASH_TOP", SWIG_From_int((int)(wxSASH_TOP)));
30142     }
30143     {
30144         PyDict_SetItemString(d,"SASH_RIGHT", SWIG_From_int((int)(wxSASH_RIGHT)));
30145     }
30146     {
30147         PyDict_SetItemString(d,"SASH_BOTTOM", SWIG_From_int((int)(wxSASH_BOTTOM)));
30148     }
30149     {
30150         PyDict_SetItemString(d,"SASH_LEFT", SWIG_From_int((int)(wxSASH_LEFT)));
30151     }
30152     {
30153         PyDict_SetItemString(d,"SASH_NONE", SWIG_From_int((int)(wxSASH_NONE)));
30154     }
30155     {
30156         PyDict_SetItemString(d,"SASH_STATUS_OK", SWIG_From_int((int)(wxSASH_STATUS_OK)));
30157     }
30158     {
30159         PyDict_SetItemString(d,"SASH_STATUS_OUT_OF_RANGE", SWIG_From_int((int)(wxSASH_STATUS_OUT_OF_RANGE)));
30160     }
30161     PyDict_SetItemString(d, "wxEVT_SASH_DRAGGED", PyInt_FromLong(wxEVT_SASH_DRAGGED));
30162     {
30163         PyDict_SetItemString(d,"LAYOUT_HORIZONTAL", SWIG_From_int((int)(wxLAYOUT_HORIZONTAL)));
30164     }
30165     {
30166         PyDict_SetItemString(d,"LAYOUT_VERTICAL", SWIG_From_int((int)(wxLAYOUT_VERTICAL)));
30167     }
30168     {
30169         PyDict_SetItemString(d,"LAYOUT_NONE", SWIG_From_int((int)(wxLAYOUT_NONE)));
30170     }
30171     {
30172         PyDict_SetItemString(d,"LAYOUT_TOP", SWIG_From_int((int)(wxLAYOUT_TOP)));
30173     }
30174     {
30175         PyDict_SetItemString(d,"LAYOUT_LEFT", SWIG_From_int((int)(wxLAYOUT_LEFT)));
30176     }
30177     {
30178         PyDict_SetItemString(d,"LAYOUT_RIGHT", SWIG_From_int((int)(wxLAYOUT_RIGHT)));
30179     }
30180     {
30181         PyDict_SetItemString(d,"LAYOUT_BOTTOM", SWIG_From_int((int)(wxLAYOUT_BOTTOM)));
30182     }
30183     {
30184         PyDict_SetItemString(d,"LAYOUT_LENGTH_Y", SWIG_From_int((int)(wxLAYOUT_LENGTH_Y)));
30185     }
30186     {
30187         PyDict_SetItemString(d,"LAYOUT_LENGTH_X", SWIG_From_int((int)(wxLAYOUT_LENGTH_X)));
30188     }
30189     {
30190         PyDict_SetItemString(d,"LAYOUT_MRU_LENGTH", SWIG_From_int((int)(wxLAYOUT_MRU_LENGTH)));
30191     }
30192     {
30193         PyDict_SetItemString(d,"LAYOUT_QUERY", SWIG_From_int((int)(wxLAYOUT_QUERY)));
30194     }
30195     PyDict_SetItemString(d, "wxEVT_QUERY_LAYOUT_INFO", PyInt_FromLong(wxEVT_QUERY_LAYOUT_INFO));
30196     PyDict_SetItemString(d, "wxEVT_CALCULATE_LAYOUT", PyInt_FromLong(wxEVT_CALCULATE_LAYOUT));
30197     SWIG_addvarlink(SWIG_globals,(char*)"VListBoxNameStr",_wrap_VListBoxNameStr_get, _wrap_VListBoxNameStr_set);
30198
30199     // Map renamed classes back to their common name for OOR
30200     wxPyPtrTypeMap_Add("wxHtmlListBox",     "wxPyHtmlListBox");
30201     wxPyPtrTypeMap_Add("wxVListBox",        "wxPyVListBox");
30202     wxPyPtrTypeMap_Add("wxVScrolledWindow", "wxPyVScrolledWindow");
30203
30204     PyDict_SetItemString(d, "wxEVT_TASKBAR_MOVE", PyInt_FromLong(wxEVT_TASKBAR_MOVE));
30205     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DOWN", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DOWN));
30206     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_UP", PyInt_FromLong(wxEVT_TASKBAR_LEFT_UP));
30207     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DOWN", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DOWN));
30208     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_UP", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_UP));
30209     PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DCLICK));
30210     PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DCLICK));
30211     SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
30212     SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
30213     SWIG_addvarlink(SWIG_globals,(char*)"DirDialogNameStr",_wrap_DirDialogNameStr_get, _wrap_DirDialogNameStr_set);
30214     SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
30215     SWIG_addvarlink(SWIG_globals,(char*)"GetTextFromUserPromptStr",_wrap_GetTextFromUserPromptStr_get, _wrap_GetTextFromUserPromptStr_set);
30216     SWIG_addvarlink(SWIG_globals,(char*)"MessageBoxCaptionStr",_wrap_MessageBoxCaptionStr_get, _wrap_MessageBoxCaptionStr_set);
30217     {
30218         PyDict_SetItemString(d,"CHOICEDLG_STYLE", SWIG_From_int((int)(wxCHOICEDLG_STYLE)));
30219     }
30220     {
30221         PyDict_SetItemString(d,"TextEntryDialogStyle", SWIG_From_int((int)(wxTextEntryDialogStyle)));
30222     }
30223     SWIG_addvarlink(SWIG_globals,(char*)"GetPasswordFromUserPromptStr",_wrap_GetPasswordFromUserPromptStr_get, _wrap_GetPasswordFromUserPromptStr_set);
30224     {
30225         PyDict_SetItemString(d,"FR_DOWN", SWIG_From_int((int)(wxFR_DOWN)));
30226     }
30227     {
30228         PyDict_SetItemString(d,"FR_WHOLEWORD", SWIG_From_int((int)(wxFR_WHOLEWORD)));
30229     }
30230     {
30231         PyDict_SetItemString(d,"FR_MATCHCASE", SWIG_From_int((int)(wxFR_MATCHCASE)));
30232     }
30233     {
30234         PyDict_SetItemString(d,"FR_REPLACEDIALOG", SWIG_From_int((int)(wxFR_REPLACEDIALOG)));
30235     }
30236     {
30237         PyDict_SetItemString(d,"FR_NOUPDOWN", SWIG_From_int((int)(wxFR_NOUPDOWN)));
30238     }
30239     {
30240         PyDict_SetItemString(d,"FR_NOMATCHCASE", SWIG_From_int((int)(wxFR_NOMATCHCASE)));
30241     }
30242     {
30243         PyDict_SetItemString(d,"FR_NOWHOLEWORD", SWIG_From_int((int)(wxFR_NOWHOLEWORD)));
30244     }
30245     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND", PyInt_FromLong(wxEVT_COMMAND_FIND));
30246     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_NEXT", PyInt_FromLong(wxEVT_COMMAND_FIND_NEXT));
30247     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE));
30248     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE_ALL", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE_ALL));
30249     PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_CLOSE", PyInt_FromLong(wxEVT_COMMAND_FIND_CLOSE));
30250     {
30251         PyDict_SetItemString(d,"IDM_WINDOWTILE", SWIG_From_int((int)(4001)));
30252     }
30253     {
30254         PyDict_SetItemString(d,"IDM_WINDOWTILEHOR", SWIG_From_int((int)(4001)));
30255     }
30256     {
30257         PyDict_SetItemString(d,"IDM_WINDOWCASCADE", SWIG_From_int((int)(4002)));
30258     }
30259     {
30260         PyDict_SetItemString(d,"IDM_WINDOWICONS", SWIG_From_int((int)(4003)));
30261     }
30262     {
30263         PyDict_SetItemString(d,"IDM_WINDOWNEXT", SWIG_From_int((int)(4004)));
30264     }
30265     {
30266         PyDict_SetItemString(d,"IDM_WINDOWTILEVERT", SWIG_From_int((int)(4005)));
30267     }
30268     {
30269         PyDict_SetItemString(d,"IDM_WINDOWPREV", SWIG_From_int((int)(4006)));
30270     }
30271     {
30272         PyDict_SetItemString(d,"FIRST_MDI_CHILD", SWIG_From_int((int)(4100)));
30273     }
30274     {
30275         PyDict_SetItemString(d,"LAST_MDI_CHILD", SWIG_From_int((int)(4600)));
30276     }
30277     SWIG_addvarlink(SWIG_globals,(char*)"PrintoutTitleStr",_wrap_PrintoutTitleStr_get, _wrap_PrintoutTitleStr_set);
30278     SWIG_addvarlink(SWIG_globals,(char*)"PreviewCanvasNameStr",_wrap_PreviewCanvasNameStr_get, _wrap_PreviewCanvasNameStr_set);
30279     {
30280         PyDict_SetItemString(d,"PRINT_MODE_NONE", SWIG_From_int((int)(wxPRINT_MODE_NONE)));
30281     }
30282     {
30283         PyDict_SetItemString(d,"PRINT_MODE_PREVIEW", SWIG_From_int((int)(wxPRINT_MODE_PREVIEW)));
30284     }
30285     {
30286         PyDict_SetItemString(d,"PRINT_MODE_FILE", SWIG_From_int((int)(wxPRINT_MODE_FILE)));
30287     }
30288     {
30289         PyDict_SetItemString(d,"PRINT_MODE_PRINTER", SWIG_From_int((int)(wxPRINT_MODE_PRINTER)));
30290     }
30291     {
30292         PyDict_SetItemString(d,"PRINT_MODE_STREAM", SWIG_From_int((int)(wxPRINT_MODE_STREAM)));
30293     }
30294     {
30295         PyDict_SetItemString(d,"PRINTBIN_DEFAULT", SWIG_From_int((int)(wxPRINTBIN_DEFAULT)));
30296     }
30297     {
30298         PyDict_SetItemString(d,"PRINTBIN_ONLYONE", SWIG_From_int((int)(wxPRINTBIN_ONLYONE)));
30299     }
30300     {
30301         PyDict_SetItemString(d,"PRINTBIN_LOWER", SWIG_From_int((int)(wxPRINTBIN_LOWER)));
30302     }
30303     {
30304         PyDict_SetItemString(d,"PRINTBIN_MIDDLE", SWIG_From_int((int)(wxPRINTBIN_MIDDLE)));
30305     }
30306     {
30307         PyDict_SetItemString(d,"PRINTBIN_MANUAL", SWIG_From_int((int)(wxPRINTBIN_MANUAL)));
30308     }
30309     {
30310         PyDict_SetItemString(d,"PRINTBIN_ENVELOPE", SWIG_From_int((int)(wxPRINTBIN_ENVELOPE)));
30311     }
30312     {
30313         PyDict_SetItemString(d,"PRINTBIN_ENVMANUAL", SWIG_From_int((int)(wxPRINTBIN_ENVMANUAL)));
30314     }
30315     {
30316         PyDict_SetItemString(d,"PRINTBIN_AUTO", SWIG_From_int((int)(wxPRINTBIN_AUTO)));
30317     }
30318     {
30319         PyDict_SetItemString(d,"PRINTBIN_TRACTOR", SWIG_From_int((int)(wxPRINTBIN_TRACTOR)));
30320     }
30321     {
30322         PyDict_SetItemString(d,"PRINTBIN_SMALLFMT", SWIG_From_int((int)(wxPRINTBIN_SMALLFMT)));
30323     }
30324     {
30325         PyDict_SetItemString(d,"PRINTBIN_LARGEFMT", SWIG_From_int((int)(wxPRINTBIN_LARGEFMT)));
30326     }
30327     {
30328         PyDict_SetItemString(d,"PRINTBIN_LARGECAPACITY", SWIG_From_int((int)(wxPRINTBIN_LARGECAPACITY)));
30329     }
30330     {
30331         PyDict_SetItemString(d,"PRINTBIN_CASSETTE", SWIG_From_int((int)(wxPRINTBIN_CASSETTE)));
30332     }
30333     {
30334         PyDict_SetItemString(d,"PRINTBIN_FORMSOURCE", SWIG_From_int((int)(wxPRINTBIN_FORMSOURCE)));
30335     }
30336     {
30337         PyDict_SetItemString(d,"PRINTBIN_USER", SWIG_From_int((int)(wxPRINTBIN_USER)));
30338     }
30339     {
30340         PyDict_SetItemString(d,"PRINTER_NO_ERROR", SWIG_From_int((int)(wxPRINTER_NO_ERROR)));
30341     }
30342     {
30343         PyDict_SetItemString(d,"PRINTER_CANCELLED", SWIG_From_int((int)(wxPRINTER_CANCELLED)));
30344     }
30345     {
30346         PyDict_SetItemString(d,"PRINTER_ERROR", SWIG_From_int((int)(wxPRINTER_ERROR)));
30347     }
30348     {
30349         PyDict_SetItemString(d,"PREVIEW_PRINT", SWIG_From_int((int)(wxPREVIEW_PRINT)));
30350     }
30351     {
30352         PyDict_SetItemString(d,"PREVIEW_PREVIOUS", SWIG_From_int((int)(wxPREVIEW_PREVIOUS)));
30353     }
30354     {
30355         PyDict_SetItemString(d,"PREVIEW_NEXT", SWIG_From_int((int)(wxPREVIEW_NEXT)));
30356     }
30357     {
30358         PyDict_SetItemString(d,"PREVIEW_ZOOM", SWIG_From_int((int)(wxPREVIEW_ZOOM)));
30359     }
30360     {
30361         PyDict_SetItemString(d,"PREVIEW_FIRST", SWIG_From_int((int)(wxPREVIEW_FIRST)));
30362     }
30363     {
30364         PyDict_SetItemString(d,"PREVIEW_LAST", SWIG_From_int((int)(wxPREVIEW_LAST)));
30365     }
30366     {
30367         PyDict_SetItemString(d,"PREVIEW_GOTO", SWIG_From_int((int)(wxPREVIEW_GOTO)));
30368     }
30369     {
30370         PyDict_SetItemString(d,"PREVIEW_DEFAULT", SWIG_From_int((int)(wxPREVIEW_DEFAULT)));
30371     }
30372     {
30373         PyDict_SetItemString(d,"ID_PREVIEW_CLOSE", SWIG_From_int((int)(wxID_PREVIEW_CLOSE)));
30374     }
30375     {
30376         PyDict_SetItemString(d,"ID_PREVIEW_NEXT", SWIG_From_int((int)(wxID_PREVIEW_NEXT)));
30377     }
30378     {
30379         PyDict_SetItemString(d,"ID_PREVIEW_PREVIOUS", SWIG_From_int((int)(wxID_PREVIEW_PREVIOUS)));
30380     }
30381     {
30382         PyDict_SetItemString(d,"ID_PREVIEW_PRINT", SWIG_From_int((int)(wxID_PREVIEW_PRINT)));
30383     }
30384     {
30385         PyDict_SetItemString(d,"ID_PREVIEW_ZOOM", SWIG_From_int((int)(wxID_PREVIEW_ZOOM)));
30386     }
30387     {
30388         PyDict_SetItemString(d,"ID_PREVIEW_FIRST", SWIG_From_int((int)(wxID_PREVIEW_FIRST)));
30389     }
30390     {
30391         PyDict_SetItemString(d,"ID_PREVIEW_LAST", SWIG_From_int((int)(wxID_PREVIEW_LAST)));
30392     }
30393     {
30394         PyDict_SetItemString(d,"ID_PREVIEW_GOTO", SWIG_From_int((int)(wxID_PREVIEW_GOTO)));
30395     }
30396
30397     wxPyPtrTypeMap_Add("wxPrintout", "wxPyPrintout");
30398
30399 }
30400