~brian-sidebotham/wxwidgets-cmake/wxpython-2.9.4

« back to all changes in this revision

Viewing changes to wxPython/src/osx_cocoa/wizard_wrap.cpp

  • Committer: Brian Sidebotham
  • Date: 2013-08-03 14:30:08 UTC
  • Revision ID: brian.sidebotham@gmail.com-20130803143008-c7806tkych1tp6fc
Initial import into Bazaar

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* ----------------------------------------------------------------------------
 
2
 * This file was automatically generated by SWIG (http://www.swig.org).
 
3
 * Version 1.3.29
 
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
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
 
13
 
 
14
#ifdef __cplusplus
 
15
template<class T> class SwigValueWrapper {
 
16
    T *tt;
 
17
public:
 
18
    SwigValueWrapper() : tt(0) { }
 
19
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
 
20
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
 
21
    ~SwigValueWrapper() { delete tt; } 
 
22
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
 
23
    operator T&() const { return *tt; }
 
24
    T *operator&() { return tt; }
 
25
private:
 
26
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
 
27
};
 
28
#endif
 
29
 
 
30
/* -----------------------------------------------------------------------------
 
31
 *  This section contains generic SWIG labels for method/variable
 
32
 *  declarations/attributes, and other compiler dependent labels.
 
33
 * ----------------------------------------------------------------------------- */
 
34
 
 
35
/* template workaround for compilers that cannot correctly implement the C++ standard */
 
36
#ifndef SWIGTEMPLATEDISAMBIGUATOR
 
37
# if defined(__SUNPRO_CC)
 
38
#   if (__SUNPRO_CC <= 0x560)
 
39
#     define SWIGTEMPLATEDISAMBIGUATOR template
 
40
#   else
 
41
#     define SWIGTEMPLATEDISAMBIGUATOR 
 
42
#   endif
 
43
# else
 
44
#   define SWIGTEMPLATEDISAMBIGUATOR 
 
45
# endif
 
46
#endif
 
47
 
 
48
/* inline attribute */
 
49
#ifndef SWIGINLINE
 
50
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
 
51
#   define SWIGINLINE inline
 
52
# else
 
53
#   define SWIGINLINE
 
54
# endif
 
55
#endif
 
56
 
 
57
/* attribute recognised by some compilers to avoid 'unused' warnings */
 
58
#ifndef SWIGUNUSED
 
59
# if defined(__GNUC__)
 
60
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
 
61
#     define SWIGUNUSED __attribute__ ((__unused__)) 
 
62
#   else
 
63
#     define SWIGUNUSED
 
64
#   endif
 
65
# elif defined(__ICC)
 
66
#   define SWIGUNUSED __attribute__ ((__unused__)) 
 
67
# else
 
68
#   define SWIGUNUSED 
 
69
# endif
 
70
#endif
 
71
 
 
72
#ifndef SWIGUNUSEDPARM
 
73
# ifdef __cplusplus
 
74
#   define SWIGUNUSEDPARM(p)
 
75
# else
 
76
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
 
77
# endif
 
78
#endif
 
79
 
 
80
/* internal SWIG method */
 
81
#ifndef SWIGINTERN
 
82
# define SWIGINTERN static SWIGUNUSED
 
83
#endif
 
84
 
 
85
/* internal inline SWIG method */
 
86
#ifndef SWIGINTERNINLINE
 
87
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 
88
#endif
 
89
 
 
90
/* exporting methods */
 
91
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 
92
#  ifndef GCC_HASCLASSVISIBILITY
 
93
#    define GCC_HASCLASSVISIBILITY
 
94
#  endif
 
95
#endif
 
96
 
 
97
#ifndef SWIGEXPORT
 
98
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 
99
#   if defined(STATIC_LINKED)
 
100
#     define SWIGEXPORT
 
101
#   else
 
102
#     define SWIGEXPORT __declspec(dllexport)
 
103
#   endif
 
104
# else
 
105
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 
106
#     define SWIGEXPORT __attribute__ ((visibility("default")))
 
107
#   else
 
108
#     define SWIGEXPORT
 
109
#   endif
 
110
# endif
 
111
#endif
 
112
 
 
113
/* calling conventions for Windows */
 
114
#ifndef SWIGSTDCALL
 
115
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 
116
#   define SWIGSTDCALL __stdcall
 
117
# else
 
118
#   define SWIGSTDCALL
 
119
# endif 
 
120
#endif
 
121
 
 
122
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 
123
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
 
124
# define _CRT_SECURE_NO_DEPRECATE
 
125
#endif
 
126
 
 
127
 
 
128
/* Python.h has to appear first */
 
129
#include <Python.h>
 
130
 
 
131
/* -----------------------------------------------------------------------------
 
132
 * swigrun.swg
 
133
 *
 
134
 * This file contains generic CAPI SWIG runtime support for pointer
 
135
 * type checking.
 
136
 * ----------------------------------------------------------------------------- */
 
137
 
 
138
/* This should only be incremented when either the layout of swig_type_info changes,
 
139
   or for whatever reason, the runtime changes incompatibly */
 
140
#define SWIG_RUNTIME_VERSION "2"
 
141
 
 
142
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 
143
#ifdef SWIG_TYPE_TABLE
 
144
# define SWIG_QUOTE_STRING(x) #x
 
145
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 
146
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 
147
#else
 
148
# define SWIG_TYPE_TABLE_NAME
 
149
#endif
 
150
 
 
151
/*
 
152
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 
153
  creating a static or dynamic library from the swig runtime code.
 
154
  In 99.9% of the cases, swig just needs to declare them as 'static'.
 
155
  
 
156
  But only do this if is strictly necessary, ie, if you have problems
 
157
  with your compiler or so.
 
158
*/
 
159
 
 
160
#ifndef SWIGRUNTIME
 
161
# define SWIGRUNTIME SWIGINTERN
 
162
#endif
 
163
 
 
164
#ifndef SWIGRUNTIMEINLINE
 
165
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 
166
#endif
 
167
 
 
168
/*  Generic buffer size */
 
169
#ifndef SWIG_BUFFER_SIZE
 
170
# define SWIG_BUFFER_SIZE 1024
 
171
#endif
 
172
 
 
173
/* Flags for pointer conversions */
 
174
#define SWIG_POINTER_DISOWN        0x1
 
175
 
 
176
/* Flags for new pointer objects */
 
177
#define SWIG_POINTER_OWN           0x1
 
178
 
 
179
 
 
180
/* 
 
181
   Flags/methods for returning states.
 
182
   
 
183
   The swig conversion methods, as ConvertPtr, return and integer 
 
184
   that tells if the conversion was successful or not. And if not,
 
185
   an error code can be returned (see swigerrors.swg for the codes).
 
186
   
 
187
   Use the following macros/flags to set or process the returning
 
188
   states.
 
189
   
 
190
   In old swig versions, you usually write code as:
 
191
 
 
192
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 
193
       // success code
 
194
     } else {
 
195
       //fail code
 
196
     }
 
197
 
 
198
   Now you can be more explicit as:
 
199
 
 
200
    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 
201
    if (SWIG_IsOK(res)) {
 
202
      // success code
 
203
    } else {
 
204
      // fail code
 
205
    }
 
206
 
 
207
   that seems to be the same, but now you can also do
 
208
 
 
209
    Type *ptr;
 
210
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 
211
    if (SWIG_IsOK(res)) {
 
212
      // success code
 
213
      if (SWIG_IsNewObj(res) {
 
214
        ...
 
215
        delete *ptr;
 
216
      } else {
 
217
        ...
 
218
      }
 
219
    } else {
 
220
      // fail code
 
221
    }
 
222
    
 
223
   I.e., now SWIG_ConvertPtr can return new objects and you can
 
224
   identify the case and take care of the deallocation. Of course that
 
225
   requires also to SWIG_ConvertPtr to return new result values, as
 
226
 
 
227
      int SWIG_ConvertPtr(obj, ptr,...) {         
 
228
        if (<obj is ok>) {                             
 
229
          if (<need new object>) {                     
 
230
            *ptr = <ptr to new allocated object>; 
 
231
            return SWIG_NEWOBJ;                
 
232
          } else {                                     
 
233
            *ptr = <ptr to old object>;        
 
234
            return SWIG_OLDOBJ;                
 
235
          }                                    
 
236
        } else {                                       
 
237
          return SWIG_BADOBJ;                  
 
238
        }                                              
 
239
      }
 
240
 
 
241
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 
242
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 
243
   swig errors code.
 
244
 
 
245
   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 
246
   allows to return the 'cast rank', for example, if you have this
 
247
 
 
248
       int food(double)
 
249
       int fooi(int);
 
250
 
 
251
   and you call
 
252
 
 
253
      food(1)   // cast rank '1'  (1 -> 1.0)
 
254
      fooi(1)   // cast rank '0'
 
255
 
 
256
   just use the SWIG_AddCast()/SWIG_CheckState()
 
257
 
 
258
 
 
259
 */
 
260
#define SWIG_OK                    (0) 
 
261
#define SWIG_ERROR                 (-1)
 
262
#define SWIG_IsOK(r)               (r >= 0)
 
263
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
 
264
 
 
265
/* The CastRankLimit says how many bits are used for the cast rank */
 
266
#define SWIG_CASTRANKLIMIT         (1 << 8)
 
267
/* The NewMask denotes the object was created (using new/malloc) */
 
268
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 
269
/* The TmpMask is for in/out typemaps that use temporal objects */
 
270
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 
271
/* Simple returning values */
 
272
#define SWIG_BADOBJ                (SWIG_ERROR)
 
273
#define SWIG_OLDOBJ                (SWIG_OK)
 
274
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 
275
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 
276
/* Check, add and del mask methods */
 
277
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 
278
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 
279
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 
280
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 
281
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 
282
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 
283
 
 
284
 
 
285
/* Cast-Rank Mode */
 
286
#if defined(SWIG_CASTRANK_MODE)
 
287
#  ifndef SWIG_TypeRank
 
288
#    define SWIG_TypeRank             unsigned long
 
289
#  endif
 
290
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 
291
#    define SWIG_MAXCASTRANK          (2)
 
292
#  endif
 
293
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 
294
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 
295
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
 
296
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 
297
}
 
298
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
 
299
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
 
300
}
 
301
#else /* no cast-rank mode */
 
302
#  define SWIG_AddCast
 
303
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 
304
#endif
 
305
 
 
306
 
 
307
 
 
308
 
 
309
#include <string.h>
 
310
 
 
311
#ifdef __cplusplus
 
312
extern "C" {
 
313
#endif
 
314
 
 
315
typedef void *(*swig_converter_func)(void *);
 
316
typedef struct swig_type_info *(*swig_dycast_func)(void **);
 
317
 
 
318
/* Structure to store inforomation on one type */
 
319
typedef struct swig_type_info {
 
320
  const char             *name;                 /* mangled name of this type */
 
321
  const char             *str;                  /* human readable name of this type */
 
322
  swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 
323
  struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 
324
  void                   *clientdata;           /* language specific type data */
 
325
  int                    owndata;               /* flag if the structure owns the clientdata */
 
326
} swig_type_info;
 
327
 
 
328
/* Structure to store a type and conversion function used for casting */
 
329
typedef struct swig_cast_info {
 
330
  swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 
331
  swig_converter_func     converter;            /* function to cast the void pointers */
 
332
  struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 
333
  struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 
334
} swig_cast_info;
 
335
 
 
336
/* Structure used to store module information
 
337
 * Each module generates one structure like this, and the runtime collects
 
338
 * all of these structures and stores them in a circularly linked list.*/
 
339
typedef struct swig_module_info {
 
340
  swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 
341
  size_t                 size;                  /* Number of types in this module */
 
342
  struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 
343
  swig_type_info         **type_initial;        /* Array of initially generated type structures */
 
344
  swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 
345
  void                    *clientdata;          /* Language specific module data */
 
346
} swig_module_info;
 
347
 
 
348
/* 
 
349
  Compare two type names skipping the space characters, therefore
 
350
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 
351
 
 
352
  Return 0 when the two name types are equivalent, as in
 
353
  strncmp, but skipping ' '.
 
354
*/
 
355
SWIGRUNTIME int
 
356
SWIG_TypeNameComp(const char *f1, const char *l1,
 
357
                  const char *f2, const char *l2) {
 
358
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 
359
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
 
360
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
 
361
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 
362
  }
 
363
  return (l1 - f1) - (l2 - f2);
 
364
}
 
365
 
 
366
/*
 
367
  Check type equivalence in a name list like <name1>|<name2>|...
 
368
  Return 0 if not equal, 1 if equal
 
369
*/
 
370
SWIGRUNTIME int
 
371
SWIG_TypeEquiv(const char *nb, const char *tb) {
 
372
  int equiv = 0;
 
373
  const char* te = tb + strlen(tb);
 
374
  const char* ne = nb;
 
375
  while (!equiv && *ne) {
 
376
    for (nb = ne; *ne; ++ne) {
 
377
      if (*ne == '|') break;
 
378
    }
 
379
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 
380
    if (*ne) ++ne;
 
381
  }
 
382
  return equiv;
 
383
}
 
384
 
 
385
/*
 
386
  Check type equivalence in a name list like <name1>|<name2>|...
 
387
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 
388
*/
 
389
SWIGRUNTIME int
 
390
SWIG_TypeCompare(const char *nb, const char *tb) {
 
391
  int equiv = 0;
 
392
  const char* te = tb + strlen(tb);
 
393
  const char* ne = nb;
 
394
  while (!equiv && *ne) {
 
395
    for (nb = ne; *ne; ++ne) {
 
396
      if (*ne == '|') break;
 
397
    }
 
398
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 
399
    if (*ne) ++ne;
 
400
  }
 
401
  return equiv;
 
402
}
 
403
 
 
404
 
 
405
/* think of this as a c++ template<> or a scheme macro */
 
406
#define SWIG_TypeCheck_Template(comparison, ty)         \
 
407
  if (ty) {                                             \
 
408
    swig_cast_info *iter = ty->cast;                    \
 
409
    while (iter) {                                      \
 
410
      if (comparison) {                                 \
 
411
        if (iter == ty->cast) return iter;              \
 
412
        /* Move iter to the top of the linked list */   \
 
413
        iter->prev->next = iter->next;                  \
 
414
        if (iter->next)                                 \
 
415
          iter->next->prev = iter->prev;                \
 
416
        iter->next = ty->cast;                          \
 
417
        iter->prev = 0;                                 \
 
418
        if (ty->cast) ty->cast->prev = iter;            \
 
419
        ty->cast = iter;                                \
 
420
        return iter;                                    \
 
421
      }                                                 \
 
422
      iter = iter->next;                                \
 
423
    }                                                   \
 
424
  }                                                     \
 
425
  return 0
 
426
 
 
427
/*
 
428
  Check the typename
 
429
*/
 
430
SWIGRUNTIME swig_cast_info *
 
431
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 
432
  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 
433
}
 
434
 
 
435
/* Same as previous function, except strcmp is replaced with a pointer comparison */
 
436
SWIGRUNTIME swig_cast_info *
 
437
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
 
438
  SWIG_TypeCheck_Template(iter->type == from, into);
 
439
}
 
440
 
 
441
/*
 
442
  Cast a pointer up an inheritance hierarchy
 
443
*/
 
444
SWIGRUNTIMEINLINE void *
 
445
SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
 
446
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
 
447
}
 
448
 
 
449
/* 
 
450
   Dynamic pointer casting. Down an inheritance hierarchy
 
451
*/
 
452
SWIGRUNTIME swig_type_info *
 
453
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 
454
  swig_type_info *lastty = ty;
 
455
  if (!ty || !ty->dcast) return ty;
 
456
  while (ty && (ty->dcast)) {
 
457
    ty = (*ty->dcast)(ptr);
 
458
    if (ty) lastty = ty;
 
459
  }
 
460
  return lastty;
 
461
}
 
462
 
 
463
/*
 
464
  Return the name associated with this type
 
465
*/
 
466
SWIGRUNTIMEINLINE const char *
 
467
SWIG_TypeName(const swig_type_info *ty) {
 
468
  return ty->name;
 
469
}
 
470
 
 
471
/*
 
472
  Return the pretty name associated with this type,
 
473
  that is an unmangled type name in a form presentable to the user.
 
474
*/
 
475
SWIGRUNTIME const char *
 
476
SWIG_TypePrettyName(const swig_type_info *type) {
 
477
  /* The "str" field contains the equivalent pretty names of the
 
478
     type, separated by vertical-bar characters.  We choose
 
479
     to print the last name, as it is often (?) the most
 
480
     specific. */
 
481
  if (!type) return NULL;
 
482
  if (type->str != NULL) {
 
483
    const char *last_name = type->str;
 
484
    const char *s;
 
485
    for (s = type->str; *s; s++)
 
486
      if (*s == '|') last_name = s+1;
 
487
    return last_name;
 
488
  }
 
489
  else
 
490
    return type->name;
 
491
}
 
492
 
 
493
/* 
 
494
   Set the clientdata field for a type
 
495
*/
 
496
SWIGRUNTIME void
 
497
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 
498
  swig_cast_info *cast = ti->cast;
 
499
  /* if (ti->clientdata == clientdata) return; */
 
500
  ti->clientdata = clientdata;
 
501
  
 
502
  while (cast) {
 
503
    if (!cast->converter) {
 
504
      swig_type_info *tc = cast->type;
 
505
      if (!tc->clientdata) {
 
506
        SWIG_TypeClientData(tc, clientdata);
 
507
      }
 
508
    }    
 
509
    cast = cast->next;
 
510
  }
 
511
}
 
512
SWIGRUNTIME void
 
513
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 
514
  SWIG_TypeClientData(ti, clientdata);
 
515
  ti->owndata = 1;
 
516
}
 
517
  
 
518
/*
 
519
  Search for a swig_type_info structure only by mangled name
 
520
  Search is a O(log #types)
 
521
  
 
522
  We start searching at module start, and finish searching when start == end.  
 
523
  Note: if start == end at the beginning of the function, we go all the way around
 
524
  the circular list.
 
525
*/
 
526
SWIGRUNTIME swig_type_info *
 
527
SWIG_MangledTypeQueryModule(swig_module_info *start, 
 
528
                            swig_module_info *end, 
 
529
                            const char *name) {
 
530
  swig_module_info *iter = start;
 
531
  do {
 
532
    if (iter->size) {
 
533
      register size_t l = 0;
 
534
      register size_t r = iter->size - 1;
 
535
      do {
 
536
        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 
537
        register size_t i = (l + r) >> 1; 
 
538
        const char *iname = iter->types[i]->name;
 
539
        if (iname) {
 
540
          register int compare = strcmp(name, iname);
 
541
          if (compare == 0) {       
 
542
            return iter->types[i];
 
543
          } else if (compare < 0) {
 
544
            if (i) {
 
545
              r = i - 1;
 
546
            } else {
 
547
              break;
 
548
            }
 
549
          } else if (compare > 0) {
 
550
            l = i + 1;
 
551
          }
 
552
        } else {
 
553
          break; /* should never happen */
 
554
        }
 
555
      } while (l <= r);
 
556
    }
 
557
    iter = iter->next;
 
558
  } while (iter != end);
 
559
  return 0;
 
560
}
 
561
 
 
562
/*
 
563
  Search for a swig_type_info structure for either a mangled name or a human readable name.
 
564
  It first searches the mangled names of the types, which is a O(log #types)
 
565
  If a type is not found it then searches the human readable names, which is O(#types).
 
566
  
 
567
  We start searching at module start, and finish searching when start == end.  
 
568
  Note: if start == end at the beginning of the function, we go all the way around
 
569
  the circular list.
 
570
*/
 
571
SWIGRUNTIME swig_type_info *
 
572
SWIG_TypeQueryModule(swig_module_info *start, 
 
573
                     swig_module_info *end, 
 
574
                     const char *name) {
 
575
  /* STEP 1: Search the name field using binary search */
 
576
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 
577
  if (ret) {
 
578
    return ret;
 
579
  } else {
 
580
    /* STEP 2: If the type hasn't been found, do a complete search
 
581
       of the str field (the human readable name) */
 
582
    swig_module_info *iter = start;
 
583
    do {
 
584
      register size_t i = 0;
 
585
      for (; i < iter->size; ++i) {
 
586
        if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 
587
          return iter->types[i];
 
588
      }
 
589
      iter = iter->next;
 
590
    } while (iter != end);
 
591
  }
 
592
  
 
593
  /* neither found a match */
 
594
  return 0;
 
595
}
 
596
 
 
597
/* 
 
598
   Pack binary data into a string
 
599
*/
 
600
SWIGRUNTIME char *
 
601
SWIG_PackData(char *c, void *ptr, size_t sz) {
 
602
  static const char hex[17] = "0123456789abcdef";
 
603
  register const unsigned char *u = (unsigned char *) ptr;
 
604
  register const unsigned char *eu =  u + sz;
 
605
  for (; u != eu; ++u) {
 
606
    register unsigned char uu = *u;
 
607
    *(c++) = hex[(uu & 0xf0) >> 4];
 
608
    *(c++) = hex[uu & 0xf];
 
609
  }
 
610
  return c;
 
611
}
 
612
 
 
613
/* 
 
614
   Unpack binary data from a string
 
615
*/
 
616
SWIGRUNTIME const char *
 
617
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 
618
  register unsigned char *u = (unsigned char *) ptr;
 
619
  register const unsigned char *eu = u + sz;
 
620
  for (; u != eu; ++u) {
 
621
    register char d = *(c++);
 
622
    register unsigned char uu;
 
623
    if ((d >= '0') && (d <= '9'))
 
624
      uu = ((d - '0') << 4);
 
625
    else if ((d >= 'a') && (d <= 'f'))
 
626
      uu = ((d - ('a'-10)) << 4);
 
627
    else 
 
628
      return (char *) 0;
 
629
    d = *(c++);
 
630
    if ((d >= '0') && (d <= '9'))
 
631
      uu |= (d - '0');
 
632
    else if ((d >= 'a') && (d <= 'f'))
 
633
      uu |= (d - ('a'-10));
 
634
    else 
 
635
      return (char *) 0;
 
636
    *u = uu;
 
637
  }
 
638
  return c;
 
639
}
 
640
 
 
641
/* 
 
642
   Pack 'void *' into a string buffer.
 
643
*/
 
644
SWIGRUNTIME char *
 
645
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 
646
  char *r = buff;
 
647
  if ((2*sizeof(void *) + 2) > bsz) return 0;
 
648
  *(r++) = '_';
 
649
  r = SWIG_PackData(r,&ptr,sizeof(void *));
 
650
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 
651
  strcpy(r,name);
 
652
  return buff;
 
653
}
 
654
 
 
655
SWIGRUNTIME const char *
 
656
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 
657
  if (*c != '_') {
 
658
    if (strcmp(c,"NULL") == 0) {
 
659
      *ptr = (void *) 0;
 
660
      return name;
 
661
    } else {
 
662
      return 0;
 
663
    }
 
664
  }
 
665
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
 
666
}
 
667
 
 
668
SWIGRUNTIME char *
 
669
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 
670
  char *r = buff;
 
671
  size_t lname = (name ? strlen(name) : 0);
 
672
  if ((2*sz + 2 + lname) > bsz) return 0;
 
673
  *(r++) = '_';
 
674
  r = SWIG_PackData(r,ptr,sz);
 
675
  if (lname) {
 
676
    strncpy(r,name,lname+1);
 
677
  } else {
 
678
    *r = 0;
 
679
  }
 
680
  return buff;
 
681
}
 
682
 
 
683
SWIGRUNTIME const char *
 
684
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 
685
  if (*c != '_') {
 
686
    if (strcmp(c,"NULL") == 0) {
 
687
      memset(ptr,0,sz);
 
688
      return name;
 
689
    } else {
 
690
      return 0;
 
691
    }
 
692
  }
 
693
  return SWIG_UnpackData(++c,ptr,sz);
 
694
}
 
695
 
 
696
#ifdef __cplusplus
 
697
}
 
698
#endif
 
699
 
 
700
/*  Errors in SWIG */
 
701
#define  SWIG_UnknownError         -1 
 
702
#define  SWIG_IOError              -2 
 
703
#define  SWIG_RuntimeError         -3 
 
704
#define  SWIG_IndexError           -4 
 
705
#define  SWIG_TypeError            -5 
 
706
#define  SWIG_DivisionByZero       -6 
 
707
#define  SWIG_OverflowError        -7 
 
708
#define  SWIG_SyntaxError          -8 
 
709
#define  SWIG_ValueError           -9 
 
710
#define  SWIG_SystemError          -10
 
711
#define  SWIG_AttributeError       -11
 
712
#define  SWIG_MemoryError          -12 
 
713
#define  SWIG_NullReferenceError   -13
 
714
 
 
715
 
 
716
 
 
717
/* Python.h has to appear first */
 
718
#include <Python.h>
 
719
 
 
720
/* Add PyOS_snprintf for old Pythons */
 
721
#if PY_VERSION_HEX < 0x02020000
 
722
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
 
723
#  define PyOS_snprintf _snprintf
 
724
# else
 
725
#  define PyOS_snprintf snprintf
 
726
# endif
 
727
#endif
 
728
 
 
729
/* A crude PyString_FromFormat implementation for old Pythons */
 
730
#if PY_VERSION_HEX < 0x02020000
 
731
 
 
732
#ifndef SWIG_PYBUFFER_SIZE
 
733
# define SWIG_PYBUFFER_SIZE 1024
 
734
#endif
 
735
 
 
736
static PyObject *
 
737
PyString_FromFormat(const char *fmt, ...) {
 
738
  va_list ap;
 
739
  char buf[SWIG_PYBUFFER_SIZE * 2];
 
740
  int res;
 
741
  va_start(ap, fmt);
 
742
  res = vsnprintf(buf, sizeof(buf), fmt, ap);
 
743
  va_end(ap);
 
744
  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
 
745
}
 
746
#endif
 
747
 
 
748
/* Add PyObject_Del for old Pythons */
 
749
#if PY_VERSION_HEX < 0x01060000
 
750
# define PyObject_Del(op) PyMem_DEL((op))
 
751
#endif
 
752
#ifndef PyObject_DEL
 
753
# define PyObject_DEL PyObject_Del
 
754
#endif
 
755
 
 
756
/* A crude PyExc_StopIteration exception for old Pythons */
 
757
#if PY_VERSION_HEX < 0x02020000
 
758
# ifndef PyExc_StopIteration
 
759
#  define PyExc_StopIteration PyExc_RuntimeError
 
760
# endif
 
761
# ifndef PyObject_GenericGetAttr
 
762
#  define PyObject_GenericGetAttr 0
 
763
# endif
 
764
#endif
 
765
/* Py_NotImplemented is defined in 2.1 and up. */
 
766
#if PY_VERSION_HEX < 0x02010000
 
767
# ifndef Py_NotImplemented
 
768
#  define Py_NotImplemented PyExc_RuntimeError
 
769
# endif
 
770
#endif
 
771
 
 
772
 
 
773
/* A crude PyString_AsStringAndSize implementation for old Pythons */
 
774
#if PY_VERSION_HEX < 0x02010000
 
775
# ifndef PyString_AsStringAndSize
 
776
#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
 
777
# endif
 
778
#endif
 
779
 
 
780
/* PySequence_Size for old Pythons */
 
781
#if PY_VERSION_HEX < 0x02000000
 
782
# ifndef PySequence_Size
 
783
#  define PySequence_Size PySequence_Length
 
784
# endif
 
785
#endif
 
786
 
 
787
 
 
788
/* PyBool_FromLong for old Pythons */
 
789
#if PY_VERSION_HEX < 0x02030000
 
790
static
 
791
PyObject *PyBool_FromLong(long ok)
 
792
{
 
793
  PyObject *result = ok ? Py_True : Py_False;
 
794
  Py_INCREF(result);
 
795
  return result;
 
796
}
 
797
#endif
 
798
 
 
799
 
 
800
/* -----------------------------------------------------------------------------
 
801
 * error manipulation
 
802
 * ----------------------------------------------------------------------------- */
 
803
 
 
804
SWIGRUNTIME PyObject*
 
805
SWIG_Python_ErrorType(int code) {
 
806
  PyObject* type = 0;
 
807
  switch(code) {
 
808
  case SWIG_MemoryError:
 
809
    type = PyExc_MemoryError;
 
810
    break;
 
811
  case SWIG_IOError:
 
812
    type = PyExc_IOError;
 
813
    break;
 
814
  case SWIG_RuntimeError:
 
815
    type = PyExc_RuntimeError;
 
816
    break;
 
817
  case SWIG_IndexError:
 
818
    type = PyExc_IndexError;
 
819
    break;
 
820
  case SWIG_TypeError:
 
821
    type = PyExc_TypeError;
 
822
    break;
 
823
  case SWIG_DivisionByZero:
 
824
    type = PyExc_ZeroDivisionError;
 
825
    break;
 
826
  case SWIG_OverflowError:
 
827
    type = PyExc_OverflowError;
 
828
    break;
 
829
  case SWIG_SyntaxError:
 
830
    type = PyExc_SyntaxError;
 
831
    break;
 
832
  case SWIG_ValueError:
 
833
    type = PyExc_ValueError;
 
834
    break;
 
835
  case SWIG_SystemError:
 
836
    type = PyExc_SystemError;
 
837
    break;
 
838
  case SWIG_AttributeError:
 
839
    type = PyExc_AttributeError;
 
840
    break;
 
841
  default:
 
842
    type = PyExc_RuntimeError;
 
843
  }
 
844
  return type;
 
845
}
 
846
 
 
847
 
 
848
SWIGRUNTIME void
 
849
SWIG_Python_AddErrorMsg(const char* mesg)
 
850
{
 
851
  PyObject *type = 0;
 
852
  PyObject *value = 0;
 
853
  PyObject *traceback = 0;
 
854
 
 
855
  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
 
856
  if (value) {
 
857
    PyObject *old_str = PyObject_Str(value);
 
858
    PyErr_Clear();
 
859
    Py_XINCREF(type);
 
860
    PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
 
861
    Py_DECREF(old_str);
 
862
    Py_DECREF(value);
 
863
  } else {
 
864
    PyErr_Format(PyExc_RuntimeError, mesg);
 
865
  }
 
866
}
 
867
 
 
868
 
 
869
 
 
870
#if defined(SWIG_PYTHON_NO_THREADS)
 
871
#  if defined(SWIG_PYTHON_THREADS)
 
872
#    undef SWIG_PYTHON_THREADS
 
873
#  endif
 
874
#endif
 
875
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
 
876
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
 
877
#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
 
878
#      define SWIG_PYTHON_USE_GIL
 
879
#    endif
 
880
#  endif
 
881
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
 
882
#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
 
883
#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
 
884
#    endif
 
885
#    ifdef __cplusplus /* C++ code */
 
886
       class SWIG_Python_Thread_Block {
 
887
         bool status;
 
888
         PyGILState_STATE state;
 
889
       public:
 
890
         void end() { if (status) { PyGILState_Release(state); status = false;} }
 
891
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
 
892
         ~SWIG_Python_Thread_Block() { end(); }
 
893
       };
 
894
       class SWIG_Python_Thread_Allow {
 
895
         bool status;
 
896
         PyThreadState *save;
 
897
       public:
 
898
         void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
 
899
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
 
900
         ~SWIG_Python_Thread_Allow() { end(); }
 
901
       };
 
902
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
 
903
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
 
904
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
 
905
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
 
906
#    else /* C code */
 
907
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
 
908
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
 
909
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
 
910
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
 
911
#    endif
 
912
#  else /* Old thread way, not implemented, user must provide it */
 
913
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
 
914
#      define SWIG_PYTHON_INITIALIZE_THREADS
 
915
#    endif
 
916
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
 
917
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 
918
#    endif
 
919
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
 
920
#      define SWIG_PYTHON_THREAD_END_BLOCK
 
921
#    endif
 
922
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
 
923
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 
924
#    endif
 
925
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
 
926
#      define SWIG_PYTHON_THREAD_END_ALLOW
 
927
#    endif
 
928
#  endif
 
929
#else /* No thread support */
 
930
#  define SWIG_PYTHON_INITIALIZE_THREADS
 
931
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 
932
#  define SWIG_PYTHON_THREAD_END_BLOCK
 
933
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 
934
#  define SWIG_PYTHON_THREAD_END_ALLOW
 
935
#endif
 
936
 
 
937
/* -----------------------------------------------------------------------------
 
938
 * Python API portion that goes into the runtime
 
939
 * ----------------------------------------------------------------------------- */
 
940
 
 
941
#ifdef __cplusplus
 
942
extern "C" {
 
943
#if 0
 
944
} /* cc-mode */
 
945
#endif
 
946
#endif
 
947
 
 
948
/* -----------------------------------------------------------------------------
 
949
 * Constant declarations
 
950
 * ----------------------------------------------------------------------------- */
 
951
 
 
952
/* Constant Types */
 
953
#define SWIG_PY_POINTER 4
 
954
#define SWIG_PY_BINARY  5
 
955
 
 
956
/* Constant information structure */
 
957
typedef struct swig_const_info {
 
958
  int type;
 
959
  char *name;
 
960
  long lvalue;
 
961
  double dvalue;
 
962
  void   *pvalue;
 
963
  swig_type_info **ptype;
 
964
} swig_const_info;
 
965
 
 
966
#ifdef __cplusplus
 
967
#if 0
 
968
{ /* cc-mode */
 
969
#endif
 
970
}
 
971
#endif
 
972
 
 
973
 
 
974
/* -----------------------------------------------------------------------------
 
975
 * See the LICENSE file for information on copyright, usage and redistribution
 
976
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 
977
 *
 
978
 * pyrun.swg
 
979
 *
 
980
 * This file contains the runtime support for Python modules
 
981
 * and includes code for managing global variables and pointer
 
982
 * type checking.
 
983
 *
 
984
 * ----------------------------------------------------------------------------- */
 
985
 
 
986
/* Common SWIG API */
 
987
 
 
988
#if PY_VERSION_HEX < 0x02050000
 
989
typedef int Py_ssize_t;
 
990
#endif
 
991
 
 
992
/* for raw pointers */
 
993
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
 
994
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
 
995
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
 
996
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
 
997
#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
 
998
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
 
999
#define swig_owntype                                    int
 
1000
 
 
1001
/* for raw packed data */
 
1002
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
 
1003
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
 
1004
 
 
1005
/* for class or struct pointers */
 
1006
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
 
1007
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
 
1008
 
 
1009
/* for C or C++ function pointers */
 
1010
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
 
1011
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
 
1012
 
 
1013
/* for C++ member pointers, ie, member methods */
 
1014
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
 
1015
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
 
1016
 
 
1017
 
 
1018
/* Runtime API */
 
1019
 
 
1020
#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
 
1021
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
 
1022
#define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
 
1023
 
 
1024
#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
 
1025
#define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg                            
 
1026
#define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)                        
 
1027
#define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
 
1028
#define SWIG_fail                                       goto fail                                          
 
1029
 
 
1030
 
 
1031
/* Runtime API implementation */
 
1032
 
 
1033
/* Error manipulation */
 
1034
 
 
1035
SWIGINTERN void 
 
1036
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
 
1037
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
 
1038
  PyErr_SetObject(errtype, obj);
 
1039
  Py_DECREF(obj);
 
1040
  SWIG_PYTHON_THREAD_END_BLOCK;
 
1041
}
 
1042
 
 
1043
SWIGINTERN void 
 
1044
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
 
1045
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
 
1046
  PyErr_SetString(errtype, (char *) msg);
 
1047
  SWIG_PYTHON_THREAD_END_BLOCK;
 
1048
}
 
1049
 
 
1050
#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
 
1051
 
 
1052
/* Set a constant value */
 
1053
 
 
1054
SWIGINTERN void
 
1055
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
 
1056
  PyDict_SetItemString(d, (char*) name, obj);
 
1057
  Py_DECREF(obj);                            
 
1058
}
 
1059
 
 
1060
/* Append a value to the result obj */
 
1061
 
 
1062
SWIGINTERN PyObject*
 
1063
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
 
1064
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
 
1065
  if (!result) {
 
1066
    result = obj;
 
1067
  } else if (result == Py_None) {
 
1068
    Py_DECREF(result);
 
1069
    result = obj;
 
1070
  } else {
 
1071
    if (!PyList_Check(result)) {
 
1072
      PyObject *o2 = result;
 
1073
      result = PyList_New(1);
 
1074
      PyList_SetItem(result, 0, o2);
 
1075
    }
 
1076
    PyList_Append(result,obj);
 
1077
    Py_DECREF(obj);
 
1078
  }
 
1079
  return result;
 
1080
#else
 
1081
  PyObject*   o2;
 
1082
  PyObject*   o3;
 
1083
  if (!result) {
 
1084
    result = obj;
 
1085
  } else if (result == Py_None) {
 
1086
    Py_DECREF(result);
 
1087
    result = obj;
 
1088
  } else {
 
1089
    if (!PyTuple_Check(result)) {
 
1090
      o2 = result;
 
1091
      result = PyTuple_New(1);
 
1092
      PyTuple_SET_ITEM(result, 0, o2);
 
1093
    }
 
1094
    o3 = PyTuple_New(1);
 
1095
    PyTuple_SET_ITEM(o3, 0, obj);
 
1096
    o2 = result;
 
1097
    result = PySequence_Concat(o2, o3);
 
1098
    Py_DECREF(o2);
 
1099
    Py_DECREF(o3);
 
1100
  }
 
1101
  return result;
 
1102
#endif
 
1103
}
 
1104
 
 
1105
/* Unpack the argument tuple */
 
1106
 
 
1107
SWIGINTERN int
 
1108
SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
 
1109
{
 
1110
  if (!args) {
 
1111
    if (!min && !max) {
 
1112
      return 1;
 
1113
    } else {
 
1114
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
 
1115
                   name, (min == max ? "" : "at least "), min);
 
1116
      return 0;
 
1117
    }
 
1118
  }  
 
1119
  if (!PyTuple_Check(args)) {
 
1120
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
 
1121
    return 0;
 
1122
  } else {
 
1123
    register int l = PyTuple_GET_SIZE(args);
 
1124
    if (l < min) {
 
1125
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
 
1126
                   name, (min == max ? "" : "at least "), min, l);
 
1127
      return 0;
 
1128
    } else if (l > max) {
 
1129
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
 
1130
                   name, (min == max ? "" : "at most "), max, l);
 
1131
      return 0;
 
1132
    } else {
 
1133
      register int i;
 
1134
      for (i = 0; i < l; ++i) {
 
1135
        objs[i] = PyTuple_GET_ITEM(args, i);
 
1136
      }
 
1137
      for (; l < max; ++l) {
 
1138
        objs[l] = 0;
 
1139
      }
 
1140
      return i + 1;
 
1141
    }    
 
1142
  }
 
1143
}
 
1144
 
 
1145
/* A functor is a function object with one single object argument */
 
1146
#if PY_VERSION_HEX >= 0x02020000
 
1147
#define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
 
1148
#else
 
1149
#define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
 
1150
#endif
 
1151
 
 
1152
/*
 
1153
  Helper for static pointer initialization for both C and C++ code, for example
 
1154
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
 
1155
*/
 
1156
#ifdef __cplusplus
 
1157
#define SWIG_STATIC_POINTER(var)  var
 
1158
#else
 
1159
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
 
1160
#endif
 
1161
 
 
1162
/* -----------------------------------------------------------------------------
 
1163
 * Pointer declarations
 
1164
 * ----------------------------------------------------------------------------- */
 
1165
 
 
1166
/* Flags for new pointer objects */
 
1167
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
 
1168
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
 
1169
 
 
1170
#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
 
1171
 
 
1172
#ifdef __cplusplus
 
1173
extern "C" {
 
1174
#if 0
 
1175
} /* cc-mode */
 
1176
#endif
 
1177
#endif
 
1178
 
 
1179
/*  How to access Py_None */
 
1180
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 
1181
#  ifndef SWIG_PYTHON_NO_BUILD_NONE
 
1182
#    ifndef SWIG_PYTHON_BUILD_NONE
 
1183
#      define SWIG_PYTHON_BUILD_NONE
 
1184
#    endif
 
1185
#  endif
 
1186
#endif
 
1187
 
 
1188
#ifdef SWIG_PYTHON_BUILD_NONE
 
1189
#  ifdef Py_None
 
1190
#   undef Py_None
 
1191
#   define Py_None SWIG_Py_None()
 
1192
#  endif
 
1193
SWIGRUNTIMEINLINE PyObject * 
 
1194
_SWIG_Py_None(void)
 
1195
{
 
1196
  PyObject *none = Py_BuildValue("");
 
1197
  Py_DECREF(none);
 
1198
  return none;
 
1199
}
 
1200
SWIGRUNTIME PyObject * 
 
1201
SWIG_Py_None(void)
 
1202
{
 
1203
  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
 
1204
  return none;
 
1205
}
 
1206
#endif
 
1207
 
 
1208
/* The python void return value */
 
1209
 
 
1210
SWIGRUNTIMEINLINE PyObject * 
 
1211
SWIG_Py_Void(void)
 
1212
{
 
1213
  PyObject *none = Py_None;
 
1214
  Py_INCREF(none);
 
1215
  return none;
 
1216
}
 
1217
 
 
1218
/* PySwigClientData */
 
1219
 
 
1220
typedef struct {
 
1221
  PyObject *klass;
 
1222
  PyObject *newraw;
 
1223
  PyObject *newargs;
 
1224
  PyObject *destroy;
 
1225
  int delargs;
 
1226
  int implicitconv;
 
1227
} PySwigClientData;
 
1228
 
 
1229
SWIGRUNTIMEINLINE int 
 
1230
SWIG_Python_CheckImplicit(swig_type_info *ty)
 
1231
{
 
1232
  PySwigClientData *data = (PySwigClientData *)ty->clientdata;
 
1233
  return data ? data->implicitconv : 0;
 
1234
}
 
1235
 
 
1236
SWIGRUNTIMEINLINE PyObject *
 
1237
SWIG_Python_ExceptionType(swig_type_info *desc) {
 
1238
  PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
 
1239
  PyObject *klass = data ? data->klass : 0;
 
1240
  return (klass ? klass : PyExc_RuntimeError);
 
1241
}
 
1242
 
 
1243
 
 
1244
SWIGRUNTIME PySwigClientData * 
 
1245
PySwigClientData_New(PyObject* obj)
 
1246
{
 
1247
  if (!obj) {
 
1248
    return 0;
 
1249
  } else {
 
1250
    PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
 
1251
    /* the klass element */
 
1252
    data->klass = obj;
 
1253
    Py_INCREF(data->klass);
 
1254
    /* the newraw method and newargs arguments used to create a new raw instance */
 
1255
    if (PyClass_Check(obj)) {
 
1256
      data->newraw = 0;
 
1257
      data->newargs = obj;
 
1258
      Py_INCREF(obj);
 
1259
    } else {
 
1260
#if (PY_VERSION_HEX < 0x02020000)
 
1261
      data->newraw = 0;
 
1262
#else
 
1263
      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
 
1264
#endif
 
1265
      if (data->newraw) {
 
1266
        Py_INCREF(data->newraw);
 
1267
        data->newargs = PyTuple_New(1);
 
1268
        PyTuple_SetItem(data->newargs, 0, obj);
 
1269
      } else {
 
1270
        data->newargs = obj;
 
1271
      }
 
1272
      Py_INCREF(data->newargs);
 
1273
    }
 
1274
    /* the destroy method, aka as the C++ delete method */
 
1275
    data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
 
1276
    if (PyErr_Occurred()) {
 
1277
      PyErr_Clear();
 
1278
      data->destroy = 0;
 
1279
    }
 
1280
    if (data->destroy) {
 
1281
      int flags;
 
1282
      Py_INCREF(data->destroy);
 
1283
      flags = PyCFunction_GET_FLAGS(data->destroy);
 
1284
#ifdef METH_O
 
1285
      data->delargs = !(flags & (METH_O));
 
1286
#else
 
1287
      data->delargs = 0;
 
1288
#endif
 
1289
    } else {
 
1290
      data->delargs = 0;
 
1291
    }
 
1292
    data->implicitconv = 0;
 
1293
    return data;
 
1294
  }
 
1295
}
 
1296
 
 
1297
SWIGRUNTIME void 
 
1298
PySwigClientData_Del(PySwigClientData* data)
 
1299
{
 
1300
  Py_XDECREF(data->newraw);
 
1301
  Py_XDECREF(data->newargs);
 
1302
  Py_XDECREF(data->destroy);
 
1303
}
 
1304
 
 
1305
/* =============== PySwigObject =====================*/
 
1306
 
 
1307
typedef struct {
 
1308
  PyObject_HEAD
 
1309
  void *ptr;
 
1310
  swig_type_info *ty;
 
1311
  int own;
 
1312
  PyObject *next;
 
1313
} PySwigObject;
 
1314
 
 
1315
SWIGRUNTIME PyObject *
 
1316
PySwigObject_long(PySwigObject *v)
 
1317
{
 
1318
  return PyLong_FromVoidPtr(v->ptr);
 
1319
}
 
1320
 
 
1321
SWIGRUNTIME PyObject *
 
1322
PySwigObject_format(const char* fmt, PySwigObject *v)
 
1323
{
 
1324
  PyObject *res = NULL;
 
1325
  PyObject *args = PyTuple_New(1);
 
1326
  if (args) {
 
1327
    if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
 
1328
      PyObject *ofmt = PyString_FromString(fmt);
 
1329
      if (ofmt) {
 
1330
        res = PyString_Format(ofmt,args);
 
1331
        Py_DECREF(ofmt);
 
1332
      }
 
1333
      Py_DECREF(args);
 
1334
    }
 
1335
  }
 
1336
  return res;
 
1337
}
 
1338
 
 
1339
SWIGRUNTIME PyObject *
 
1340
PySwigObject_oct(PySwigObject *v)
 
1341
{
 
1342
  return PySwigObject_format("%o",v);
 
1343
}
 
1344
 
 
1345
SWIGRUNTIME PyObject *
 
1346
PySwigObject_hex(PySwigObject *v)
 
1347
{
 
1348
  return PySwigObject_format("%x",v);
 
1349
}
 
1350
 
 
1351
SWIGRUNTIME PyObject *
 
1352
#ifdef METH_NOARGS
 
1353
PySwigObject_repr(PySwigObject *v)
 
1354
#else
 
1355
PySwigObject_repr(PySwigObject *v, PyObject *args)
 
1356
#endif
 
1357
{
 
1358
  const char *name = SWIG_TypePrettyName(v->ty);
 
1359
  PyObject *hex = PySwigObject_hex(v);    
 
1360
  PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
 
1361
  Py_DECREF(hex);
 
1362
  if (v->next) {
 
1363
#ifdef METH_NOARGS
 
1364
    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
 
1365
#else
 
1366
    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
 
1367
#endif
 
1368
    PyString_ConcatAndDel(&repr,nrep);
 
1369
  }
 
1370
  return repr;  
 
1371
}
 
1372
 
 
1373
SWIGRUNTIME int
 
1374
PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
 
1375
{
 
1376
#ifdef METH_NOARGS
 
1377
  PyObject *repr = PySwigObject_repr(v);
 
1378
#else
 
1379
  PyObject *repr = PySwigObject_repr(v, NULL);
 
1380
#endif
 
1381
  if (repr) {
 
1382
    fputs(PyString_AsString(repr), fp);
 
1383
    Py_DECREF(repr);
 
1384
    return 0; 
 
1385
  } else {
 
1386
    return 1; 
 
1387
  }
 
1388
}
 
1389
 
 
1390
SWIGRUNTIME PyObject *
 
1391
PySwigObject_str(PySwigObject *v)
 
1392
{
 
1393
  char result[SWIG_BUFFER_SIZE];
 
1394
  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
 
1395
    PyString_FromString(result) : 0;
 
1396
}
 
1397
 
 
1398
SWIGRUNTIME int
 
1399
PySwigObject_compare(PySwigObject *v, PySwigObject *w)
 
1400
{
 
1401
  void *i = v->ptr;
 
1402
  void *j = w->ptr;
 
1403
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
 
1404
}
 
1405
 
 
1406
SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
 
1407
 
 
1408
SWIGRUNTIME PyTypeObject*
 
1409
PySwigObject_type(void) {
 
1410
  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
 
1411
  return type;
 
1412
}
 
1413
 
 
1414
SWIGRUNTIMEINLINE int
 
1415
PySwigObject_Check(PyObject *op) {
 
1416
  return ((op)->ob_type == PySwigObject_type())
 
1417
    || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
 
1418
}
 
1419
 
 
1420
SWIGRUNTIME PyObject *
 
1421
PySwigObject_New(void *ptr, swig_type_info *ty, int own);
 
1422
 
 
1423
SWIGRUNTIME void
 
1424
PySwigObject_dealloc(PyObject *v)
 
1425
{
 
1426
  PySwigObject *sobj = (PySwigObject *) v;
 
1427
  PyObject *next = sobj->next;
 
1428
  if (sobj->own) {
 
1429
    swig_type_info *ty = sobj->ty;
 
1430
    PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
 
1431
    PyObject *destroy = data ? data->destroy : 0;
 
1432
    if (destroy) {
 
1433
      /* destroy is always a VARARGS method */
 
1434
      PyObject *res;
 
1435
      if (data->delargs) {
 
1436
        /* we need to create a temporal object to carry the destroy operation */
 
1437
        PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
 
1438
        res = SWIG_Python_CallFunctor(destroy, tmp);
 
1439
        Py_DECREF(tmp);
 
1440
      } else {
 
1441
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
 
1442
        PyObject *mself = PyCFunction_GET_SELF(destroy);
 
1443
        res = ((*meth)(mself, v));
 
1444
      }
 
1445
      Py_XDECREF(res);
 
1446
    } else {
 
1447
      const char *name = SWIG_TypePrettyName(ty);
 
1448
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
 
1449
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
 
1450
#endif
 
1451
    }
 
1452
  } 
 
1453
  Py_XDECREF(next);
 
1454
  PyObject_DEL(v);
 
1455
}
 
1456
 
 
1457
SWIGRUNTIME PyObject* 
 
1458
PySwigObject_append(PyObject* v, PyObject* next)
 
1459
{
 
1460
  PySwigObject *sobj = (PySwigObject *) v;
 
1461
#ifndef METH_O
 
1462
  PyObject *tmp = 0;
 
1463
  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
 
1464
  next = tmp;
 
1465
#endif
 
1466
  if (!PySwigObject_Check(next)) {
 
1467
    return NULL;
 
1468
  }
 
1469
  sobj->next = next;
 
1470
  Py_INCREF(next);
 
1471
  return SWIG_Py_Void();
 
1472
}
 
1473
 
 
1474
SWIGRUNTIME PyObject* 
 
1475
#ifdef METH_NOARGS
 
1476
PySwigObject_next(PyObject* v)
 
1477
#else
 
1478
PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
 
1479
#endif
 
1480
{
 
1481
  PySwigObject *sobj = (PySwigObject *) v;
 
1482
  if (sobj->next) {    
 
1483
    Py_INCREF(sobj->next);
 
1484
    return sobj->next;
 
1485
  } else {
 
1486
    return SWIG_Py_Void();
 
1487
  }
 
1488
}
 
1489
 
 
1490
SWIGINTERN PyObject*
 
1491
#ifdef METH_NOARGS
 
1492
PySwigObject_disown(PyObject *v)
 
1493
#else
 
1494
PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
 
1495
#endif
 
1496
{
 
1497
  PySwigObject *sobj = (PySwigObject *)v;
 
1498
  sobj->own = 0;
 
1499
  return SWIG_Py_Void();
 
1500
}
 
1501
 
 
1502
SWIGINTERN PyObject*
 
1503
#ifdef METH_NOARGS
 
1504
PySwigObject_acquire(PyObject *v)
 
1505
#else
 
1506
PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
 
1507
#endif
 
1508
{
 
1509
  PySwigObject *sobj = (PySwigObject *)v;
 
1510
  sobj->own = SWIG_POINTER_OWN;
 
1511
  return SWIG_Py_Void();
 
1512
}
 
1513
 
 
1514
SWIGINTERN PyObject*
 
1515
PySwigObject_own(PyObject *v, PyObject *args)
 
1516
{
 
1517
  PyObject *val = 0;
 
1518
#if (PY_VERSION_HEX < 0x02020000)
 
1519
  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
 
1520
#else
 
1521
  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
 
1522
#endif
 
1523
    {
 
1524
      return NULL;
 
1525
    } 
 
1526
  else
 
1527
    {
 
1528
      PySwigObject *sobj = (PySwigObject *)v;
 
1529
      PyObject *obj = PyBool_FromLong(sobj->own);
 
1530
      if (val) {
 
1531
#ifdef METH_NOARGS
 
1532
        if (PyObject_IsTrue(val)) {
 
1533
          PySwigObject_acquire(v);
 
1534
        } else {
 
1535
          PySwigObject_disown(v);
 
1536
        }
 
1537
#else
 
1538
        if (PyObject_IsTrue(val)) {
 
1539
          PySwigObject_acquire(v,args);
 
1540
        } else {
 
1541
          PySwigObject_disown(v,args);
 
1542
        }
 
1543
#endif
 
1544
      } 
 
1545
      return obj;
 
1546
    }
 
1547
}
 
1548
 
 
1549
#ifdef METH_O
 
1550
static PyMethodDef
 
1551
swigobject_methods[] = {
 
1552
  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
 
1553
  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
 
1554
  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
 
1555
  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
 
1556
  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
 
1557
  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
 
1558
  {0, 0, 0, 0}  
 
1559
};
 
1560
#else
 
1561
static PyMethodDef
 
1562
swigobject_methods[] = {
 
1563
  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
 
1564
  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
 
1565
  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
 
1566
  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
 
1567
  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
 
1568
  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
 
1569
  {0, 0, 0, 0}  
 
1570
};
 
1571
#endif
 
1572
 
 
1573
#if PY_VERSION_HEX < 0x02020000
 
1574
SWIGINTERN PyObject *
 
1575
PySwigObject_getattr(PySwigObject *sobj,char *name)
 
1576
{
 
1577
  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
 
1578
}
 
1579
#endif
 
1580
 
 
1581
SWIGRUNTIME PyTypeObject*
 
1582
_PySwigObject_type(void) {
 
1583
  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
 
1584
  
 
1585
  static PyNumberMethods PySwigObject_as_number = {
 
1586
    (binaryfunc)0, /*nb_add*/
 
1587
    (binaryfunc)0, /*nb_subtract*/
 
1588
    (binaryfunc)0, /*nb_multiply*/
 
1589
    (binaryfunc)0, /*nb_divide*/
 
1590
    (binaryfunc)0, /*nb_remainder*/
 
1591
    (binaryfunc)0, /*nb_divmod*/
 
1592
    (ternaryfunc)0,/*nb_power*/
 
1593
    (unaryfunc)0,  /*nb_negative*/
 
1594
    (unaryfunc)0,  /*nb_positive*/
 
1595
    (unaryfunc)0,  /*nb_absolute*/
 
1596
    (inquiry)0,    /*nb_nonzero*/
 
1597
    0,             /*nb_invert*/
 
1598
    0,             /*nb_lshift*/
 
1599
    0,             /*nb_rshift*/
 
1600
    0,             /*nb_and*/
 
1601
    0,             /*nb_xor*/
 
1602
    0,             /*nb_or*/
 
1603
    (coercion)0,   /*nb_coerce*/
 
1604
    (unaryfunc)PySwigObject_long, /*nb_int*/
 
1605
    (unaryfunc)PySwigObject_long, /*nb_long*/
 
1606
    (unaryfunc)0,                 /*nb_float*/
 
1607
    (unaryfunc)PySwigObject_oct,  /*nb_oct*/
 
1608
    (unaryfunc)PySwigObject_hex,  /*nb_hex*/
 
1609
#if PY_VERSION_HEX >= 0x02020000
 
1610
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 
 
1611
#elif PY_VERSION_HEX >= 0x02000000
 
1612
    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
 
1613
#endif
 
1614
  };
 
1615
 
 
1616
  static PyTypeObject pyswigobject_type;  
 
1617
  static int type_init = 0;
 
1618
  if (!type_init) {
 
1619
    const PyTypeObject tmp
 
1620
      = {
 
1621
        PyObject_HEAD_INIT(NULL)
 
1622
        0,                                  /* ob_size */
 
1623
        (char *)"PySwigObject",             /* tp_name */
 
1624
        sizeof(PySwigObject),               /* tp_basicsize */
 
1625
        0,                                  /* tp_itemsize */
 
1626
        (destructor)PySwigObject_dealloc,   /* tp_dealloc */
 
1627
        (printfunc)PySwigObject_print,      /* tp_print */
 
1628
#if PY_VERSION_HEX < 0x02020000
 
1629
        (getattrfunc)PySwigObject_getattr,  /* tp_getattr */ 
 
1630
#else
 
1631
        (getattrfunc)0,                     /* tp_getattr */ 
 
1632
#endif
 
1633
        (setattrfunc)0,                     /* tp_setattr */ 
 
1634
        (cmpfunc)PySwigObject_compare,      /* tp_compare */ 
 
1635
        (reprfunc)PySwigObject_repr,        /* tp_repr */    
 
1636
        &PySwigObject_as_number,            /* tp_as_number */
 
1637
        0,                                  /* tp_as_sequence */
 
1638
        0,                                  /* tp_as_mapping */
 
1639
        (hashfunc)0,                        /* tp_hash */
 
1640
        (ternaryfunc)0,                     /* tp_call */
 
1641
        (reprfunc)PySwigObject_str,         /* tp_str */
 
1642
        PyObject_GenericGetAttr,            /* tp_getattro */
 
1643
        0,                                  /* tp_setattro */
 
1644
        0,                                  /* tp_as_buffer */
 
1645
        Py_TPFLAGS_DEFAULT,                 /* tp_flags */
 
1646
        swigobject_doc,                     /* tp_doc */        
 
1647
        0,                                  /* tp_traverse */
 
1648
        0,                                  /* tp_clear */
 
1649
        0,                                  /* tp_richcompare */
 
1650
        0,                                  /* tp_weaklistoffset */
 
1651
#if PY_VERSION_HEX >= 0x02020000
 
1652
        0,                                  /* tp_iter */
 
1653
        0,                                  /* tp_iternext */
 
1654
        swigobject_methods,                 /* tp_methods */ 
 
1655
        0,                                  /* tp_members */
 
1656
        0,                                  /* tp_getset */             
 
1657
        0,                                  /* tp_base */               
 
1658
        0,                                  /* tp_dict */               
 
1659
        0,                                  /* tp_descr_get */          
 
1660
        0,                                  /* tp_descr_set */          
 
1661
        0,                                  /* tp_dictoffset */         
 
1662
        0,                                  /* tp_init */               
 
1663
        0,                                  /* tp_alloc */              
 
1664
        0,                                  /* tp_new */                
 
1665
        0,                                  /* tp_free */          
 
1666
        0,                                  /* tp_is_gc */  
 
1667
        0,                                  /* tp_bases */   
 
1668
        0,                                  /* tp_mro */
 
1669
        0,                                  /* tp_cache */   
 
1670
        0,                                  /* tp_subclasses */
 
1671
        0,                                  /* tp_weaklist */
 
1672
#endif
 
1673
#if PY_VERSION_HEX >= 0x02030000
 
1674
        0,                                  /* tp_del */
 
1675
#endif
 
1676
#ifdef COUNT_ALLOCS
 
1677
        0,0,0,0                             /* tp_alloc -> tp_next */
 
1678
#endif
 
1679
      };
 
1680
    pyswigobject_type = tmp;
 
1681
    pyswigobject_type.ob_type = &PyType_Type;
 
1682
    type_init = 1;
 
1683
  }
 
1684
  return &pyswigobject_type;
 
1685
}
 
1686
 
 
1687
SWIGRUNTIME PyObject *
 
1688
PySwigObject_New(void *ptr, swig_type_info *ty, int own)
 
1689
{
 
1690
  PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
 
1691
  if (sobj) {
 
1692
    sobj->ptr  = ptr;
 
1693
    sobj->ty   = ty;
 
1694
    sobj->own  = own;
 
1695
    sobj->next = 0;
 
1696
  }
 
1697
  return (PyObject *)sobj;
 
1698
}
 
1699
 
 
1700
/* -----------------------------------------------------------------------------
 
1701
 * Implements a simple Swig Packed type, and use it instead of string
 
1702
 * ----------------------------------------------------------------------------- */
 
1703
 
 
1704
typedef struct {
 
1705
  PyObject_HEAD
 
1706
  void *pack;
 
1707
  swig_type_info *ty;
 
1708
  size_t size;
 
1709
} PySwigPacked;
 
1710
 
 
1711
SWIGRUNTIME int
 
1712
PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
 
1713
{
 
1714
  char result[SWIG_BUFFER_SIZE];
 
1715
  fputs("<Swig Packed ", fp); 
 
1716
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
 
1717
    fputs("at ", fp); 
 
1718
    fputs(result, fp); 
 
1719
  }
 
1720
  fputs(v->ty->name,fp); 
 
1721
  fputs(">", fp);
 
1722
  return 0; 
 
1723
}
 
1724
  
 
1725
SWIGRUNTIME PyObject *
 
1726
PySwigPacked_repr(PySwigPacked *v)
 
1727
{
 
1728
  char result[SWIG_BUFFER_SIZE];
 
1729
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
 
1730
    return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
 
1731
  } else {
 
1732
    return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
 
1733
  }  
 
1734
}
 
1735
 
 
1736
SWIGRUNTIME PyObject *
 
1737
PySwigPacked_str(PySwigPacked *v)
 
1738
{
 
1739
  char result[SWIG_BUFFER_SIZE];
 
1740
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
 
1741
    return PyString_FromFormat("%s%s", result, v->ty->name);
 
1742
  } else {
 
1743
    return PyString_FromString(v->ty->name);
 
1744
  }  
 
1745
}
 
1746
 
 
1747
SWIGRUNTIME int
 
1748
PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
 
1749
{
 
1750
  size_t i = v->size;
 
1751
  size_t j = w->size;
 
1752
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
 
1753
  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
 
1754
}
 
1755
 
 
1756
SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
 
1757
 
 
1758
SWIGRUNTIME PyTypeObject*
 
1759
PySwigPacked_type(void) {
 
1760
  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
 
1761
  return type;
 
1762
}
 
1763
 
 
1764
SWIGRUNTIMEINLINE int
 
1765
PySwigPacked_Check(PyObject *op) {
 
1766
  return ((op)->ob_type == _PySwigPacked_type()) 
 
1767
    || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
 
1768
}
 
1769
 
 
1770
SWIGRUNTIME void
 
1771
PySwigPacked_dealloc(PyObject *v)
 
1772
{
 
1773
  if (PySwigPacked_Check(v)) {
 
1774
    PySwigPacked *sobj = (PySwigPacked *) v;
 
1775
    free(sobj->pack);
 
1776
  }
 
1777
  PyObject_DEL(v);
 
1778
}
 
1779
 
 
1780
SWIGRUNTIME PyTypeObject*
 
1781
_PySwigPacked_type(void) {
 
1782
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
 
1783
  static PyTypeObject pyswigpacked_type;
 
1784
  static int type_init = 0;  
 
1785
  if (!type_init) {
 
1786
    const PyTypeObject tmp
 
1787
      = {
 
1788
        PyObject_HEAD_INIT(NULL)
 
1789
        0,                                  /* ob_size */       
 
1790
        (char *)"PySwigPacked",             /* tp_name */       
 
1791
        sizeof(PySwigPacked),               /* tp_basicsize */  
 
1792
        0,                                  /* tp_itemsize */   
 
1793
        (destructor)PySwigPacked_dealloc,   /* tp_dealloc */    
 
1794
        (printfunc)PySwigPacked_print,      /* tp_print */      
 
1795
        (getattrfunc)0,                     /* tp_getattr */    
 
1796
        (setattrfunc)0,                     /* tp_setattr */    
 
1797
        (cmpfunc)PySwigPacked_compare,      /* tp_compare */    
 
1798
        (reprfunc)PySwigPacked_repr,        /* tp_repr */       
 
1799
        0,                                  /* tp_as_number */  
 
1800
        0,                                  /* tp_as_sequence */
 
1801
        0,                                  /* tp_as_mapping */ 
 
1802
        (hashfunc)0,                        /* tp_hash */       
 
1803
        (ternaryfunc)0,                     /* tp_call */       
 
1804
        (reprfunc)PySwigPacked_str,         /* tp_str */        
 
1805
        PyObject_GenericGetAttr,            /* tp_getattro */
 
1806
        0,                                  /* tp_setattro */
 
1807
        0,                                  /* tp_as_buffer */
 
1808
        Py_TPFLAGS_DEFAULT,                 /* tp_flags */
 
1809
        swigpacked_doc,                     /* tp_doc */
 
1810
        0,                                  /* tp_traverse */
 
1811
        0,                                  /* tp_clear */
 
1812
        0,                                  /* tp_richcompare */
 
1813
        0,                                  /* tp_weaklistoffset */
 
1814
#if PY_VERSION_HEX >= 0x02020000
 
1815
        0,                                  /* tp_iter */
 
1816
        0,                                  /* tp_iternext */
 
1817
        0,                                  /* tp_methods */ 
 
1818
        0,                                  /* tp_members */
 
1819
        0,                                  /* tp_getset */             
 
1820
        0,                                  /* tp_base */               
 
1821
        0,                                  /* tp_dict */               
 
1822
        0,                                  /* tp_descr_get */          
 
1823
        0,                                  /* tp_descr_set */          
 
1824
        0,                                  /* tp_dictoffset */         
 
1825
        0,                                  /* tp_init */               
 
1826
        0,                                  /* tp_alloc */              
 
1827
        0,                                  /* tp_new */                
 
1828
        0,                                  /* tp_free */          
 
1829
        0,                                  /* tp_is_gc */  
 
1830
        0,                                  /* tp_bases */   
 
1831
        0,                                  /* tp_mro */
 
1832
        0,                                  /* tp_cache */   
 
1833
        0,                                  /* tp_subclasses */
 
1834
        0,                                  /* tp_weaklist */
 
1835
#endif
 
1836
#if PY_VERSION_HEX >= 0x02030000
 
1837
        0,                                  /* tp_del */
 
1838
#endif
 
1839
#ifdef COUNT_ALLOCS
 
1840
        0,0,0,0                             /* tp_alloc -> tp_next */
 
1841
#endif
 
1842
      };
 
1843
    pyswigpacked_type = tmp;
 
1844
    pyswigpacked_type.ob_type = &PyType_Type;
 
1845
    type_init = 1;
 
1846
  }
 
1847
  return &pyswigpacked_type;
 
1848
}
 
1849
 
 
1850
SWIGRUNTIME PyObject *
 
1851
PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
 
1852
{
 
1853
  PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
 
1854
  if (sobj) {
 
1855
    void *pack = malloc(size);
 
1856
    if (pack) {
 
1857
      memcpy(pack, ptr, size);
 
1858
      sobj->pack = pack;
 
1859
      sobj->ty   = ty;
 
1860
      sobj->size = size;
 
1861
    } else {
 
1862
      PyObject_DEL((PyObject *) sobj);
 
1863
      sobj = 0;
 
1864
    }
 
1865
  }
 
1866
  return (PyObject *) sobj;
 
1867
}
 
1868
 
 
1869
SWIGRUNTIME swig_type_info *
 
1870
PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
 
1871
{
 
1872
  if (PySwigPacked_Check(obj)) {
 
1873
    PySwigPacked *sobj = (PySwigPacked *)obj;
 
1874
    if (sobj->size != size) return 0;
 
1875
    memcpy(ptr, sobj->pack, size);
 
1876
    return sobj->ty;
 
1877
  } else {
 
1878
    return 0;
 
1879
  }
 
1880
}
 
1881
 
 
1882
/* -----------------------------------------------------------------------------
 
1883
 * pointers/data manipulation
 
1884
 * ----------------------------------------------------------------------------- */
 
1885
 
 
1886
SWIGRUNTIMEINLINE PyObject *
 
1887
_SWIG_This(void)
 
1888
{
 
1889
  return PyString_FromString("this");
 
1890
}
 
1891
 
 
1892
SWIGRUNTIME PyObject *
 
1893
SWIG_This(void)
 
1894
{
 
1895
  static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
 
1896
  return swig_this;
 
1897
}
 
1898
 
 
1899
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
 
1900
 
 
1901
SWIGRUNTIME PySwigObject *
 
1902
SWIG_Python_GetSwigThis(PyObject *pyobj) 
 
1903
{
 
1904
  if (PySwigObject_Check(pyobj)) {
 
1905
    return (PySwigObject *) pyobj;
 
1906
  } else {
 
1907
    PyObject *obj = 0;
 
1908
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
 
1909
    if (PyInstance_Check(pyobj)) {
 
1910
      obj = _PyInstance_Lookup(pyobj, SWIG_This());      
 
1911
    } else {
 
1912
      PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
 
1913
      if (dictptr != NULL) {
 
1914
        PyObject *dict = *dictptr;
 
1915
        obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
 
1916
      } else {
 
1917
#ifdef PyWeakref_CheckProxy
 
1918
        if (PyWeakref_CheckProxy(pyobj)) {
 
1919
          PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
 
1920
          return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
 
1921
        }
 
1922
#endif
 
1923
        obj = PyObject_GetAttr(pyobj,SWIG_This());
 
1924
        if (obj) {
 
1925
          Py_DECREF(obj);
 
1926
        } else {
 
1927
          if (PyErr_Occurred()) PyErr_Clear();
 
1928
          return 0;
 
1929
        }
 
1930
      }
 
1931
    }
 
1932
#else
 
1933
    obj = PyObject_GetAttr(pyobj,SWIG_This());
 
1934
    if (obj) {
 
1935
      Py_DECREF(obj);
 
1936
    } else {
 
1937
      if (PyErr_Occurred()) PyErr_Clear();
 
1938
      return 0;
 
1939
    }
 
1940
#endif
 
1941
    if (obj && !PySwigObject_Check(obj)) {
 
1942
      /* a PyObject is called 'this', try to get the 'real this'
 
1943
         PySwigObject from it */ 
 
1944
      return SWIG_Python_GetSwigThis(obj);
 
1945
    }
 
1946
    return (PySwigObject *)obj;
 
1947
  }
 
1948
}
 
1949
 
 
1950
/* Acquire a pointer value */
 
1951
 
 
1952
SWIGRUNTIME int
 
1953
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
 
1954
  if (own) {
 
1955
    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
 
1956
    if (sobj) {
 
1957
      int oldown = sobj->own;
 
1958
      sobj->own = own;
 
1959
      return oldown;
 
1960
    }
 
1961
  }
 
1962
  return 0;
 
1963
}
 
1964
 
 
1965
/* Convert a pointer value */
 
1966
 
 
1967
SWIGRUNTIME int
 
1968
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
 
1969
  if (!obj) return SWIG_ERROR;
 
1970
  if (obj == Py_None) {
 
1971
    if (ptr) *ptr = 0;
 
1972
    return SWIG_OK;
 
1973
  } else {
 
1974
    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
 
1975
    while (sobj) {
 
1976
      void *vptr = sobj->ptr;
 
1977
      if (ty) {
 
1978
        swig_type_info *to = sobj->ty;
 
1979
        if (to == ty) {
 
1980
          /* no type cast needed */
 
1981
          if (ptr) *ptr = vptr;
 
1982
          break;
 
1983
        } else {
 
1984
          swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
 
1985
          if (!tc) {
 
1986
            sobj = (PySwigObject *)sobj->next;
 
1987
          } else {
 
1988
            if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
 
1989
            break;
 
1990
          }
 
1991
        }
 
1992
      } else {
 
1993
        if (ptr) *ptr = vptr;
 
1994
        break;
 
1995
      }
 
1996
    }
 
1997
    if (sobj) {
 
1998
      if (own) *own = sobj->own;
 
1999
      if (flags & SWIG_POINTER_DISOWN) {
 
2000
        sobj->own = 0;
 
2001
      }
 
2002
      return SWIG_OK;
 
2003
    } else {
 
2004
      int res = SWIG_ERROR;
 
2005
      if (flags & SWIG_POINTER_IMPLICIT_CONV) {
 
2006
        PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
 
2007
        if (data && !data->implicitconv) {
 
2008
          PyObject *klass = data->klass;
 
2009
          if (klass) {
 
2010
            PyObject *impconv;
 
2011
            data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
 
2012
            impconv = SWIG_Python_CallFunctor(klass, obj);
 
2013
            data->implicitconv = 0;
 
2014
            if (PyErr_Occurred()) {
 
2015
              PyErr_Clear();
 
2016
              impconv = 0;
 
2017
            }
 
2018
            if (impconv) {
 
2019
              PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
 
2020
              if (iobj) {
 
2021
                void *vptr;
 
2022
                res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
 
2023
                if (SWIG_IsOK(res)) {
 
2024
                  if (ptr) {
 
2025
                    *ptr = vptr;
 
2026
                    /* transfer the ownership to 'ptr' */
 
2027
                    iobj->own = 0;
 
2028
                    res = SWIG_AddCast(res);
 
2029
                    res = SWIG_AddNewMask(res);
 
2030
                  } else {
 
2031
                    res = SWIG_AddCast(res);                
 
2032
                  }
 
2033
                }
 
2034
              }
 
2035
              Py_DECREF(impconv);
 
2036
            }
 
2037
          }
 
2038
        }
 
2039
      }
 
2040
      return res;
 
2041
    }
 
2042
  }
 
2043
}
 
2044
 
 
2045
/* Convert a function ptr value */
 
2046
 
 
2047
SWIGRUNTIME int
 
2048
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
 
2049
  if (!PyCFunction_Check(obj)) {
 
2050
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
 
2051
  } else {
 
2052
    void *vptr = 0;
 
2053
    
 
2054
    /* here we get the method pointer for callbacks */
 
2055
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
 
2056
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
 
2057
    if (desc) {
 
2058
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
 
2059
      if (!desc) return SWIG_ERROR;
 
2060
    }
 
2061
    if (ty) {
 
2062
      swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
 
2063
      if (!tc) return SWIG_ERROR;
 
2064
      *ptr = SWIG_TypeCast(tc,vptr);
 
2065
    } else {
 
2066
      *ptr = vptr;
 
2067
    }
 
2068
    return SWIG_OK;
 
2069
  }
 
2070
}
 
2071
 
 
2072
/* Convert a packed value value */
 
2073
 
 
2074
SWIGRUNTIME int
 
2075
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
 
2076
  swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
 
2077
  if (!to) return SWIG_ERROR;
 
2078
  if (ty) {
 
2079
    if (to != ty) {
 
2080
      /* check type cast? */
 
2081
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
 
2082
      if (!tc) return SWIG_ERROR;
 
2083
    }
 
2084
  }
 
2085
  return SWIG_OK;
 
2086
}  
 
2087
 
 
2088
/* -----------------------------------------------------------------------------
 
2089
 * Create a new pointer object
 
2090
 * ----------------------------------------------------------------------------- */
 
2091
 
 
2092
/*
 
2093
  Create a new instance object, whitout calling __init__, and set the
 
2094
  'this' attribute.
 
2095
*/
 
2096
 
 
2097
SWIGRUNTIME PyObject* 
 
2098
SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
 
2099
{
 
2100
#if (PY_VERSION_HEX >= 0x02020000)
 
2101
  PyObject *inst = 0;
 
2102
  PyObject *newraw = data->newraw;
 
2103
  if (newraw) {
 
2104
    inst = PyObject_Call(newraw, data->newargs, NULL);
 
2105
    if (inst) {
 
2106
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
 
2107
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
 
2108
      if (dictptr != NULL) {
 
2109
        PyObject *dict = *dictptr;
 
2110
        if (dict == NULL) {
 
2111
          dict = PyDict_New();
 
2112
          *dictptr = dict;
 
2113
          PyDict_SetItem(dict, SWIG_This(), swig_this);
 
2114
        }
 
2115
      }
 
2116
#else
 
2117
      PyObject *key = SWIG_This();
 
2118
      PyObject_SetAttr(inst, key, swig_this);
 
2119
#endif
 
2120
    }
 
2121
  } else {
 
2122
    PyObject *dict = PyDict_New();
 
2123
    PyDict_SetItem(dict, SWIG_This(), swig_this);
 
2124
    inst = PyInstance_NewRaw(data->newargs, dict);
 
2125
    Py_DECREF(dict);
 
2126
  }
 
2127
  return inst;
 
2128
#else
 
2129
#if (PY_VERSION_HEX >= 0x02010000)
 
2130
  PyObject *inst;
 
2131
  PyObject *dict = PyDict_New();
 
2132
  PyDict_SetItem(dict, SWIG_This(), swig_this);
 
2133
  inst = PyInstance_NewRaw(data->newargs, dict);
 
2134
  Py_DECREF(dict);
 
2135
  return (PyObject *) inst;
 
2136
#else
 
2137
  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
 
2138
  if (inst == NULL) {
 
2139
    return NULL;
 
2140
  }
 
2141
  inst->in_class = (PyClassObject *)data->newargs;
 
2142
  Py_INCREF(inst->in_class);
 
2143
  inst->in_dict = PyDict_New();
 
2144
  if (inst->in_dict == NULL) {
 
2145
    Py_DECREF(inst);
 
2146
    return NULL;
 
2147
  }
 
2148
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
 
2149
  inst->in_weakreflist = NULL;
 
2150
#endif
 
2151
#ifdef Py_TPFLAGS_GC
 
2152
  PyObject_GC_Init(inst);
 
2153
#endif
 
2154
  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
 
2155
  return (PyObject *) inst;
 
2156
#endif
 
2157
#endif
 
2158
}
 
2159
 
 
2160
SWIGRUNTIME void
 
2161
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
 
2162
{
 
2163
 PyObject *dict;
 
2164
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
 
2165
 PyObject **dictptr = _PyObject_GetDictPtr(inst);
 
2166
 if (dictptr != NULL) {
 
2167
   dict = *dictptr;
 
2168
   if (dict == NULL) {
 
2169
     dict = PyDict_New();
 
2170
     *dictptr = dict;
 
2171
   }
 
2172
   PyDict_SetItem(dict, SWIG_This(), swig_this);
 
2173
   return;
 
2174
 }
 
2175
#endif
 
2176
 dict = PyObject_GetAttrString(inst, "__dict__");
 
2177
 PyDict_SetItem(dict, SWIG_This(), swig_this);
 
2178
 Py_DECREF(dict);
 
2179
 
2180
 
 
2181
 
 
2182
SWIGINTERN PyObject *
 
2183
SWIG_Python_InitShadowInstance(PyObject *args) {
 
2184
  PyObject *obj[2];
 
2185
  if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
 
2186
    return NULL;
 
2187
  } else {
 
2188
    PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
 
2189
    if (sthis) {
 
2190
      PySwigObject_append((PyObject*) sthis, obj[1]);
 
2191
    } else {
 
2192
      SWIG_Python_SetSwigThis(obj[0], obj[1]);
 
2193
    }
 
2194
    return SWIG_Py_Void();
 
2195
  }
 
2196
}
 
2197
 
 
2198
/* Create a new pointer object */
 
2199
 
 
2200
SWIGRUNTIME PyObject *
 
2201
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
 
2202
  if (!ptr) {
 
2203
    return SWIG_Py_Void();
 
2204
  } else {
 
2205
    int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
 
2206
    PyObject *robj = PySwigObject_New(ptr, type, own);
 
2207
    PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
 
2208
    if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
 
2209
      PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
 
2210
      if (inst) {
 
2211
        Py_DECREF(robj);
 
2212
        robj = inst;
 
2213
      }
 
2214
    }
 
2215
    return robj;
 
2216
  }
 
2217
}
 
2218
 
 
2219
/* Create a new packed object */
 
2220
 
 
2221
SWIGRUNTIMEINLINE PyObject *
 
2222
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
 
2223
  return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
 
2224
}
 
2225
 
 
2226
/* -----------------------------------------------------------------------------*
 
2227
 *  Get type list 
 
2228
 * -----------------------------------------------------------------------------*/
 
2229
 
 
2230
#ifdef SWIG_LINK_RUNTIME
 
2231
void *SWIG_ReturnGlobalTypeList(void *);
 
2232
#endif
 
2233
 
 
2234
SWIGRUNTIME swig_module_info *
 
2235
SWIG_Python_GetModule(void) {
 
2236
  static void *type_pointer = (void *)0;
 
2237
  /* first check if module already created */
 
2238
  if (!type_pointer) {
 
2239
#ifdef SWIG_LINK_RUNTIME
 
2240
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
 
2241
#else
 
2242
    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
 
2243
                                    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
 
2244
    if (PyErr_Occurred()) {
 
2245
      PyErr_Clear();
 
2246
      type_pointer = (void *)0;
 
2247
    }
 
2248
#endif
 
2249
  }
 
2250
  return (swig_module_info *) type_pointer;
 
2251
}
 
2252
 
 
2253
#if PY_MAJOR_VERSION < 2
 
2254
/* PyModule_AddObject function was introduced in Python 2.0.  The following function
 
2255
   is copied out of Python/modsupport.c in python version 2.3.4 */
 
2256
SWIGINTERN int
 
2257
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
 
2258
{
 
2259
  PyObject *dict;
 
2260
  if (!PyModule_Check(m)) {
 
2261
    PyErr_SetString(PyExc_TypeError,
 
2262
                    "PyModule_AddObject() needs module as first arg");
 
2263
    return SWIG_ERROR;
 
2264
  }
 
2265
  if (!o) {
 
2266
    PyErr_SetString(PyExc_TypeError,
 
2267
                    "PyModule_AddObject() needs non-NULL value");
 
2268
    return SWIG_ERROR;
 
2269
  }
 
2270
  
 
2271
  dict = PyModule_GetDict(m);
 
2272
  if (dict == NULL) {
 
2273
    /* Internal error -- modules must have a dict! */
 
2274
    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
 
2275
                 PyModule_GetName(m));
 
2276
    return SWIG_ERROR;
 
2277
  }
 
2278
  if (PyDict_SetItemString(dict, name, o))
 
2279
    return SWIG_ERROR;
 
2280
  Py_DECREF(o);
 
2281
  return SWIG_OK;
 
2282
}
 
2283
#endif
 
2284
 
 
2285
SWIGRUNTIME void
 
2286
SWIG_Python_DestroyModule(void *vptr)
 
2287
{
 
2288
  swig_module_info *swig_module = (swig_module_info *) vptr;
 
2289
  swig_type_info **types = swig_module->types;
 
2290
  size_t i;
 
2291
  for (i =0; i < swig_module->size; ++i) {
 
2292
    swig_type_info *ty = types[i];
 
2293
    if (ty->owndata) {
 
2294
      PySwigClientData *data = (PySwigClientData *) ty->clientdata;
 
2295
      if (data) PySwigClientData_Del(data);
 
2296
    }
 
2297
  }
 
2298
  Py_DECREF(SWIG_This());
 
2299
}
 
2300
 
 
2301
SWIGRUNTIME void
 
2302
SWIG_Python_SetModule(swig_module_info *swig_module) {
 
2303
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
 
2304
 
 
2305
  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
 
2306
                                   swig_empty_runtime_method_table);
 
2307
  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
 
2308
  if (pointer && module) {
 
2309
    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
 
2310
  } else {
 
2311
    Py_XDECREF(pointer);
 
2312
  }
 
2313
}
 
2314
 
 
2315
/* The python cached type query */
 
2316
SWIGRUNTIME PyObject *
 
2317
SWIG_Python_TypeCache() {
 
2318
  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
 
2319
  return cache;
 
2320
}
 
2321
 
 
2322
SWIGRUNTIME swig_type_info *
 
2323
SWIG_Python_TypeQuery(const char *type)
 
2324
{
 
2325
  PyObject *cache = SWIG_Python_TypeCache();
 
2326
  PyObject *key = PyString_FromString(type); 
 
2327
  PyObject *obj = PyDict_GetItem(cache, key);
 
2328
  swig_type_info *descriptor;
 
2329
  if (obj) {
 
2330
    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
 
2331
  } else {
 
2332
    swig_module_info *swig_module = SWIG_Python_GetModule();
 
2333
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
 
2334
    if (descriptor) {
 
2335
      obj = PyCObject_FromVoidPtr(descriptor, NULL);
 
2336
      PyDict_SetItem(cache, key, obj);
 
2337
      Py_DECREF(obj);
 
2338
    }
 
2339
  }
 
2340
  Py_DECREF(key);
 
2341
  return descriptor;
 
2342
}
 
2343
 
 
2344
/* 
 
2345
   For backward compatibility only
 
2346
*/
 
2347
#define SWIG_POINTER_EXCEPTION  0
 
2348
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
 
2349
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
 
2350
 
 
2351
SWIGRUNTIME int
 
2352
SWIG_Python_AddErrMesg(const char* mesg, int infront)
 
2353
{
 
2354
  if (PyErr_Occurred()) {
 
2355
    PyObject *type = 0;
 
2356
    PyObject *value = 0;
 
2357
    PyObject *traceback = 0;
 
2358
    PyErr_Fetch(&type, &value, &traceback);
 
2359
    if (value) {
 
2360
      PyObject *old_str = PyObject_Str(value);
 
2361
      Py_XINCREF(type);
 
2362
      PyErr_Clear();
 
2363
      if (infront) {
 
2364
        PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
 
2365
      } else {
 
2366
        PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
 
2367
      }
 
2368
      Py_DECREF(old_str);
 
2369
    }
 
2370
    return 1;
 
2371
  } else {
 
2372
    return 0;
 
2373
  }
 
2374
}
 
2375
  
 
2376
SWIGRUNTIME int
 
2377
SWIG_Python_ArgFail(int argnum)
 
2378
{
 
2379
  if (PyErr_Occurred()) {
 
2380
    /* add information about failing argument */
 
2381
    char mesg[256];
 
2382
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
 
2383
    return SWIG_Python_AddErrMesg(mesg, 1);
 
2384
  } else {
 
2385
    return 0;
 
2386
  }
 
2387
}
 
2388
 
 
2389
SWIGRUNTIMEINLINE const char *
 
2390
PySwigObject_GetDesc(PyObject *self)
 
2391
{
 
2392
  PySwigObject *v = (PySwigObject *)self;
 
2393
  swig_type_info *ty = v ? v->ty : 0;
 
2394
  return ty ? ty->str : (char*)"";
 
2395
}
 
2396
 
 
2397
SWIGRUNTIME void
 
2398
SWIG_Python_TypeError(const char *type, PyObject *obj)
 
2399
{
 
2400
  if (type) {
 
2401
#if defined(SWIG_COBJECT_TYPES)
 
2402
    if (obj && PySwigObject_Check(obj)) {
 
2403
      const char *otype = (const char *) PySwigObject_GetDesc(obj);
 
2404
      if (otype) {
 
2405
        PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
 
2406
                     type, otype);
 
2407
        return;
 
2408
      }
 
2409
    } else 
 
2410
#endif      
 
2411
    {
 
2412
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
 
2413
      if (otype) {
 
2414
        PyObject *str = PyObject_Str(obj);
 
2415
        const char *cstr = str ? PyString_AsString(str) : 0;
 
2416
        if (cstr) {
 
2417
          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
 
2418
                       type, otype, cstr);
 
2419
        } else {
 
2420
          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
 
2421
                       type, otype);
 
2422
        }
 
2423
        Py_XDECREF(str);
 
2424
        return;
 
2425
      }
 
2426
    }   
 
2427
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
 
2428
  } else {
 
2429
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
 
2430
  }
 
2431
}
 
2432
 
 
2433
 
 
2434
/* Convert a pointer value, signal an exception on a type mismatch */
 
2435
SWIGRUNTIME void *
 
2436
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
 
2437
  void *result;
 
2438
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
 
2439
    PyErr_Clear();
 
2440
    if (flags & SWIG_POINTER_EXCEPTION) {
 
2441
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
 
2442
      SWIG_Python_ArgFail(argnum);
 
2443
    }
 
2444
  }
 
2445
  return result;
 
2446
}
 
2447
 
 
2448
 
 
2449
#ifdef __cplusplus
 
2450
#if 0
 
2451
{ /* cc-mode */
 
2452
#endif
 
2453
}
 
2454
#endif
 
2455
 
 
2456
 
 
2457
 
 
2458
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
 
2459
 
 
2460
#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
 
2461
 
 
2462
 
 
2463
 
 
2464
/* -------- TYPES TABLE (BEGIN) -------- */
 
2465
 
 
2466
#define SWIGTYPE_p_char swig_types[0]
 
2467
#define SWIGTYPE_p_double swig_types[1]
 
2468
#define SWIGTYPE_p_int swig_types[2]
 
2469
#define SWIGTYPE_p_unsigned_char swig_types[3]
 
2470
#define SWIGTYPE_p_unsigned_int swig_types[4]
 
2471
#define SWIGTYPE_p_unsigned_long swig_types[5]
 
2472
#define SWIGTYPE_p_wxANIHandler swig_types[6]
 
2473
#define SWIGTYPE_p_wxAcceleratorTable swig_types[7]
 
2474
#define SWIGTYPE_p_wxActivateEvent swig_types[8]
 
2475
#define SWIGTYPE_p_wxBMPHandler swig_types[9]
 
2476
#define SWIGTYPE_p_wxBitmap swig_types[10]
 
2477
#define SWIGTYPE_p_wxBookCtrlBase swig_types[11]
 
2478
#define SWIGTYPE_p_wxBookCtrlEvent swig_types[12]
 
2479
#define SWIGTYPE_p_wxBoxSizer swig_types[13]
 
2480
#define SWIGTYPE_p_wxCURHandler swig_types[14]
 
2481
#define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[15]
 
2482
#define SWIGTYPE_p_wxChildFocusEvent swig_types[16]
 
2483
#define SWIGTYPE_p_wxClipboardTextEvent swig_types[17]
 
2484
#define SWIGTYPE_p_wxCloseEvent swig_types[18]
 
2485
#define SWIGTYPE_p_wxColour swig_types[19]
 
2486
#define SWIGTYPE_p_wxColourData swig_types[20]
 
2487
#define SWIGTYPE_p_wxColourDialog swig_types[21]
 
2488
#define SWIGTYPE_p_wxCommandEvent swig_types[22]
 
2489
#define SWIGTYPE_p_wxContextMenuEvent swig_types[23]
 
2490
#define SWIGTYPE_p_wxControl swig_types[24]
 
2491
#define SWIGTYPE_p_wxControlWithItems swig_types[25]
 
2492
#define SWIGTYPE_p_wxDC swig_types[26]
 
2493
#define SWIGTYPE_p_wxDateEvent swig_types[27]
 
2494
#define SWIGTYPE_p_wxDialog swig_types[28]
 
2495
#define SWIGTYPE_p_wxDialogLayoutAdapter swig_types[29]
 
2496
#define SWIGTYPE_p_wxDirDialog swig_types[30]
 
2497
#define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
 
2498
#define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
 
2499
#define SWIGTYPE_p_wxDuplexMode swig_types[33]
 
2500
#define SWIGTYPE_p_wxEraseEvent swig_types[34]
 
2501
#define SWIGTYPE_p_wxEvent swig_types[35]
 
2502
#define SWIGTYPE_p_wxEventBlocker swig_types[36]
 
2503
#define SWIGTYPE_p_wxEvtHandler swig_types[37]
 
2504
#define SWIGTYPE_p_wxFSFile swig_types[38]
 
2505
#define SWIGTYPE_p_wxFileDialog swig_types[39]
 
2506
#define SWIGTYPE_p_wxFileSystem swig_types[40]
 
2507
#define SWIGTYPE_p_wxFindDialogEvent swig_types[41]
 
2508
#define SWIGTYPE_p_wxFindReplaceData swig_types[42]
 
2509
#define SWIGTYPE_p_wxFindReplaceDialog swig_types[43]
 
2510
#define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
 
2511
#define SWIGTYPE_p_wxFocusEvent swig_types[45]
 
2512
#define SWIGTYPE_p_wxFontData swig_types[46]
 
2513
#define SWIGTYPE_p_wxFontDialog swig_types[47]
 
2514
#define SWIGTYPE_p_wxFrame swig_types[48]
 
2515
#define SWIGTYPE_p_wxGBSizerItem swig_types[49]
 
2516
#define SWIGTYPE_p_wxGIFHandler swig_types[50]
 
2517
#define SWIGTYPE_p_wxGenericProgressDialog swig_types[51]
 
2518
#define SWIGTYPE_p_wxGridBagSizer swig_types[52]
 
2519
#define SWIGTYPE_p_wxGridSizer swig_types[53]
 
2520
#define SWIGTYPE_p_wxICOHandler swig_types[54]
 
2521
#define SWIGTYPE_p_wxIconizeEvent swig_types[55]
 
2522
#define SWIGTYPE_p_wxIdleEvent swig_types[56]
 
2523
#define SWIGTYPE_p_wxImage swig_types[57]
 
2524
#define SWIGTYPE_p_wxImageHandler swig_types[58]
 
2525
#define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[59]
 
2526
#define SWIGTYPE_p_wxInitDialogEvent swig_types[60]
 
2527
#define SWIGTYPE_p_wxJPEGHandler swig_types[61]
 
2528
#define SWIGTYPE_p_wxKeyEvent swig_types[62]
 
2529
#define SWIGTYPE_p_wxLayoutAlgorithm swig_types[63]
 
2530
#define SWIGTYPE_p_wxLayoutConstraints swig_types[64]
 
2531
#define SWIGTYPE_p_wxMDIChildFrame swig_types[65]
 
2532
#define SWIGTYPE_p_wxMDIClientWindow swig_types[66]
 
2533
#define SWIGTYPE_p_wxMDIParentFrame swig_types[67]
 
2534
#define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
 
2535
#define SWIGTYPE_p_wxMenu swig_types[69]
 
2536
#define SWIGTYPE_p_wxMenuBar swig_types[70]
 
2537
#define SWIGTYPE_p_wxMenuEvent swig_types[71]
 
2538
#define SWIGTYPE_p_wxMenuItem swig_types[72]
 
2539
#define SWIGTYPE_p_wxMessageDialog swig_types[73]
 
2540
#define SWIGTYPE_p_wxMiniFrame swig_types[74]
 
2541
#define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
 
2542
#define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[76]
 
2543
#define SWIGTYPE_p_wxMouseEvent swig_types[77]
 
2544
#define SWIGTYPE_p_wxMoveEvent swig_types[78]
 
2545
#define SWIGTYPE_p_wxMultiChoiceDialog swig_types[79]
 
2546
#define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
 
2547
#define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
 
2548
#define SWIGTYPE_p_wxNotifyEvent swig_types[82]
 
2549
#define SWIGTYPE_p_wxNumberEntryDialog swig_types[83]
 
2550
#define SWIGTYPE_p_wxObject swig_types[84]
 
2551
#define SWIGTYPE_p_wxPCXHandler swig_types[85]
 
2552
#define SWIGTYPE_p_wxPNGHandler swig_types[86]
 
2553
#define SWIGTYPE_p_wxPNMHandler swig_types[87]
 
2554
#define SWIGTYPE_p_wxPageSetupDialog swig_types[88]
 
2555
#define SWIGTYPE_p_wxPageSetupDialogData swig_types[89]
 
2556
#define SWIGTYPE_p_wxPaintEvent swig_types[90]
 
2557
#define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
 
2558
#define SWIGTYPE_p_wxPanel swig_types[92]
 
2559
#define SWIGTYPE_p_wxPaperSize swig_types[93]
 
2560
#define SWIGTYPE_p_wxPasswordEntryDialog swig_types[94]
 
2561
#define SWIGTYPE_p_wxPopupWindow swig_types[95]
 
2562
#define SWIGTYPE_p_wxPreviewCanvas swig_types[96]
 
2563
#define SWIGTYPE_p_wxPreviewControlBar swig_types[97]
 
2564
#define SWIGTYPE_p_wxPreviewFrame swig_types[98]
 
2565
#define SWIGTYPE_p_wxPrintData swig_types[99]
 
2566
#define SWIGTYPE_p_wxPrintDialog swig_types[100]
 
2567
#define SWIGTYPE_p_wxPrintDialogData swig_types[101]
 
2568
#define SWIGTYPE_p_wxPrintPreview swig_types[102]
 
2569
#define SWIGTYPE_p_wxPrinter swig_types[103]
 
2570
#define SWIGTYPE_p_wxProgressDialog swig_types[104]
 
2571
#define SWIGTYPE_p_wxPyApp swig_types[105]
 
2572
#define SWIGTYPE_p_wxPyCommandEvent swig_types[106]
 
2573
#define SWIGTYPE_p_wxPyEvent swig_types[107]
 
2574
#define SWIGTYPE_p_wxPyEvtHandler swig_types[108]
 
2575
#define SWIGTYPE_p_wxPyHScrolledWindow swig_types[109]
 
2576
#define SWIGTYPE_p_wxPyHVScrolledWindow swig_types[110]
 
2577
#define SWIGTYPE_p_wxPyHtmlListBox swig_types[111]
 
2578
#define SWIGTYPE_p_wxPyImageHandler swig_types[112]
 
2579
#define SWIGTYPE_p_wxPyPanel swig_types[113]
 
2580
#define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[114]
 
2581
#define SWIGTYPE_p_wxPyPreviewControlBar swig_types[115]
 
2582
#define SWIGTYPE_p_wxPyPreviewFrame swig_types[116]
 
2583
#define SWIGTYPE_p_wxPyPrintPreview swig_types[117]
 
2584
#define SWIGTYPE_p_wxPyPrintout swig_types[118]
 
2585
#define SWIGTYPE_p_wxPyScrolledWindow swig_types[119]
 
2586
#define SWIGTYPE_p_wxPySizer swig_types[120]
 
2587
#define SWIGTYPE_p_wxPyTaskBarIcon swig_types[121]
 
2588
#define SWIGTYPE_p_wxPyVListBox swig_types[122]
 
2589
#define SWIGTYPE_p_wxPyVScrolledWindow swig_types[123]
 
2590
#define SWIGTYPE_p_wxPyValidator swig_types[124]
 
2591
#define SWIGTYPE_p_wxPyWindow swig_types[125]
 
2592
#define SWIGTYPE_p_wxPyWizardPage swig_types[126]
 
2593
#define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[127]
 
2594
#define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[128]
 
2595
#define SWIGTYPE_p_wxRefCounter swig_types[129]
 
2596
#define SWIGTYPE_p_wxSashEvent swig_types[130]
 
2597
#define SWIGTYPE_p_wxSashLayoutWindow swig_types[131]
 
2598
#define SWIGTYPE_p_wxSashWindow swig_types[132]
 
2599
#define SWIGTYPE_p_wxScrollEvent swig_types[133]
 
2600
#define SWIGTYPE_p_wxScrollWinEvent swig_types[134]
 
2601
#define SWIGTYPE_p_wxScrolledWindow swig_types[135]
 
2602
#define SWIGTYPE_p_wxSetCursorEvent swig_types[136]
 
2603
#define SWIGTYPE_p_wxShowEvent swig_types[137]
 
2604
#define SWIGTYPE_p_wxSimpleHtmlListBox swig_types[138]
 
2605
#define SWIGTYPE_p_wxSingleChoiceDialog swig_types[139]
 
2606
#define SWIGTYPE_p_wxSize swig_types[140]
 
2607
#define SWIGTYPE_p_wxSizeEvent swig_types[141]
 
2608
#define SWIGTYPE_p_wxSizer swig_types[142]
 
2609
#define SWIGTYPE_p_wxSizerItem swig_types[143]
 
2610
#define SWIGTYPE_p_wxSplashScreen swig_types[144]
 
2611
#define SWIGTYPE_p_wxSplashScreenWindow swig_types[145]
 
2612
#define SWIGTYPE_p_wxSplitterEvent swig_types[146]
 
2613
#define SWIGTYPE_p_wxSplitterWindow swig_types[147]
 
2614
#define SWIGTYPE_p_wxStandardDialogLayoutAdapter swig_types[148]
 
2615
#define SWIGTYPE_p_wxStaticBoxSizer swig_types[149]
 
2616
#define SWIGTYPE_p_wxStatusBar swig_types[150]
 
2617
#define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[151]
 
2618
#define SWIGTYPE_p_wxSysColourChangedEvent swig_types[152]
 
2619
#define SWIGTYPE_p_wxTGAHandler swig_types[153]
 
2620
#define SWIGTYPE_p_wxTIFFHandler swig_types[154]
 
2621
#define SWIGTYPE_p_wxTaskBarIconEvent swig_types[155]
 
2622
#define SWIGTYPE_p_wxTextCtrlBase swig_types[156]
 
2623
#define SWIGTYPE_p_wxTextEntryDialog swig_types[157]
 
2624
#define SWIGTYPE_p_wxThreadEvent swig_types[158]
 
2625
#define SWIGTYPE_p_wxTipWindow swig_types[159]
 
2626
#define SWIGTYPE_p_wxTopLevelWindow swig_types[160]
 
2627
#define SWIGTYPE_p_wxUpdateUIEvent swig_types[161]
 
2628
#define SWIGTYPE_p_wxValidator swig_types[162]
 
2629
#define SWIGTYPE_p_wxVisualAttributes swig_types[163]
 
2630
#define SWIGTYPE_p_wxWindow swig_types[164]
 
2631
#define SWIGTYPE_p_wxWindowCreateEvent swig_types[165]
 
2632
#define SWIGTYPE_p_wxWindowDestroyEvent swig_types[166]
 
2633
#define SWIGTYPE_p_wxWindowModalDialogEvent swig_types[167]
 
2634
#define SWIGTYPE_p_wxWizard swig_types[168]
 
2635
#define SWIGTYPE_p_wxWizardEvent swig_types[169]
 
2636
#define SWIGTYPE_p_wxWizardPage swig_types[170]
 
2637
#define SWIGTYPE_p_wxWizardPageSimple swig_types[171]
 
2638
#define SWIGTYPE_p_wxWrapSizer swig_types[172]
 
2639
#define SWIGTYPE_p_wxXPMHandler swig_types[173]
 
2640
static swig_type_info *swig_types[175];
 
2641
static swig_module_info swig_module = {swig_types, 174, 0, 0, 0, 0};
 
2642
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 
2643
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
2644
 
 
2645
/* -------- TYPES TABLE (END) -------- */
 
2646
 
 
2647
#if (PY_VERSION_HEX <= 0x02000000)
 
2648
# if !defined(SWIG_PYTHON_CLASSIC)
 
2649
#  error "This python version requires to use swig with the '-classic' option"
 
2650
# endif
 
2651
#endif
 
2652
#if (PY_VERSION_HEX <= 0x02020000)
 
2653
# error "This python version requires to use swig with the '-nomodern' option"
 
2654
#endif
 
2655
#if (PY_VERSION_HEX <= 0x02020000)
 
2656
# error "This python version requires to use swig with the '-nomodernargs' option"
 
2657
#endif
 
2658
#ifndef METH_O
 
2659
# error "This python version requires to use swig with the '-nofastunpack' option"
 
2660
#endif
 
2661
 
 
2662
/*-----------------------------------------------
 
2663
              @(target):= _wizard.so
 
2664
  ------------------------------------------------*/
 
2665
#define SWIG_init    init_wizard
 
2666
 
 
2667
#define SWIG_name    "_wizard"
 
2668
 
 
2669
#define SWIGVERSION 0x010329 
 
2670
 
 
2671
 
 
2672
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
 
2673
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
 
2674
 
 
2675
 
 
2676
#include <stdexcept>
 
2677
 
 
2678
 
 
2679
namespace swig {
 
2680
  class PyObject_ptr {
 
2681
  protected:
 
2682
    PyObject *_obj;
 
2683
 
 
2684
  public:
 
2685
    PyObject_ptr() :_obj(0)
 
2686
    {
 
2687
    }
 
2688
 
 
2689
    PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
 
2690
    {
 
2691
      Py_XINCREF(_obj);      
 
2692
    }
 
2693
    
 
2694
    PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
 
2695
    {
 
2696
      if (initial_ref) Py_XINCREF(_obj);
 
2697
    }
 
2698
    
 
2699
    PyObject_ptr & operator=(const PyObject_ptr& item) 
 
2700
    {
 
2701
      Py_XINCREF(item._obj);
 
2702
      Py_XDECREF(_obj);
 
2703
      _obj = item._obj;
 
2704
      return *this;      
 
2705
    }
 
2706
    
 
2707
    ~PyObject_ptr() 
 
2708
    {
 
2709
      Py_XDECREF(_obj);
 
2710
    }
 
2711
    
 
2712
    operator PyObject *() const
 
2713
    {
 
2714
      return _obj;
 
2715
    }
 
2716
 
 
2717
    PyObject *operator->() const
 
2718
    {
 
2719
      return _obj;
 
2720
    }
 
2721
  };
 
2722
}
 
2723
 
 
2724
 
 
2725
namespace swig {
 
2726
  struct PyObject_var : PyObject_ptr {
 
2727
    PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
 
2728
    
 
2729
    PyObject_var & operator = (PyObject* obj)
 
2730
    {
 
2731
      Py_XDECREF(_obj);
 
2732
      _obj = obj;
 
2733
      return *this;      
 
2734
    }
 
2735
  };
 
2736
}
 
2737
 
 
2738
 
 
2739
#include "wx/wxPython/wxPython.h"
 
2740
#include "wx/wxPython/pyclasses.h"
 
2741
#include "wx/wxPython/printfw.h"
 
2742
 
 
2743
#include <wx/wizard.h>
 
2744
 
 
2745
 
 
2746
 static const wxString wxPyEmptyString(wxEmptyString); 
 
2747
 
 
2748
  #define SWIG_From_long   PyInt_FromLong 
 
2749
 
 
2750
 
 
2751
SWIGINTERNINLINE PyObject *
 
2752
SWIG_From_int  (int value)
 
2753
{    
 
2754
  return SWIG_From_long  (value);
 
2755
}
 
2756
 
 
2757
 
 
2758
#include <limits.h>
 
2759
#ifndef LLONG_MIN
 
2760
# define LLONG_MIN      LONG_LONG_MIN
 
2761
#endif
 
2762
#ifndef LLONG_MAX
 
2763
# define LLONG_MAX      LONG_LONG_MAX
 
2764
#endif
 
2765
#ifndef ULLONG_MAX
 
2766
# define ULLONG_MAX     ULONG_LONG_MAX
 
2767
#endif
 
2768
 
 
2769
 
 
2770
SWIGINTERN int
 
2771
SWIG_AsVal_long (PyObject* obj, long* val)
 
2772
{
 
2773
    if (PyNumber_Check(obj)) {
 
2774
        if (val) *val = PyInt_AsLong(obj);
 
2775
        return SWIG_OK;
 
2776
    }
 
2777
    return SWIG_TypeError;
 
2778
}
 
2779
 
 
2780
 
 
2781
SWIGINTERN int
 
2782
SWIG_AsVal_int (PyObject * obj, int *val)
 
2783
{
 
2784
  long v;
 
2785
  int res = SWIG_AsVal_long (obj, &v);
 
2786
  if (SWIG_IsOK(res)) {
 
2787
    if ((v < INT_MIN || v > INT_MAX)) {
 
2788
      return SWIG_OverflowError;
 
2789
    } else {
 
2790
      if (val) *val = static_cast< int >(v);
 
2791
    }
 
2792
  }  
 
2793
  return res;
 
2794
}
 
2795
 
 
2796
 
 
2797
SWIGINTERN int
 
2798
SWIG_AsVal_bool (PyObject *obj, bool *val)
 
2799
{
 
2800
  if (obj == Py_True) {
 
2801
    if (val) *val = true;
 
2802
    return SWIG_OK;
 
2803
  } else if (obj == Py_False) {
 
2804
    if (val) *val = false;
 
2805
    return SWIG_OK;
 
2806
  } else {
 
2807
    long v = 0;
 
2808
    int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
 
2809
    if (SWIG_IsOK(res) && val) *val = v ? true : false;
 
2810
    return res;
 
2811
  }
 
2812
}
 
2813
 
 
2814
  // C++ Version of a Python aware class
 
2815
class wxPyWizardPage : public wxWizardPage {
 
2816
    DECLARE_ABSTRACT_CLASS(wxPyWizardPage)
 
2817
public:
 
2818
    wxPyWizardPage() : wxWizardPage() {}
 
2819
    wxPyWizardPage(wxWizard *parent,
 
2820
                   const wxBitmap& bitmap = wxNullBitmap)
 
2821
        : wxWizardPage(parent, bitmap) {}
 
2822
 
 
2823
    DEC_PYCALLBACK_WIZPG__pure(GetPrev);
 
2824
    DEC_PYCALLBACK_WIZPG__pure(GetNext);
 
2825
    DEC_PYCALLBACK_BITMAP__pure(GetBitmap);
 
2826
 
 
2827
    DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
 
2828
    DEC_PYCALLBACK_VOID_INT5(DoSetSize);
 
2829
    DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
 
2830
    DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
 
2831
 
 
2832
    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
 
2833
    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
 
2834
    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
 
2835
 
 
2836
    DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
 
2837
    DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
 
2838
 
 
2839
    DEC_PYCALLBACK__(InitDialog);
 
2840
    DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
 
2841
    DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
 
2842
    DEC_PYCALLBACK_BOOL_(Validate);
 
2843
 
 
2844
    DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
 
2845
    DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
 
2846
    DEC_PYCALLBACK_SIZE_const(GetMaxSize);
 
2847
 
 
2848
    DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
 
2849
    DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
 
2850
 
 
2851
    PYPRIVATE;
 
2852
};
 
2853
 
 
2854
 
 
2855
IMPLEMENT_ABSTRACT_CLASS(wxPyWizardPage, wxWizardPage);
 
2856
 
 
2857
IMP_PYCALLBACK_WIZPG__pure(wxPyWizardPage, wxWizardPage, GetPrev);
 
2858
IMP_PYCALLBACK_WIZPG__pure(wxPyWizardPage, wxWizardPage, GetNext);
 
2859
IMP_PYCALLBACK_BITMAP__pure(wxPyWizardPage, wxWizardPage, GetBitmap);
 
2860
 
 
2861
IMP_PYCALLBACK_VOID_INT4(wxPyWizardPage, wxWizardPage, DoMoveWindow);
 
2862
IMP_PYCALLBACK_VOID_INT5(wxPyWizardPage, wxWizardPage, DoSetSize);
 
2863
IMP_PYCALLBACK_VOID_INTINT(wxPyWizardPage, wxWizardPage, DoSetClientSize);
 
2864
IMP_PYCALLBACK_VOID_INTINT(wxPyWizardPage, wxWizardPage, DoSetVirtualSize);
 
2865
 
 
2866
IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWizardPage, wxWizardPage, DoGetSize);
 
2867
IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWizardPage, wxWizardPage, DoGetClientSize);
 
2868
IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWizardPage, wxWizardPage, DoGetPosition);
 
2869
 
 
2870
IMP_PYCALLBACK_SIZE_const(wxPyWizardPage, wxWizardPage, DoGetVirtualSize);
 
2871
IMP_PYCALLBACK_SIZE_const(wxPyWizardPage, wxWizardPage, DoGetBestSize);
 
2872
 
 
2873
IMP_PYCALLBACK__(wxPyWizardPage, wxWizardPage, InitDialog);
 
2874
IMP_PYCALLBACK_BOOL_(wxPyWizardPage, wxWizardPage, TransferDataFromWindow);
 
2875
IMP_PYCALLBACK_BOOL_(wxPyWizardPage, wxWizardPage, TransferDataToWindow);
 
2876
IMP_PYCALLBACK_BOOL_(wxPyWizardPage, wxWizardPage, Validate);
 
2877
 
 
2878
IMP_PYCALLBACK_BOOL_const(wxPyWizardPage, wxWizardPage, AcceptsFocus);
 
2879
IMP_PYCALLBACK_BOOL_const(wxPyWizardPage, wxWizardPage, AcceptsFocusFromKeyboard);
 
2880
IMP_PYCALLBACK_SIZE_const(wxPyWizardPage, wxWizardPage, GetMaxSize);
 
2881
 
 
2882
IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWizardPage, wxWizardPage, AddChild);
 
2883
IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWizardPage, wxWizardPage, RemoveChild);
 
2884
 
 
2885
 
 
2886
#ifdef __cplusplus
 
2887
extern "C" {
 
2888
#endif
 
2889
SWIGINTERN PyObject *_wrap_new_WizardEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
2890
  PyObject *resultobj = 0;
 
2891
  wxEventType arg1 = (wxEventType) wxEVT_NULL ;
 
2892
  int arg2 = (int) -1 ;
 
2893
  bool arg3 = (bool) true ;
 
2894
  wxWizardPage *arg4 = (wxWizardPage *) NULL ;
 
2895
  wxWizardEvent *result = 0 ;
 
2896
  int val1 ;
 
2897
  int ecode1 = 0 ;
 
2898
  int val2 ;
 
2899
  int ecode2 = 0 ;
 
2900
  bool val3 ;
 
2901
  int ecode3 = 0 ;
 
2902
  void *argp4 = 0 ;
 
2903
  int res4 = 0 ;
 
2904
  PyObject * obj0 = 0 ;
 
2905
  PyObject * obj1 = 0 ;
 
2906
  PyObject * obj2 = 0 ;
 
2907
  PyObject * obj3 = 0 ;
 
2908
  char *  kwnames[] = {
 
2909
    (char *) "type",(char *) "id",(char *) "direction",(char *) "page", NULL 
 
2910
  };
 
2911
  
 
2912
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_WizardEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
2913
  if (obj0) {
 
2914
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
2915
    if (!SWIG_IsOK(ecode1)) {
 
2916
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_WizardEvent" "', expected argument " "1"" of type '" "wxEventType""'");
 
2917
    } 
 
2918
    arg1 = static_cast< wxEventType >(val1);
 
2919
  }
 
2920
  if (obj1) {
 
2921
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
2922
    if (!SWIG_IsOK(ecode2)) {
 
2923
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_WizardEvent" "', expected argument " "2"" of type '" "int""'");
 
2924
    } 
 
2925
    arg2 = static_cast< int >(val2);
 
2926
  }
 
2927
  if (obj2) {
 
2928
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
2929
    if (!SWIG_IsOK(ecode3)) {
 
2930
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_WizardEvent" "', expected argument " "3"" of type '" "bool""'");
 
2931
    } 
 
2932
    arg3 = static_cast< bool >(val3);
 
2933
  }
 
2934
  if (obj3) {
 
2935
    res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
2936
    if (!SWIG_IsOK(res4)) {
 
2937
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_WizardEvent" "', expected argument " "4"" of type '" "wxWizardPage *""'"); 
 
2938
    }
 
2939
    arg4 = reinterpret_cast< wxWizardPage * >(argp4);
 
2940
  }
 
2941
  {
 
2942
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
2943
    result = (wxWizardEvent *)new wxWizardEvent(arg1,arg2,arg3,arg4);
 
2944
    wxPyEndAllowThreads(__tstate);
 
2945
    if (PyErr_Occurred()) SWIG_fail;
 
2946
  }
 
2947
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWizardEvent, SWIG_POINTER_NEW |  0 );
 
2948
  return resultobj;
 
2949
fail:
 
2950
  return NULL;
 
2951
}
 
2952
 
 
2953
 
 
2954
SWIGINTERN PyObject *_wrap_WizardEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
2955
  PyObject *resultobj = 0;
 
2956
  wxWizardEvent *arg1 = (wxWizardEvent *) 0 ;
 
2957
  bool result;
 
2958
  void *argp1 = 0 ;
 
2959
  int res1 = 0 ;
 
2960
  PyObject *swig_obj[1] ;
 
2961
  
 
2962
  if (!args) SWIG_fail;
 
2963
  swig_obj[0] = args;
 
2964
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizardEvent, 0 |  0 );
 
2965
  if (!SWIG_IsOK(res1)) {
 
2966
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WizardEvent_GetDirection" "', expected argument " "1"" of type '" "wxWizardEvent const *""'"); 
 
2967
  }
 
2968
  arg1 = reinterpret_cast< wxWizardEvent * >(argp1);
 
2969
  {
 
2970
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
2971
    result = (bool)((wxWizardEvent const *)arg1)->GetDirection();
 
2972
    wxPyEndAllowThreads(__tstate);
 
2973
    if (PyErr_Occurred()) SWIG_fail;
 
2974
  }
 
2975
  {
 
2976
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
2977
  }
 
2978
  return resultobj;
 
2979
fail:
 
2980
  return NULL;
 
2981
}
 
2982
 
 
2983
 
 
2984
SWIGINTERN PyObject *_wrap_WizardEvent_GetPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
2985
  PyObject *resultobj = 0;
 
2986
  wxWizardEvent *arg1 = (wxWizardEvent *) 0 ;
 
2987
  wxWizardPage *result = 0 ;
 
2988
  void *argp1 = 0 ;
 
2989
  int res1 = 0 ;
 
2990
  PyObject *swig_obj[1] ;
 
2991
  
 
2992
  if (!args) SWIG_fail;
 
2993
  swig_obj[0] = args;
 
2994
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizardEvent, 0 |  0 );
 
2995
  if (!SWIG_IsOK(res1)) {
 
2996
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WizardEvent_GetPage" "', expected argument " "1"" of type '" "wxWizardEvent const *""'"); 
 
2997
  }
 
2998
  arg1 = reinterpret_cast< wxWizardEvent * >(argp1);
 
2999
  {
 
3000
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3001
    result = (wxWizardPage *)((wxWizardEvent const *)arg1)->GetPage();
 
3002
    wxPyEndAllowThreads(__tstate);
 
3003
    if (PyErr_Occurred()) SWIG_fail;
 
3004
  }
 
3005
  {
 
3006
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
3007
  }
 
3008
  return resultobj;
 
3009
fail:
 
3010
  return NULL;
 
3011
}
 
3012
 
 
3013
 
 
3014
SWIGINTERN PyObject *WizardEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3015
  PyObject *obj;
 
3016
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
3017
  SWIG_TypeNewClientData(SWIGTYPE_p_wxWizardEvent, SWIG_NewClientData(obj));
 
3018
  return SWIG_Py_Void();
 
3019
}
 
3020
 
 
3021
SWIGINTERN PyObject *WizardEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3022
  return SWIG_Python_InitShadowInstance(args);
 
3023
}
 
3024
 
 
3025
SWIGINTERN PyObject *_wrap_WizardPage_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3026
  PyObject *resultobj = 0;
 
3027
  wxWizardPage *arg1 = (wxWizardPage *) 0 ;
 
3028
  wxWizard *arg2 = (wxWizard *) 0 ;
 
3029
  wxBitmap const &arg3_defvalue = wxNullBitmap ;
 
3030
  wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
 
3031
  bool result;
 
3032
  void *argp1 = 0 ;
 
3033
  int res1 = 0 ;
 
3034
  void *argp2 = 0 ;
 
3035
  int res2 = 0 ;
 
3036
  void *argp3 = 0 ;
 
3037
  int res3 = 0 ;
 
3038
  PyObject * obj0 = 0 ;
 
3039
  PyObject * obj1 = 0 ;
 
3040
  PyObject * obj2 = 0 ;
 
3041
  char *  kwnames[] = {
 
3042
    (char *) "self",(char *) "parent",(char *) "bitmap", NULL 
 
3043
  };
 
3044
  
 
3045
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:WizardPage_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
3046
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
3047
  if (!SWIG_IsOK(res1)) {
 
3048
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WizardPage_Create" "', expected argument " "1"" of type '" "wxWizardPage *""'"); 
 
3049
  }
 
3050
  arg1 = reinterpret_cast< wxWizardPage * >(argp1);
 
3051
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizard, 0 |  0 );
 
3052
  if (!SWIG_IsOK(res2)) {
 
3053
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WizardPage_Create" "', expected argument " "2"" of type '" "wxWizard *""'"); 
 
3054
  }
 
3055
  arg2 = reinterpret_cast< wxWizard * >(argp2);
 
3056
  if (obj2) {
 
3057
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3058
    if (!SWIG_IsOK(res3)) {
 
3059
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WizardPage_Create" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
3060
    }
 
3061
    if (!argp3) {
 
3062
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WizardPage_Create" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
3063
    }
 
3064
    arg3 = reinterpret_cast< wxBitmap * >(argp3);
 
3065
  }
 
3066
  {
 
3067
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3068
    result = (bool)(arg1)->Create(arg2,(wxBitmap const &)*arg3);
 
3069
    wxPyEndAllowThreads(__tstate);
 
3070
    if (PyErr_Occurred()) SWIG_fail;
 
3071
  }
 
3072
  {
 
3073
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
3074
  }
 
3075
  return resultobj;
 
3076
fail:
 
3077
  return NULL;
 
3078
}
 
3079
 
 
3080
 
 
3081
SWIGINTERN PyObject *_wrap_WizardPage_GetPrev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3082
  PyObject *resultobj = 0;
 
3083
  wxWizardPage *arg1 = (wxWizardPage *) 0 ;
 
3084
  wxWizardPage *result = 0 ;
 
3085
  void *argp1 = 0 ;
 
3086
  int res1 = 0 ;
 
3087
  PyObject *swig_obj[1] ;
 
3088
  
 
3089
  if (!args) SWIG_fail;
 
3090
  swig_obj[0] = args;
 
3091
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
3092
  if (!SWIG_IsOK(res1)) {
 
3093
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WizardPage_GetPrev" "', expected argument " "1"" of type '" "wxWizardPage const *""'"); 
 
3094
  }
 
3095
  arg1 = reinterpret_cast< wxWizardPage * >(argp1);
 
3096
  {
 
3097
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3098
    result = (wxWizardPage *)((wxWizardPage const *)arg1)->GetPrev();
 
3099
    wxPyEndAllowThreads(__tstate);
 
3100
    if (PyErr_Occurred()) SWIG_fail;
 
3101
  }
 
3102
  {
 
3103
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
3104
  }
 
3105
  return resultobj;
 
3106
fail:
 
3107
  return NULL;
 
3108
}
 
3109
 
 
3110
 
 
3111
SWIGINTERN PyObject *_wrap_WizardPage_GetNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3112
  PyObject *resultobj = 0;
 
3113
  wxWizardPage *arg1 = (wxWizardPage *) 0 ;
 
3114
  wxWizardPage *result = 0 ;
 
3115
  void *argp1 = 0 ;
 
3116
  int res1 = 0 ;
 
3117
  PyObject *swig_obj[1] ;
 
3118
  
 
3119
  if (!args) SWIG_fail;
 
3120
  swig_obj[0] = args;
 
3121
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
3122
  if (!SWIG_IsOK(res1)) {
 
3123
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WizardPage_GetNext" "', expected argument " "1"" of type '" "wxWizardPage const *""'"); 
 
3124
  }
 
3125
  arg1 = reinterpret_cast< wxWizardPage * >(argp1);
 
3126
  {
 
3127
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3128
    result = (wxWizardPage *)((wxWizardPage const *)arg1)->GetNext();
 
3129
    wxPyEndAllowThreads(__tstate);
 
3130
    if (PyErr_Occurred()) SWIG_fail;
 
3131
  }
 
3132
  {
 
3133
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
3134
  }
 
3135
  return resultobj;
 
3136
fail:
 
3137
  return NULL;
 
3138
}
 
3139
 
 
3140
 
 
3141
SWIGINTERN PyObject *_wrap_WizardPage_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3142
  PyObject *resultobj = 0;
 
3143
  wxWizardPage *arg1 = (wxWizardPage *) 0 ;
 
3144
  wxBitmap result;
 
3145
  void *argp1 = 0 ;
 
3146
  int res1 = 0 ;
 
3147
  PyObject *swig_obj[1] ;
 
3148
  
 
3149
  if (!args) SWIG_fail;
 
3150
  swig_obj[0] = args;
 
3151
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
3152
  if (!SWIG_IsOK(res1)) {
 
3153
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WizardPage_GetBitmap" "', expected argument " "1"" of type '" "wxWizardPage const *""'"); 
 
3154
  }
 
3155
  arg1 = reinterpret_cast< wxWizardPage * >(argp1);
 
3156
  {
 
3157
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3158
    result = ((wxWizardPage const *)arg1)->GetBitmap();
 
3159
    wxPyEndAllowThreads(__tstate);
 
3160
    if (PyErr_Occurred()) SWIG_fail;
 
3161
  }
 
3162
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
3163
  return resultobj;
 
3164
fail:
 
3165
  return NULL;
 
3166
}
 
3167
 
 
3168
 
 
3169
SWIGINTERN PyObject *WizardPage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3170
  PyObject *obj;
 
3171
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
3172
  SWIG_TypeNewClientData(SWIGTYPE_p_wxWizardPage, SWIG_NewClientData(obj));
 
3173
  return SWIG_Py_Void();
 
3174
}
 
3175
 
 
3176
SWIGINTERN PyObject *_wrap_new_PyWizardPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3177
  PyObject *resultobj = 0;
 
3178
  wxWizard *arg1 = (wxWizard *) 0 ;
 
3179
  wxBitmap const &arg2_defvalue = wxNullBitmap ;
 
3180
  wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
 
3181
  wxPyWizardPage *result = 0 ;
 
3182
  void *argp1 = 0 ;
 
3183
  int res1 = 0 ;
 
3184
  void *argp2 = 0 ;
 
3185
  int res2 = 0 ;
 
3186
  PyObject * obj0 = 0 ;
 
3187
  PyObject * obj1 = 0 ;
 
3188
  char *  kwnames[] = {
 
3189
    (char *) "parent",(char *) "bitmap", NULL 
 
3190
  };
 
3191
  
 
3192
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_PyWizardPage",kwnames,&obj0,&obj1)) SWIG_fail;
 
3193
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
3194
  if (!SWIG_IsOK(res1)) {
 
3195
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyWizardPage" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
3196
  }
 
3197
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
3198
  if (obj1) {
 
3199
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3200
    if (!SWIG_IsOK(res2)) {
 
3201
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PyWizardPage" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3202
    }
 
3203
    if (!argp2) {
 
3204
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyWizardPage" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3205
    }
 
3206
    arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
3207
  }
 
3208
  {
 
3209
    if (!wxPyCheckForApp()) SWIG_fail;
 
3210
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3211
    result = (wxPyWizardPage *)new wxPyWizardPage(arg1,(wxBitmap const &)*arg2);
 
3212
    wxPyEndAllowThreads(__tstate);
 
3213
    if (PyErr_Occurred()) SWIG_fail;
 
3214
  }
 
3215
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyWizardPage, SWIG_POINTER_NEW |  0 );
 
3216
  return resultobj;
 
3217
fail:
 
3218
  return NULL;
 
3219
}
 
3220
 
 
3221
 
 
3222
SWIGINTERN PyObject *_wrap_new_PrePyWizardPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3223
  PyObject *resultobj = 0;
 
3224
  wxPyWizardPage *result = 0 ;
 
3225
  
 
3226
  if (!SWIG_Python_UnpackTuple(args,"new_PrePyWizardPage",0,0,0)) SWIG_fail;
 
3227
  {
 
3228
    if (!wxPyCheckForApp()) SWIG_fail;
 
3229
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3230
    result = (wxPyWizardPage *)new wxPyWizardPage();
 
3231
    wxPyEndAllowThreads(__tstate);
 
3232
    if (PyErr_Occurred()) SWIG_fail;
 
3233
  }
 
3234
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyWizardPage, SWIG_POINTER_OWN |  0 );
 
3235
  return resultobj;
 
3236
fail:
 
3237
  return NULL;
 
3238
}
 
3239
 
 
3240
 
 
3241
SWIGINTERN PyObject *_wrap_PyWizardPage_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3242
  PyObject *resultobj = 0;
 
3243
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3244
  wxWizard *arg2 = (wxWizard *) 0 ;
 
3245
  wxBitmap const &arg3_defvalue = wxNullBitmap ;
 
3246
  wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
 
3247
  bool result;
 
3248
  void *argp1 = 0 ;
 
3249
  int res1 = 0 ;
 
3250
  void *argp2 = 0 ;
 
3251
  int res2 = 0 ;
 
3252
  void *argp3 = 0 ;
 
3253
  int res3 = 0 ;
 
3254
  PyObject * obj0 = 0 ;
 
3255
  PyObject * obj1 = 0 ;
 
3256
  PyObject * obj2 = 0 ;
 
3257
  char *  kwnames[] = {
 
3258
    (char *) "self",(char *) "parent",(char *) "bitmap", NULL 
 
3259
  };
 
3260
  
 
3261
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyWizardPage_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
3262
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3263
  if (!SWIG_IsOK(res1)) {
 
3264
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_Create" "', expected argument " "1"" of type '" "wxPyWizardPage *""'"); 
 
3265
  }
 
3266
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3267
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizard, 0 |  0 );
 
3268
  if (!SWIG_IsOK(res2)) {
 
3269
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyWizardPage_Create" "', expected argument " "2"" of type '" "wxWizard *""'"); 
 
3270
  }
 
3271
  arg2 = reinterpret_cast< wxWizard * >(argp2);
 
3272
  if (obj2) {
 
3273
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3274
    if (!SWIG_IsOK(res3)) {
 
3275
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyWizardPage_Create" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
3276
    }
 
3277
    if (!argp3) {
 
3278
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyWizardPage_Create" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
3279
    }
 
3280
    arg3 = reinterpret_cast< wxBitmap * >(argp3);
 
3281
  }
 
3282
  {
 
3283
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3284
    result = (bool)(arg1)->Create(arg2,(wxBitmap const &)*arg3);
 
3285
    wxPyEndAllowThreads(__tstate);
 
3286
    if (PyErr_Occurred()) SWIG_fail;
 
3287
  }
 
3288
  {
 
3289
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
3290
  }
 
3291
  return resultobj;
 
3292
fail:
 
3293
  return NULL;
 
3294
}
 
3295
 
 
3296
 
 
3297
SWIGINTERN PyObject *_wrap_PyWizardPage__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3298
  PyObject *resultobj = 0;
 
3299
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3300
  PyObject *arg2 = (PyObject *) 0 ;
 
3301
  PyObject *arg3 = (PyObject *) 0 ;
 
3302
  void *argp1 = 0 ;
 
3303
  int res1 = 0 ;
 
3304
  PyObject * obj0 = 0 ;
 
3305
  PyObject * obj1 = 0 ;
 
3306
  PyObject * obj2 = 0 ;
 
3307
  char *  kwnames[] = {
 
3308
    (char *) "self",(char *) "self",(char *) "_class", NULL 
 
3309
  };
 
3310
  
 
3311
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWizardPage__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
3312
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3313
  if (!SWIG_IsOK(res1)) {
 
3314
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyWizardPage *""'"); 
 
3315
  }
 
3316
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3317
  arg2 = obj1;
 
3318
  arg3 = obj2;
 
3319
  {
 
3320
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3321
    (arg1)->_setCallbackInfo(arg2,arg3);
 
3322
    wxPyEndAllowThreads(__tstate);
 
3323
    if (PyErr_Occurred()) SWIG_fail;
 
3324
  }
 
3325
  resultobj = SWIG_Py_Void();
 
3326
  return resultobj;
 
3327
fail:
 
3328
  return NULL;
 
3329
}
 
3330
 
 
3331
 
 
3332
SWIGINTERN PyObject *_wrap_PyWizardPage_DoMoveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3333
  PyObject *resultobj = 0;
 
3334
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3335
  int arg2 ;
 
3336
  int arg3 ;
 
3337
  int arg4 ;
 
3338
  int arg5 ;
 
3339
  void *argp1 = 0 ;
 
3340
  int res1 = 0 ;
 
3341
  int val2 ;
 
3342
  int ecode2 = 0 ;
 
3343
  int val3 ;
 
3344
  int ecode3 = 0 ;
 
3345
  int val4 ;
 
3346
  int ecode4 = 0 ;
 
3347
  int val5 ;
 
3348
  int ecode5 = 0 ;
 
3349
  PyObject * obj0 = 0 ;
 
3350
  PyObject * obj1 = 0 ;
 
3351
  PyObject * obj2 = 0 ;
 
3352
  PyObject * obj3 = 0 ;
 
3353
  PyObject * obj4 = 0 ;
 
3354
  char *  kwnames[] = {
 
3355
    (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL 
 
3356
  };
 
3357
  
 
3358
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyWizardPage_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
3359
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3360
  if (!SWIG_IsOK(res1)) {
 
3361
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_DoMoveWindow" "', expected argument " "1"" of type '" "wxPyWizardPage *""'"); 
 
3362
  }
 
3363
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3364
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
3365
  if (!SWIG_IsOK(ecode2)) {
 
3366
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyWizardPage_DoMoveWindow" "', expected argument " "2"" of type '" "int""'");
 
3367
  } 
 
3368
  arg2 = static_cast< int >(val2);
 
3369
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
3370
  if (!SWIG_IsOK(ecode3)) {
 
3371
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyWizardPage_DoMoveWindow" "', expected argument " "3"" of type '" "int""'");
 
3372
  } 
 
3373
  arg3 = static_cast< int >(val3);
 
3374
  ecode4 = SWIG_AsVal_int(obj3, &val4);
 
3375
  if (!SWIG_IsOK(ecode4)) {
 
3376
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyWizardPage_DoMoveWindow" "', expected argument " "4"" of type '" "int""'");
 
3377
  } 
 
3378
  arg4 = static_cast< int >(val4);
 
3379
  ecode5 = SWIG_AsVal_int(obj4, &val5);
 
3380
  if (!SWIG_IsOK(ecode5)) {
 
3381
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PyWizardPage_DoMoveWindow" "', expected argument " "5"" of type '" "int""'");
 
3382
  } 
 
3383
  arg5 = static_cast< int >(val5);
 
3384
  {
 
3385
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3386
    (arg1)->DoMoveWindow(arg2,arg3,arg4,arg5);
 
3387
    wxPyEndAllowThreads(__tstate);
 
3388
    if (PyErr_Occurred()) SWIG_fail;
 
3389
  }
 
3390
  resultobj = SWIG_Py_Void();
 
3391
  return resultobj;
 
3392
fail:
 
3393
  return NULL;
 
3394
}
 
3395
 
 
3396
 
 
3397
SWIGINTERN PyObject *_wrap_PyWizardPage_DoSetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3398
  PyObject *resultobj = 0;
 
3399
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3400
  int arg2 ;
 
3401
  int arg3 ;
 
3402
  int arg4 ;
 
3403
  int arg5 ;
 
3404
  int arg6 = (int) wxSIZE_AUTO ;
 
3405
  void *argp1 = 0 ;
 
3406
  int res1 = 0 ;
 
3407
  int val2 ;
 
3408
  int ecode2 = 0 ;
 
3409
  int val3 ;
 
3410
  int ecode3 = 0 ;
 
3411
  int val4 ;
 
3412
  int ecode4 = 0 ;
 
3413
  int val5 ;
 
3414
  int ecode5 = 0 ;
 
3415
  int val6 ;
 
3416
  int ecode6 = 0 ;
 
3417
  PyObject * obj0 = 0 ;
 
3418
  PyObject * obj1 = 0 ;
 
3419
  PyObject * obj2 = 0 ;
 
3420
  PyObject * obj3 = 0 ;
 
3421
  PyObject * obj4 = 0 ;
 
3422
  PyObject * obj5 = 0 ;
 
3423
  char *  kwnames[] = {
 
3424
    (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL 
 
3425
  };
 
3426
  
 
3427
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyWizardPage_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
3428
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3429
  if (!SWIG_IsOK(res1)) {
 
3430
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_DoSetSize" "', expected argument " "1"" of type '" "wxPyWizardPage *""'"); 
 
3431
  }
 
3432
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3433
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
3434
  if (!SWIG_IsOK(ecode2)) {
 
3435
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyWizardPage_DoSetSize" "', expected argument " "2"" of type '" "int""'");
 
3436
  } 
 
3437
  arg2 = static_cast< int >(val2);
 
3438
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
3439
  if (!SWIG_IsOK(ecode3)) {
 
3440
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyWizardPage_DoSetSize" "', expected argument " "3"" of type '" "int""'");
 
3441
  } 
 
3442
  arg3 = static_cast< int >(val3);
 
3443
  ecode4 = SWIG_AsVal_int(obj3, &val4);
 
3444
  if (!SWIG_IsOK(ecode4)) {
 
3445
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyWizardPage_DoSetSize" "', expected argument " "4"" of type '" "int""'");
 
3446
  } 
 
3447
  arg4 = static_cast< int >(val4);
 
3448
  ecode5 = SWIG_AsVal_int(obj4, &val5);
 
3449
  if (!SWIG_IsOK(ecode5)) {
 
3450
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PyWizardPage_DoSetSize" "', expected argument " "5"" of type '" "int""'");
 
3451
  } 
 
3452
  arg5 = static_cast< int >(val5);
 
3453
  if (obj5) {
 
3454
    ecode6 = SWIG_AsVal_int(obj5, &val6);
 
3455
    if (!SWIG_IsOK(ecode6)) {
 
3456
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PyWizardPage_DoSetSize" "', expected argument " "6"" of type '" "int""'");
 
3457
    } 
 
3458
    arg6 = static_cast< int >(val6);
 
3459
  }
 
3460
  {
 
3461
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3462
    (arg1)->DoSetSize(arg2,arg3,arg4,arg5,arg6);
 
3463
    wxPyEndAllowThreads(__tstate);
 
3464
    if (PyErr_Occurred()) SWIG_fail;
 
3465
  }
 
3466
  resultobj = SWIG_Py_Void();
 
3467
  return resultobj;
 
3468
fail:
 
3469
  return NULL;
 
3470
}
 
3471
 
 
3472
 
 
3473
SWIGINTERN PyObject *_wrap_PyWizardPage_DoSetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3474
  PyObject *resultobj = 0;
 
3475
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3476
  int arg2 ;
 
3477
  int arg3 ;
 
3478
  void *argp1 = 0 ;
 
3479
  int res1 = 0 ;
 
3480
  int val2 ;
 
3481
  int ecode2 = 0 ;
 
3482
  int val3 ;
 
3483
  int ecode3 = 0 ;
 
3484
  PyObject * obj0 = 0 ;
 
3485
  PyObject * obj1 = 0 ;
 
3486
  PyObject * obj2 = 0 ;
 
3487
  char *  kwnames[] = {
 
3488
    (char *) "self",(char *) "width",(char *) "height", NULL 
 
3489
  };
 
3490
  
 
3491
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWizardPage_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
3492
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3493
  if (!SWIG_IsOK(res1)) {
 
3494
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_DoSetClientSize" "', expected argument " "1"" of type '" "wxPyWizardPage *""'"); 
 
3495
  }
 
3496
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3497
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
3498
  if (!SWIG_IsOK(ecode2)) {
 
3499
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyWizardPage_DoSetClientSize" "', expected argument " "2"" of type '" "int""'");
 
3500
  } 
 
3501
  arg2 = static_cast< int >(val2);
 
3502
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
3503
  if (!SWIG_IsOK(ecode3)) {
 
3504
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyWizardPage_DoSetClientSize" "', expected argument " "3"" of type '" "int""'");
 
3505
  } 
 
3506
  arg3 = static_cast< int >(val3);
 
3507
  {
 
3508
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3509
    (arg1)->DoSetClientSize(arg2,arg3);
 
3510
    wxPyEndAllowThreads(__tstate);
 
3511
    if (PyErr_Occurred()) SWIG_fail;
 
3512
  }
 
3513
  resultobj = SWIG_Py_Void();
 
3514
  return resultobj;
 
3515
fail:
 
3516
  return NULL;
 
3517
}
 
3518
 
 
3519
 
 
3520
SWIGINTERN PyObject *_wrap_PyWizardPage_DoSetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3521
  PyObject *resultobj = 0;
 
3522
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3523
  int arg2 ;
 
3524
  int arg3 ;
 
3525
  void *argp1 = 0 ;
 
3526
  int res1 = 0 ;
 
3527
  int val2 ;
 
3528
  int ecode2 = 0 ;
 
3529
  int val3 ;
 
3530
  int ecode3 = 0 ;
 
3531
  PyObject * obj0 = 0 ;
 
3532
  PyObject * obj1 = 0 ;
 
3533
  PyObject * obj2 = 0 ;
 
3534
  char *  kwnames[] = {
 
3535
    (char *) "self",(char *) "x",(char *) "y", NULL 
 
3536
  };
 
3537
  
 
3538
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyWizardPage_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
3539
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3540
  if (!SWIG_IsOK(res1)) {
 
3541
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_DoSetVirtualSize" "', expected argument " "1"" of type '" "wxPyWizardPage *""'"); 
 
3542
  }
 
3543
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3544
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
3545
  if (!SWIG_IsOK(ecode2)) {
 
3546
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyWizardPage_DoSetVirtualSize" "', expected argument " "2"" of type '" "int""'");
 
3547
  } 
 
3548
  arg2 = static_cast< int >(val2);
 
3549
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
3550
  if (!SWIG_IsOK(ecode3)) {
 
3551
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyWizardPage_DoSetVirtualSize" "', expected argument " "3"" of type '" "int""'");
 
3552
  } 
 
3553
  arg3 = static_cast< int >(val3);
 
3554
  {
 
3555
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3556
    (arg1)->DoSetVirtualSize(arg2,arg3);
 
3557
    wxPyEndAllowThreads(__tstate);
 
3558
    if (PyErr_Occurred()) SWIG_fail;
 
3559
  }
 
3560
  resultobj = SWIG_Py_Void();
 
3561
  return resultobj;
 
3562
fail:
 
3563
  return NULL;
 
3564
}
 
3565
 
 
3566
 
 
3567
SWIGINTERN PyObject *_wrap_PyWizardPage_DoGetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3568
  PyObject *resultobj = 0;
 
3569
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3570
  int *arg2 = (int *) 0 ;
 
3571
  int *arg3 = (int *) 0 ;
 
3572
  void *argp1 = 0 ;
 
3573
  int res1 = 0 ;
 
3574
  int temp2 ;
 
3575
  int res2 = SWIG_TMPOBJ ;
 
3576
  int temp3 ;
 
3577
  int res3 = SWIG_TMPOBJ ;
 
3578
  PyObject *swig_obj[1] ;
 
3579
  
 
3580
  arg2 = &temp2;
 
3581
  arg3 = &temp3;
 
3582
  if (!args) SWIG_fail;
 
3583
  swig_obj[0] = args;
 
3584
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3585
  if (!SWIG_IsOK(res1)) {
 
3586
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_DoGetSize" "', expected argument " "1"" of type '" "wxPyWizardPage const *""'"); 
 
3587
  }
 
3588
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3589
  {
 
3590
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3591
    ((wxPyWizardPage const *)arg1)->DoGetSize(arg2,arg3);
 
3592
    wxPyEndAllowThreads(__tstate);
 
3593
    if (PyErr_Occurred()) SWIG_fail;
 
3594
  }
 
3595
  resultobj = SWIG_Py_Void();
 
3596
  if (SWIG_IsTmpObj(res2)) {
 
3597
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
 
3598
  } else {
 
3599
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
3600
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
 
3601
  }
 
3602
  if (SWIG_IsTmpObj(res3)) {
 
3603
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
 
3604
  } else {
 
3605
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
3606
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
 
3607
  }
 
3608
  return resultobj;
 
3609
fail:
 
3610
  return NULL;
 
3611
}
 
3612
 
 
3613
 
 
3614
SWIGINTERN PyObject *_wrap_PyWizardPage_DoGetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3615
  PyObject *resultobj = 0;
 
3616
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3617
  int *arg2 = (int *) 0 ;
 
3618
  int *arg3 = (int *) 0 ;
 
3619
  void *argp1 = 0 ;
 
3620
  int res1 = 0 ;
 
3621
  int temp2 ;
 
3622
  int res2 = SWIG_TMPOBJ ;
 
3623
  int temp3 ;
 
3624
  int res3 = SWIG_TMPOBJ ;
 
3625
  PyObject *swig_obj[1] ;
 
3626
  
 
3627
  arg2 = &temp2;
 
3628
  arg3 = &temp3;
 
3629
  if (!args) SWIG_fail;
 
3630
  swig_obj[0] = args;
 
3631
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3632
  if (!SWIG_IsOK(res1)) {
 
3633
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_DoGetClientSize" "', expected argument " "1"" of type '" "wxPyWizardPage const *""'"); 
 
3634
  }
 
3635
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3636
  {
 
3637
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3638
    ((wxPyWizardPage const *)arg1)->DoGetClientSize(arg2,arg3);
 
3639
    wxPyEndAllowThreads(__tstate);
 
3640
    if (PyErr_Occurred()) SWIG_fail;
 
3641
  }
 
3642
  resultobj = SWIG_Py_Void();
 
3643
  if (SWIG_IsTmpObj(res2)) {
 
3644
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
 
3645
  } else {
 
3646
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
3647
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
 
3648
  }
 
3649
  if (SWIG_IsTmpObj(res3)) {
 
3650
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
 
3651
  } else {
 
3652
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
3653
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
 
3654
  }
 
3655
  return resultobj;
 
3656
fail:
 
3657
  return NULL;
 
3658
}
 
3659
 
 
3660
 
 
3661
SWIGINTERN PyObject *_wrap_PyWizardPage_DoGetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3662
  PyObject *resultobj = 0;
 
3663
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3664
  int *arg2 = (int *) 0 ;
 
3665
  int *arg3 = (int *) 0 ;
 
3666
  void *argp1 = 0 ;
 
3667
  int res1 = 0 ;
 
3668
  int temp2 ;
 
3669
  int res2 = SWIG_TMPOBJ ;
 
3670
  int temp3 ;
 
3671
  int res3 = SWIG_TMPOBJ ;
 
3672
  PyObject *swig_obj[1] ;
 
3673
  
 
3674
  arg2 = &temp2;
 
3675
  arg3 = &temp3;
 
3676
  if (!args) SWIG_fail;
 
3677
  swig_obj[0] = args;
 
3678
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3679
  if (!SWIG_IsOK(res1)) {
 
3680
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_DoGetPosition" "', expected argument " "1"" of type '" "wxPyWizardPage const *""'"); 
 
3681
  }
 
3682
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3683
  {
 
3684
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3685
    ((wxPyWizardPage const *)arg1)->DoGetPosition(arg2,arg3);
 
3686
    wxPyEndAllowThreads(__tstate);
 
3687
    if (PyErr_Occurred()) SWIG_fail;
 
3688
  }
 
3689
  resultobj = SWIG_Py_Void();
 
3690
  if (SWIG_IsTmpObj(res2)) {
 
3691
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
 
3692
  } else {
 
3693
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
3694
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
 
3695
  }
 
3696
  if (SWIG_IsTmpObj(res3)) {
 
3697
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
 
3698
  } else {
 
3699
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
3700
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
 
3701
  }
 
3702
  return resultobj;
 
3703
fail:
 
3704
  return NULL;
 
3705
}
 
3706
 
 
3707
 
 
3708
SWIGINTERN PyObject *_wrap_PyWizardPage_DoGetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3709
  PyObject *resultobj = 0;
 
3710
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3711
  wxSize result;
 
3712
  void *argp1 = 0 ;
 
3713
  int res1 = 0 ;
 
3714
  PyObject *swig_obj[1] ;
 
3715
  
 
3716
  if (!args) SWIG_fail;
 
3717
  swig_obj[0] = args;
 
3718
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3719
  if (!SWIG_IsOK(res1)) {
 
3720
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_DoGetVirtualSize" "', expected argument " "1"" of type '" "wxPyWizardPage const *""'"); 
 
3721
  }
 
3722
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3723
  {
 
3724
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3725
    result = ((wxPyWizardPage const *)arg1)->DoGetVirtualSize();
 
3726
    wxPyEndAllowThreads(__tstate);
 
3727
    if (PyErr_Occurred()) SWIG_fail;
 
3728
  }
 
3729
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
3730
  return resultobj;
 
3731
fail:
 
3732
  return NULL;
 
3733
}
 
3734
 
 
3735
 
 
3736
SWIGINTERN PyObject *_wrap_PyWizardPage_DoGetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3737
  PyObject *resultobj = 0;
 
3738
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3739
  wxSize result;
 
3740
  void *argp1 = 0 ;
 
3741
  int res1 = 0 ;
 
3742
  PyObject *swig_obj[1] ;
 
3743
  
 
3744
  if (!args) SWIG_fail;
 
3745
  swig_obj[0] = args;
 
3746
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3747
  if (!SWIG_IsOK(res1)) {
 
3748
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_DoGetBestSize" "', expected argument " "1"" of type '" "wxPyWizardPage const *""'"); 
 
3749
  }
 
3750
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3751
  {
 
3752
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3753
    result = ((wxPyWizardPage const *)arg1)->DoGetBestSize();
 
3754
    wxPyEndAllowThreads(__tstate);
 
3755
    if (PyErr_Occurred()) SWIG_fail;
 
3756
  }
 
3757
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
3758
  return resultobj;
 
3759
fail:
 
3760
  return NULL;
 
3761
}
 
3762
 
 
3763
 
 
3764
SWIGINTERN PyObject *_wrap_PyWizardPage_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3765
  PyObject *resultobj = 0;
 
3766
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3767
  SwigValueWrapper<wxVisualAttributes > result;
 
3768
  void *argp1 = 0 ;
 
3769
  int res1 = 0 ;
 
3770
  PyObject *swig_obj[1] ;
 
3771
  
 
3772
  if (!args) SWIG_fail;
 
3773
  swig_obj[0] = args;
 
3774
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3775
  if (!SWIG_IsOK(res1)) {
 
3776
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxPyWizardPage *""'"); 
 
3777
  }
 
3778
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3779
  {
 
3780
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3781
    result = (arg1)->GetDefaultAttributes();
 
3782
    wxPyEndAllowThreads(__tstate);
 
3783
    if (PyErr_Occurred()) SWIG_fail;
 
3784
  }
 
3785
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
3786
  return resultobj;
 
3787
fail:
 
3788
  return NULL;
 
3789
}
 
3790
 
 
3791
 
 
3792
SWIGINTERN PyObject *_wrap_PyWizardPage_OnInternalIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3793
  PyObject *resultobj = 0;
 
3794
  wxPyWizardPage *arg1 = (wxPyWizardPage *) 0 ;
 
3795
  void *argp1 = 0 ;
 
3796
  int res1 = 0 ;
 
3797
  PyObject *swig_obj[1] ;
 
3798
  
 
3799
  if (!args) SWIG_fail;
 
3800
  swig_obj[0] = args;
 
3801
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyWizardPage, 0 |  0 );
 
3802
  if (!SWIG_IsOK(res1)) {
 
3803
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyWizardPage_OnInternalIdle" "', expected argument " "1"" of type '" "wxPyWizardPage *""'"); 
 
3804
  }
 
3805
  arg1 = reinterpret_cast< wxPyWizardPage * >(argp1);
 
3806
  {
 
3807
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3808
    (arg1)->OnInternalIdle();
 
3809
    wxPyEndAllowThreads(__tstate);
 
3810
    if (PyErr_Occurred()) SWIG_fail;
 
3811
  }
 
3812
  resultobj = SWIG_Py_Void();
 
3813
  return resultobj;
 
3814
fail:
 
3815
  return NULL;
 
3816
}
 
3817
 
 
3818
 
 
3819
SWIGINTERN PyObject *PyWizardPage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3820
  PyObject *obj;
 
3821
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
3822
  SWIG_TypeNewClientData(SWIGTYPE_p_wxPyWizardPage, SWIG_NewClientData(obj));
 
3823
  return SWIG_Py_Void();
 
3824
}
 
3825
 
 
3826
SWIGINTERN PyObject *PyWizardPage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3827
  return SWIG_Python_InitShadowInstance(args);
 
3828
}
 
3829
 
 
3830
SWIGINTERN PyObject *_wrap_new_WizardPageSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3831
  PyObject *resultobj = 0;
 
3832
  wxWizard *arg1 = (wxWizard *) 0 ;
 
3833
  wxWizardPage *arg2 = (wxWizardPage *) NULL ;
 
3834
  wxWizardPage *arg3 = (wxWizardPage *) NULL ;
 
3835
  wxBitmap const &arg4_defvalue = wxNullBitmap ;
 
3836
  wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
 
3837
  wxWizardPageSimple *result = 0 ;
 
3838
  void *argp1 = 0 ;
 
3839
  int res1 = 0 ;
 
3840
  void *argp2 = 0 ;
 
3841
  int res2 = 0 ;
 
3842
  void *argp3 = 0 ;
 
3843
  int res3 = 0 ;
 
3844
  void *argp4 = 0 ;
 
3845
  int res4 = 0 ;
 
3846
  PyObject * obj0 = 0 ;
 
3847
  PyObject * obj1 = 0 ;
 
3848
  PyObject * obj2 = 0 ;
 
3849
  PyObject * obj3 = 0 ;
 
3850
  char *  kwnames[] = {
 
3851
    (char *) "parent",(char *) "prev",(char *) "next",(char *) "bitmap", NULL 
 
3852
  };
 
3853
  
 
3854
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_WizardPageSimple",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
3855
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
3856
  if (!SWIG_IsOK(res1)) {
 
3857
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WizardPageSimple" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
3858
  }
 
3859
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
3860
  if (obj1) {
 
3861
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
3862
    if (!SWIG_IsOK(res2)) {
 
3863
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_WizardPageSimple" "', expected argument " "2"" of type '" "wxWizardPage *""'"); 
 
3864
    }
 
3865
    arg2 = reinterpret_cast< wxWizardPage * >(argp2);
 
3866
  }
 
3867
  if (obj2) {
 
3868
    res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
3869
    if (!SWIG_IsOK(res3)) {
 
3870
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_WizardPageSimple" "', expected argument " "3"" of type '" "wxWizardPage *""'"); 
 
3871
    }
 
3872
    arg3 = reinterpret_cast< wxWizardPage * >(argp3);
 
3873
  }
 
3874
  if (obj3) {
 
3875
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3876
    if (!SWIG_IsOK(res4)) {
 
3877
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_WizardPageSimple" "', expected argument " "4"" of type '" "wxBitmap const &""'"); 
 
3878
    }
 
3879
    if (!argp4) {
 
3880
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_WizardPageSimple" "', expected argument " "4"" of type '" "wxBitmap const &""'"); 
 
3881
    }
 
3882
    arg4 = reinterpret_cast< wxBitmap * >(argp4);
 
3883
  }
 
3884
  {
 
3885
    if (!wxPyCheckForApp()) SWIG_fail;
 
3886
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3887
    result = (wxWizardPageSimple *)new wxWizardPageSimple(arg1,arg2,arg3,(wxBitmap const &)*arg4);
 
3888
    wxPyEndAllowThreads(__tstate);
 
3889
    if (PyErr_Occurred()) SWIG_fail;
 
3890
  }
 
3891
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWizardPageSimple, SWIG_POINTER_NEW |  0 );
 
3892
  return resultobj;
 
3893
fail:
 
3894
  return NULL;
 
3895
}
 
3896
 
 
3897
 
 
3898
SWIGINTERN PyObject *_wrap_new_PreWizardPageSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3899
  PyObject *resultobj = 0;
 
3900
  wxWizardPageSimple *result = 0 ;
 
3901
  
 
3902
  if (!SWIG_Python_UnpackTuple(args,"new_PreWizardPageSimple",0,0,0)) SWIG_fail;
 
3903
  {
 
3904
    if (!wxPyCheckForApp()) SWIG_fail;
 
3905
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3906
    result = (wxWizardPageSimple *)new wxWizardPageSimple();
 
3907
    wxPyEndAllowThreads(__tstate);
 
3908
    if (PyErr_Occurred()) SWIG_fail;
 
3909
  }
 
3910
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWizardPageSimple, SWIG_POINTER_OWN |  0 );
 
3911
  return resultobj;
 
3912
fail:
 
3913
  return NULL;
 
3914
}
 
3915
 
 
3916
 
 
3917
SWIGINTERN PyObject *_wrap_WizardPageSimple_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3918
  PyObject *resultobj = 0;
 
3919
  wxWizardPageSimple *arg1 = (wxWizardPageSimple *) 0 ;
 
3920
  wxWizard *arg2 = (wxWizard *) NULL ;
 
3921
  wxWizardPage *arg3 = (wxWizardPage *) NULL ;
 
3922
  wxWizardPage *arg4 = (wxWizardPage *) NULL ;
 
3923
  wxBitmap const &arg5_defvalue = wxNullBitmap ;
 
3924
  wxBitmap *arg5 = (wxBitmap *) &arg5_defvalue ;
 
3925
  bool result;
 
3926
  void *argp1 = 0 ;
 
3927
  int res1 = 0 ;
 
3928
  void *argp2 = 0 ;
 
3929
  int res2 = 0 ;
 
3930
  void *argp3 = 0 ;
 
3931
  int res3 = 0 ;
 
3932
  void *argp4 = 0 ;
 
3933
  int res4 = 0 ;
 
3934
  void *argp5 = 0 ;
 
3935
  int res5 = 0 ;
 
3936
  PyObject * obj0 = 0 ;
 
3937
  PyObject * obj1 = 0 ;
 
3938
  PyObject * obj2 = 0 ;
 
3939
  PyObject * obj3 = 0 ;
 
3940
  PyObject * obj4 = 0 ;
 
3941
  char *  kwnames[] = {
 
3942
    (char *) "self",(char *) "parent",(char *) "prev",(char *) "next",(char *) "bitmap", NULL 
 
3943
  };
 
3944
  
 
3945
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:WizardPageSimple_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
3946
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizardPageSimple, 0 |  0 );
 
3947
  if (!SWIG_IsOK(res1)) {
 
3948
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WizardPageSimple_Create" "', expected argument " "1"" of type '" "wxWizardPageSimple *""'"); 
 
3949
  }
 
3950
  arg1 = reinterpret_cast< wxWizardPageSimple * >(argp1);
 
3951
  if (obj1) {
 
3952
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizard, 0 |  0 );
 
3953
    if (!SWIG_IsOK(res2)) {
 
3954
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WizardPageSimple_Create" "', expected argument " "2"" of type '" "wxWizard *""'"); 
 
3955
    }
 
3956
    arg2 = reinterpret_cast< wxWizard * >(argp2);
 
3957
  }
 
3958
  if (obj2) {
 
3959
    res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
3960
    if (!SWIG_IsOK(res3)) {
 
3961
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WizardPageSimple_Create" "', expected argument " "3"" of type '" "wxWizardPage *""'"); 
 
3962
    }
 
3963
    arg3 = reinterpret_cast< wxWizardPage * >(argp3);
 
3964
  }
 
3965
  if (obj3) {
 
3966
    res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
3967
    if (!SWIG_IsOK(res4)) {
 
3968
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "WizardPageSimple_Create" "', expected argument " "4"" of type '" "wxWizardPage *""'"); 
 
3969
    }
 
3970
    arg4 = reinterpret_cast< wxWizardPage * >(argp4);
 
3971
  }
 
3972
  if (obj4) {
 
3973
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3974
    if (!SWIG_IsOK(res5)) {
 
3975
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "WizardPageSimple_Create" "', expected argument " "5"" of type '" "wxBitmap const &""'"); 
 
3976
    }
 
3977
    if (!argp5) {
 
3978
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WizardPageSimple_Create" "', expected argument " "5"" of type '" "wxBitmap const &""'"); 
 
3979
    }
 
3980
    arg5 = reinterpret_cast< wxBitmap * >(argp5);
 
3981
  }
 
3982
  {
 
3983
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3984
    result = (bool)(arg1)->Create(arg2,arg3,arg4,(wxBitmap const &)*arg5);
 
3985
    wxPyEndAllowThreads(__tstate);
 
3986
    if (PyErr_Occurred()) SWIG_fail;
 
3987
  }
 
3988
  {
 
3989
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
3990
  }
 
3991
  return resultobj;
 
3992
fail:
 
3993
  return NULL;
 
3994
}
 
3995
 
 
3996
 
 
3997
SWIGINTERN PyObject *_wrap_WizardPageSimple_SetPrev(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3998
  PyObject *resultobj = 0;
 
3999
  wxWizardPageSimple *arg1 = (wxWizardPageSimple *) 0 ;
 
4000
  wxWizardPage *arg2 = (wxWizardPage *) 0 ;
 
4001
  void *argp1 = 0 ;
 
4002
  int res1 = 0 ;
 
4003
  void *argp2 = 0 ;
 
4004
  int res2 = 0 ;
 
4005
  PyObject * obj0 = 0 ;
 
4006
  PyObject * obj1 = 0 ;
 
4007
  char *  kwnames[] = {
 
4008
    (char *) "self",(char *) "prev", NULL 
 
4009
  };
 
4010
  
 
4011
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:WizardPageSimple_SetPrev",kwnames,&obj0,&obj1)) SWIG_fail;
 
4012
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizardPageSimple, 0 |  0 );
 
4013
  if (!SWIG_IsOK(res1)) {
 
4014
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WizardPageSimple_SetPrev" "', expected argument " "1"" of type '" "wxWizardPageSimple *""'"); 
 
4015
  }
 
4016
  arg1 = reinterpret_cast< wxWizardPageSimple * >(argp1);
 
4017
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
4018
  if (!SWIG_IsOK(res2)) {
 
4019
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WizardPageSimple_SetPrev" "', expected argument " "2"" of type '" "wxWizardPage *""'"); 
 
4020
  }
 
4021
  arg2 = reinterpret_cast< wxWizardPage * >(argp2);
 
4022
  {
 
4023
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4024
    (arg1)->SetPrev(arg2);
 
4025
    wxPyEndAllowThreads(__tstate);
 
4026
    if (PyErr_Occurred()) SWIG_fail;
 
4027
  }
 
4028
  resultobj = SWIG_Py_Void();
 
4029
  return resultobj;
 
4030
fail:
 
4031
  return NULL;
 
4032
}
 
4033
 
 
4034
 
 
4035
SWIGINTERN PyObject *_wrap_WizardPageSimple_SetNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4036
  PyObject *resultobj = 0;
 
4037
  wxWizardPageSimple *arg1 = (wxWizardPageSimple *) 0 ;
 
4038
  wxWizardPage *arg2 = (wxWizardPage *) 0 ;
 
4039
  void *argp1 = 0 ;
 
4040
  int res1 = 0 ;
 
4041
  void *argp2 = 0 ;
 
4042
  int res2 = 0 ;
 
4043
  PyObject * obj0 = 0 ;
 
4044
  PyObject * obj1 = 0 ;
 
4045
  char *  kwnames[] = {
 
4046
    (char *) "self",(char *) "next", NULL 
 
4047
  };
 
4048
  
 
4049
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:WizardPageSimple_SetNext",kwnames,&obj0,&obj1)) SWIG_fail;
 
4050
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizardPageSimple, 0 |  0 );
 
4051
  if (!SWIG_IsOK(res1)) {
 
4052
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WizardPageSimple_SetNext" "', expected argument " "1"" of type '" "wxWizardPageSimple *""'"); 
 
4053
  }
 
4054
  arg1 = reinterpret_cast< wxWizardPageSimple * >(argp1);
 
4055
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
4056
  if (!SWIG_IsOK(res2)) {
 
4057
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WizardPageSimple_SetNext" "', expected argument " "2"" of type '" "wxWizardPage *""'"); 
 
4058
  }
 
4059
  arg2 = reinterpret_cast< wxWizardPage * >(argp2);
 
4060
  {
 
4061
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4062
    (arg1)->SetNext(arg2);
 
4063
    wxPyEndAllowThreads(__tstate);
 
4064
    if (PyErr_Occurred()) SWIG_fail;
 
4065
  }
 
4066
  resultobj = SWIG_Py_Void();
 
4067
  return resultobj;
 
4068
fail:
 
4069
  return NULL;
 
4070
}
 
4071
 
 
4072
 
 
4073
SWIGINTERN PyObject *_wrap_WizardPageSimple_Chain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4074
  PyObject *resultobj = 0;
 
4075
  wxWizardPageSimple *arg1 = (wxWizardPageSimple *) 0 ;
 
4076
  wxWizardPageSimple *arg2 = (wxWizardPageSimple *) 0 ;
 
4077
  void *argp1 = 0 ;
 
4078
  int res1 = 0 ;
 
4079
  void *argp2 = 0 ;
 
4080
  int res2 = 0 ;
 
4081
  PyObject * obj0 = 0 ;
 
4082
  PyObject * obj1 = 0 ;
 
4083
  char *  kwnames[] = {
 
4084
    (char *) "first",(char *) "second", NULL 
 
4085
  };
 
4086
  
 
4087
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:WizardPageSimple_Chain",kwnames,&obj0,&obj1)) SWIG_fail;
 
4088
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizardPageSimple, 0 |  0 );
 
4089
  if (!SWIG_IsOK(res1)) {
 
4090
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WizardPageSimple_Chain" "', expected argument " "1"" of type '" "wxWizardPageSimple *""'"); 
 
4091
  }
 
4092
  arg1 = reinterpret_cast< wxWizardPageSimple * >(argp1);
 
4093
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizardPageSimple, 0 |  0 );
 
4094
  if (!SWIG_IsOK(res2)) {
 
4095
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WizardPageSimple_Chain" "', expected argument " "2"" of type '" "wxWizardPageSimple *""'"); 
 
4096
  }
 
4097
  arg2 = reinterpret_cast< wxWizardPageSimple * >(argp2);
 
4098
  {
 
4099
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4100
    wxWizardPageSimple::Chain(arg1,arg2);
 
4101
    wxPyEndAllowThreads(__tstate);
 
4102
    if (PyErr_Occurred()) SWIG_fail;
 
4103
  }
 
4104
  resultobj = SWIG_Py_Void();
 
4105
  return resultobj;
 
4106
fail:
 
4107
  return NULL;
 
4108
}
 
4109
 
 
4110
 
 
4111
SWIGINTERN PyObject *WizardPageSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4112
  PyObject *obj;
 
4113
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
4114
  SWIG_TypeNewClientData(SWIGTYPE_p_wxWizardPageSimple, SWIG_NewClientData(obj));
 
4115
  return SWIG_Py_Void();
 
4116
}
 
4117
 
 
4118
SWIGINTERN PyObject *WizardPageSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4119
  return SWIG_Python_InitShadowInstance(args);
 
4120
}
 
4121
 
 
4122
SWIGINTERN PyObject *_wrap_new_Wizard(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4123
  PyObject *resultobj = 0;
 
4124
  wxWindow *arg1 = (wxWindow *) 0 ;
 
4125
  int arg2 = (int) -1 ;
 
4126
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
4127
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
4128
  wxBitmap const &arg4_defvalue = wxNullBitmap ;
 
4129
  wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
 
4130
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
4131
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
4132
  long arg6 = (long) wxDEFAULT_DIALOG_STYLE ;
 
4133
  wxWizard *result = 0 ;
 
4134
  void *argp1 = 0 ;
 
4135
  int res1 = 0 ;
 
4136
  int val2 ;
 
4137
  int ecode2 = 0 ;
 
4138
  bool temp3 = false ;
 
4139
  void *argp4 = 0 ;
 
4140
  int res4 = 0 ;
 
4141
  wxPoint temp5 ;
 
4142
  long val6 ;
 
4143
  int ecode6 = 0 ;
 
4144
  PyObject * obj0 = 0 ;
 
4145
  PyObject * obj1 = 0 ;
 
4146
  PyObject * obj2 = 0 ;
 
4147
  PyObject * obj3 = 0 ;
 
4148
  PyObject * obj4 = 0 ;
 
4149
  PyObject * obj5 = 0 ;
 
4150
  char *  kwnames[] = {
 
4151
    (char *) "parent",(char *) "id",(char *) "title",(char *) "bitmap",(char *) "pos",(char *) "style", NULL 
 
4152
  };
 
4153
  
 
4154
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Wizard",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
4155
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
4156
  if (!SWIG_IsOK(res1)) {
 
4157
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wizard" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
4158
  }
 
4159
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
4160
  if (obj1) {
 
4161
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
4162
    if (!SWIG_IsOK(ecode2)) {
 
4163
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Wizard" "', expected argument " "2"" of type '" "int""'");
 
4164
    } 
 
4165
    arg2 = static_cast< int >(val2);
 
4166
  }
 
4167
  if (obj2) {
 
4168
    {
 
4169
      arg3 = wxString_in_helper(obj2);
 
4170
      if (arg3 == NULL) SWIG_fail;
 
4171
      temp3 = true;
 
4172
    }
 
4173
  }
 
4174
  if (obj3) {
 
4175
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap,  0  | 0);
 
4176
    if (!SWIG_IsOK(res4)) {
 
4177
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Wizard" "', expected argument " "4"" of type '" "wxBitmap const &""'"); 
 
4178
    }
 
4179
    if (!argp4) {
 
4180
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Wizard" "', expected argument " "4"" of type '" "wxBitmap const &""'"); 
 
4181
    }
 
4182
    arg4 = reinterpret_cast< wxBitmap * >(argp4);
 
4183
  }
 
4184
  if (obj4) {
 
4185
    {
 
4186
      arg5 = &temp5;
 
4187
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
4188
    }
 
4189
  }
 
4190
  if (obj5) {
 
4191
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
4192
    if (!SWIG_IsOK(ecode6)) {
 
4193
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Wizard" "', expected argument " "6"" of type '" "long""'");
 
4194
    } 
 
4195
    arg6 = static_cast< long >(val6);
 
4196
  }
 
4197
  {
 
4198
    if (!wxPyCheckForApp()) SWIG_fail;
 
4199
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4200
    result = (wxWizard *)new wxWizard(arg1,arg2,(wxString const &)*arg3,(wxBitmap const &)*arg4,(wxPoint const &)*arg5,arg6);
 
4201
    wxPyEndAllowThreads(__tstate);
 
4202
    if (PyErr_Occurred()) SWIG_fail;
 
4203
  }
 
4204
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWizard, SWIG_POINTER_NEW |  0 );
 
4205
  {
 
4206
    if (temp3)
 
4207
    delete arg3;
 
4208
  }
 
4209
  return resultobj;
 
4210
fail:
 
4211
  {
 
4212
    if (temp3)
 
4213
    delete arg3;
 
4214
  }
 
4215
  return NULL;
 
4216
}
 
4217
 
 
4218
 
 
4219
SWIGINTERN PyObject *_wrap_new_PreWizard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4220
  PyObject *resultobj = 0;
 
4221
  wxWizard *result = 0 ;
 
4222
  
 
4223
  if (!SWIG_Python_UnpackTuple(args,"new_PreWizard",0,0,0)) SWIG_fail;
 
4224
  {
 
4225
    if (!wxPyCheckForApp()) SWIG_fail;
 
4226
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4227
    result = (wxWizard *)new wxWizard();
 
4228
    wxPyEndAllowThreads(__tstate);
 
4229
    if (PyErr_Occurred()) SWIG_fail;
 
4230
  }
 
4231
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWizard, SWIG_POINTER_OWN |  0 );
 
4232
  return resultobj;
 
4233
fail:
 
4234
  return NULL;
 
4235
}
 
4236
 
 
4237
 
 
4238
SWIGINTERN PyObject *_wrap_Wizard_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4239
  PyObject *resultobj = 0;
 
4240
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4241
  wxWindow *arg2 = (wxWindow *) 0 ;
 
4242
  int arg3 = (int) -1 ;
 
4243
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
4244
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
4245
  wxBitmap const &arg5_defvalue = wxNullBitmap ;
 
4246
  wxBitmap *arg5 = (wxBitmap *) &arg5_defvalue ;
 
4247
  wxPoint const &arg6_defvalue = wxDefaultPosition ;
 
4248
  wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
 
4249
  bool result;
 
4250
  void *argp1 = 0 ;
 
4251
  int res1 = 0 ;
 
4252
  void *argp2 = 0 ;
 
4253
  int res2 = 0 ;
 
4254
  int val3 ;
 
4255
  int ecode3 = 0 ;
 
4256
  bool temp4 = false ;
 
4257
  void *argp5 = 0 ;
 
4258
  int res5 = 0 ;
 
4259
  wxPoint temp6 ;
 
4260
  PyObject * obj0 = 0 ;
 
4261
  PyObject * obj1 = 0 ;
 
4262
  PyObject * obj2 = 0 ;
 
4263
  PyObject * obj3 = 0 ;
 
4264
  PyObject * obj4 = 0 ;
 
4265
  PyObject * obj5 = 0 ;
 
4266
  char *  kwnames[] = {
 
4267
    (char *) "self",(char *) "parent",(char *) "id",(char *) "title",(char *) "bitmap",(char *) "pos", NULL 
 
4268
  };
 
4269
  
 
4270
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Wizard_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
4271
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4272
  if (!SWIG_IsOK(res1)) {
 
4273
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_Create" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4274
  }
 
4275
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4276
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
4277
  if (!SWIG_IsOK(res2)) {
 
4278
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wizard_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
4279
  }
 
4280
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
4281
  if (obj2) {
 
4282
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
4283
    if (!SWIG_IsOK(ecode3)) {
 
4284
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Wizard_Create" "', expected argument " "3"" of type '" "int""'");
 
4285
    } 
 
4286
    arg3 = static_cast< int >(val3);
 
4287
  }
 
4288
  if (obj3) {
 
4289
    {
 
4290
      arg4 = wxString_in_helper(obj3);
 
4291
      if (arg4 == NULL) SWIG_fail;
 
4292
      temp4 = true;
 
4293
    }
 
4294
  }
 
4295
  if (obj4) {
 
4296
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxBitmap,  0  | 0);
 
4297
    if (!SWIG_IsOK(res5)) {
 
4298
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Wizard_Create" "', expected argument " "5"" of type '" "wxBitmap const &""'"); 
 
4299
    }
 
4300
    if (!argp5) {
 
4301
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Wizard_Create" "', expected argument " "5"" of type '" "wxBitmap const &""'"); 
 
4302
    }
 
4303
    arg5 = reinterpret_cast< wxBitmap * >(argp5);
 
4304
  }
 
4305
  if (obj5) {
 
4306
    {
 
4307
      arg6 = &temp6;
 
4308
      if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
 
4309
    }
 
4310
  }
 
4311
  {
 
4312
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4313
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxBitmap const &)*arg5,(wxPoint const &)*arg6);
 
4314
    wxPyEndAllowThreads(__tstate);
 
4315
    if (PyErr_Occurred()) SWIG_fail;
 
4316
  }
 
4317
  {
 
4318
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
4319
  }
 
4320
  {
 
4321
    if (temp4)
 
4322
    delete arg4;
 
4323
  }
 
4324
  return resultobj;
 
4325
fail:
 
4326
  {
 
4327
    if (temp4)
 
4328
    delete arg4;
 
4329
  }
 
4330
  return NULL;
 
4331
}
 
4332
 
 
4333
 
 
4334
SWIGINTERN PyObject *_wrap_Wizard_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4335
  PyObject *resultobj = 0;
 
4336
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4337
  void *argp1 = 0 ;
 
4338
  int res1 = 0 ;
 
4339
  PyObject *swig_obj[1] ;
 
4340
  
 
4341
  if (!args) SWIG_fail;
 
4342
  swig_obj[0] = args;
 
4343
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4344
  if (!SWIG_IsOK(res1)) {
 
4345
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_Init" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4346
  }
 
4347
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4348
  {
 
4349
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4350
    (arg1)->Init();
 
4351
    wxPyEndAllowThreads(__tstate);
 
4352
    if (PyErr_Occurred()) SWIG_fail;
 
4353
  }
 
4354
  resultobj = SWIG_Py_Void();
 
4355
  return resultobj;
 
4356
fail:
 
4357
  return NULL;
 
4358
}
 
4359
 
 
4360
 
 
4361
SWIGINTERN PyObject *_wrap_Wizard_RunWizard(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4362
  PyObject *resultobj = 0;
 
4363
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4364
  wxWizardPage *arg2 = (wxWizardPage *) 0 ;
 
4365
  bool result;
 
4366
  void *argp1 = 0 ;
 
4367
  int res1 = 0 ;
 
4368
  void *argp2 = 0 ;
 
4369
  int res2 = 0 ;
 
4370
  PyObject * obj0 = 0 ;
 
4371
  PyObject * obj1 = 0 ;
 
4372
  char *  kwnames[] = {
 
4373
    (char *) "self",(char *) "firstPage", NULL 
 
4374
  };
 
4375
  
 
4376
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Wizard_RunWizard",kwnames,&obj0,&obj1)) SWIG_fail;
 
4377
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4378
  if (!SWIG_IsOK(res1)) {
 
4379
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_RunWizard" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4380
  }
 
4381
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4382
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
4383
  if (!SWIG_IsOK(res2)) {
 
4384
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wizard_RunWizard" "', expected argument " "2"" of type '" "wxWizardPage *""'"); 
 
4385
  }
 
4386
  arg2 = reinterpret_cast< wxWizardPage * >(argp2);
 
4387
  {
 
4388
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4389
    result = (bool)(arg1)->RunWizard(arg2);
 
4390
    wxPyEndAllowThreads(__tstate);
 
4391
    if (PyErr_Occurred()) SWIG_fail;
 
4392
  }
 
4393
  {
 
4394
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
4395
  }
 
4396
  return resultobj;
 
4397
fail:
 
4398
  return NULL;
 
4399
}
 
4400
 
 
4401
 
 
4402
SWIGINTERN PyObject *_wrap_Wizard_GetCurrentPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4403
  PyObject *resultobj = 0;
 
4404
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4405
  wxWizardPage *result = 0 ;
 
4406
  void *argp1 = 0 ;
 
4407
  int res1 = 0 ;
 
4408
  PyObject *swig_obj[1] ;
 
4409
  
 
4410
  if (!args) SWIG_fail;
 
4411
  swig_obj[0] = args;
 
4412
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4413
  if (!SWIG_IsOK(res1)) {
 
4414
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_GetCurrentPage" "', expected argument " "1"" of type '" "wxWizard const *""'"); 
 
4415
  }
 
4416
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4417
  {
 
4418
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4419
    result = (wxWizardPage *)((wxWizard const *)arg1)->GetCurrentPage();
 
4420
    wxPyEndAllowThreads(__tstate);
 
4421
    if (PyErr_Occurred()) SWIG_fail;
 
4422
  }
 
4423
  {
 
4424
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
4425
  }
 
4426
  return resultobj;
 
4427
fail:
 
4428
  return NULL;
 
4429
}
 
4430
 
 
4431
 
 
4432
SWIGINTERN PyObject *_wrap_Wizard_SetPageSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4433
  PyObject *resultobj = 0;
 
4434
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4435
  wxSize *arg2 = 0 ;
 
4436
  void *argp1 = 0 ;
 
4437
  int res1 = 0 ;
 
4438
  wxSize temp2 ;
 
4439
  PyObject * obj0 = 0 ;
 
4440
  PyObject * obj1 = 0 ;
 
4441
  char *  kwnames[] = {
 
4442
    (char *) "self",(char *) "size", NULL 
 
4443
  };
 
4444
  
 
4445
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Wizard_SetPageSize",kwnames,&obj0,&obj1)) SWIG_fail;
 
4446
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4447
  if (!SWIG_IsOK(res1)) {
 
4448
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_SetPageSize" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4449
  }
 
4450
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4451
  {
 
4452
    arg2 = &temp2;
 
4453
    if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
 
4454
  }
 
4455
  {
 
4456
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4457
    (arg1)->SetPageSize((wxSize const &)*arg2);
 
4458
    wxPyEndAllowThreads(__tstate);
 
4459
    if (PyErr_Occurred()) SWIG_fail;
 
4460
  }
 
4461
  resultobj = SWIG_Py_Void();
 
4462
  return resultobj;
 
4463
fail:
 
4464
  return NULL;
 
4465
}
 
4466
 
 
4467
 
 
4468
SWIGINTERN PyObject *_wrap_Wizard_GetPageSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4469
  PyObject *resultobj = 0;
 
4470
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4471
  wxSize result;
 
4472
  void *argp1 = 0 ;
 
4473
  int res1 = 0 ;
 
4474
  PyObject *swig_obj[1] ;
 
4475
  
 
4476
  if (!args) SWIG_fail;
 
4477
  swig_obj[0] = args;
 
4478
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4479
  if (!SWIG_IsOK(res1)) {
 
4480
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_GetPageSize" "', expected argument " "1"" of type '" "wxWizard const *""'"); 
 
4481
  }
 
4482
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4483
  {
 
4484
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4485
    result = ((wxWizard const *)arg1)->GetPageSize();
 
4486
    wxPyEndAllowThreads(__tstate);
 
4487
    if (PyErr_Occurred()) SWIG_fail;
 
4488
  }
 
4489
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
4490
  return resultobj;
 
4491
fail:
 
4492
  return NULL;
 
4493
}
 
4494
 
 
4495
 
 
4496
SWIGINTERN PyObject *_wrap_Wizard_FitToPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4497
  PyObject *resultobj = 0;
 
4498
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4499
  wxWizardPage *arg2 = (wxWizardPage *) 0 ;
 
4500
  void *argp1 = 0 ;
 
4501
  int res1 = 0 ;
 
4502
  void *argp2 = 0 ;
 
4503
  int res2 = 0 ;
 
4504
  PyObject * obj0 = 0 ;
 
4505
  PyObject * obj1 = 0 ;
 
4506
  char *  kwnames[] = {
 
4507
    (char *) "self",(char *) "firstPage", NULL 
 
4508
  };
 
4509
  
 
4510
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Wizard_FitToPage",kwnames,&obj0,&obj1)) SWIG_fail;
 
4511
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4512
  if (!SWIG_IsOK(res1)) {
 
4513
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_FitToPage" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4514
  }
 
4515
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4516
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
4517
  if (!SWIG_IsOK(res2)) {
 
4518
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wizard_FitToPage" "', expected argument " "2"" of type '" "wxWizardPage const *""'"); 
 
4519
  }
 
4520
  arg2 = reinterpret_cast< wxWizardPage * >(argp2);
 
4521
  {
 
4522
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4523
    (arg1)->FitToPage((wxWizardPage const *)arg2);
 
4524
    wxPyEndAllowThreads(__tstate);
 
4525
    if (PyErr_Occurred()) SWIG_fail;
 
4526
  }
 
4527
  resultobj = SWIG_Py_Void();
 
4528
  return resultobj;
 
4529
fail:
 
4530
  return NULL;
 
4531
}
 
4532
 
 
4533
 
 
4534
SWIGINTERN PyObject *_wrap_Wizard_GetPageAreaSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4535
  PyObject *resultobj = 0;
 
4536
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4537
  wxSizer *result = 0 ;
 
4538
  void *argp1 = 0 ;
 
4539
  int res1 = 0 ;
 
4540
  PyObject *swig_obj[1] ;
 
4541
  
 
4542
  if (!args) SWIG_fail;
 
4543
  swig_obj[0] = args;
 
4544
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4545
  if (!SWIG_IsOK(res1)) {
 
4546
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_GetPageAreaSizer" "', expected argument " "1"" of type '" "wxWizard const *""'"); 
 
4547
  }
 
4548
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4549
  {
 
4550
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4551
    result = (wxSizer *)((wxWizard const *)arg1)->GetPageAreaSizer();
 
4552
    wxPyEndAllowThreads(__tstate);
 
4553
    if (PyErr_Occurred()) SWIG_fail;
 
4554
  }
 
4555
  {
 
4556
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
4557
  }
 
4558
  return resultobj;
 
4559
fail:
 
4560
  return NULL;
 
4561
}
 
4562
 
 
4563
 
 
4564
SWIGINTERN PyObject *_wrap_Wizard_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4565
  PyObject *resultobj = 0;
 
4566
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4567
  int arg2 ;
 
4568
  void *argp1 = 0 ;
 
4569
  int res1 = 0 ;
 
4570
  int val2 ;
 
4571
  int ecode2 = 0 ;
 
4572
  PyObject * obj0 = 0 ;
 
4573
  PyObject * obj1 = 0 ;
 
4574
  char *  kwnames[] = {
 
4575
    (char *) "self",(char *) "border", NULL 
 
4576
  };
 
4577
  
 
4578
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Wizard_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
 
4579
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4580
  if (!SWIG_IsOK(res1)) {
 
4581
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_SetBorder" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4582
  }
 
4583
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4584
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
4585
  if (!SWIG_IsOK(ecode2)) {
 
4586
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wizard_SetBorder" "', expected argument " "2"" of type '" "int""'");
 
4587
  } 
 
4588
  arg2 = static_cast< int >(val2);
 
4589
  {
 
4590
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4591
    (arg1)->SetBorder(arg2);
 
4592
    wxPyEndAllowThreads(__tstate);
 
4593
    if (PyErr_Occurred()) SWIG_fail;
 
4594
  }
 
4595
  resultobj = SWIG_Py_Void();
 
4596
  return resultobj;
 
4597
fail:
 
4598
  return NULL;
 
4599
}
 
4600
 
 
4601
 
 
4602
SWIGINTERN PyObject *_wrap_Wizard_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4603
  PyObject *resultobj = 0;
 
4604
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4605
  wxBitmap *result = 0 ;
 
4606
  void *argp1 = 0 ;
 
4607
  int res1 = 0 ;
 
4608
  PyObject *swig_obj[1] ;
 
4609
  
 
4610
  if (!args) SWIG_fail;
 
4611
  swig_obj[0] = args;
 
4612
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4613
  if (!SWIG_IsOK(res1)) {
 
4614
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_GetBitmap" "', expected argument " "1"" of type '" "wxWizard const *""'"); 
 
4615
  }
 
4616
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4617
  {
 
4618
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4619
    {
 
4620
      wxBitmap const &_result_ref = ((wxWizard const *)arg1)->GetBitmap();
 
4621
      result = (wxBitmap *) &_result_ref;
 
4622
    }
 
4623
    wxPyEndAllowThreads(__tstate);
 
4624
    if (PyErr_Occurred()) SWIG_fail;
 
4625
  }
 
4626
  {
 
4627
    wxBitmap* resultptr = new wxBitmap(*result);
 
4628
    resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
 
4629
  }
 
4630
  return resultobj;
 
4631
fail:
 
4632
  return NULL;
 
4633
}
 
4634
 
 
4635
 
 
4636
SWIGINTERN PyObject *_wrap_Wizard_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4637
  PyObject *resultobj = 0;
 
4638
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4639
  wxBitmap *arg2 = 0 ;
 
4640
  void *argp1 = 0 ;
 
4641
  int res1 = 0 ;
 
4642
  void *argp2 = 0 ;
 
4643
  int res2 = 0 ;
 
4644
  PyObject * obj0 = 0 ;
 
4645
  PyObject * obj1 = 0 ;
 
4646
  char *  kwnames[] = {
 
4647
    (char *) "self",(char *) "bitmap", NULL 
 
4648
  };
 
4649
  
 
4650
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Wizard_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
 
4651
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4652
  if (!SWIG_IsOK(res1)) {
 
4653
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_SetBitmap" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4654
  }
 
4655
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4656
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
4657
  if (!SWIG_IsOK(res2)) {
 
4658
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wizard_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
4659
  }
 
4660
  if (!argp2) {
 
4661
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Wizard_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
4662
  }
 
4663
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
4664
  {
 
4665
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4666
    (arg1)->SetBitmap((wxBitmap const &)*arg2);
 
4667
    wxPyEndAllowThreads(__tstate);
 
4668
    if (PyErr_Occurred()) SWIG_fail;
 
4669
  }
 
4670
  resultobj = SWIG_Py_Void();
 
4671
  return resultobj;
 
4672
fail:
 
4673
  return NULL;
 
4674
}
 
4675
 
 
4676
 
 
4677
SWIGINTERN PyObject *_wrap_Wizard_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4678
  PyObject *resultobj = 0;
 
4679
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4680
  bool result;
 
4681
  void *argp1 = 0 ;
 
4682
  int res1 = 0 ;
 
4683
  PyObject *swig_obj[1] ;
 
4684
  
 
4685
  if (!args) SWIG_fail;
 
4686
  swig_obj[0] = args;
 
4687
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4688
  if (!SWIG_IsOK(res1)) {
 
4689
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_IsRunning" "', expected argument " "1"" of type '" "wxWizard const *""'"); 
 
4690
  }
 
4691
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4692
  {
 
4693
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4694
    result = (bool)((wxWizard const *)arg1)->IsRunning();
 
4695
    wxPyEndAllowThreads(__tstate);
 
4696
    if (PyErr_Occurred()) SWIG_fail;
 
4697
  }
 
4698
  {
 
4699
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
4700
  }
 
4701
  return resultobj;
 
4702
fail:
 
4703
  return NULL;
 
4704
}
 
4705
 
 
4706
 
 
4707
SWIGINTERN PyObject *_wrap_Wizard_SetBitmapBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4708
  PyObject *resultobj = 0;
 
4709
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4710
  wxColour *arg2 = 0 ;
 
4711
  void *argp1 = 0 ;
 
4712
  int res1 = 0 ;
 
4713
  wxColour temp2 ;
 
4714
  PyObject * obj0 = 0 ;
 
4715
  PyObject * obj1 = 0 ;
 
4716
  char *  kwnames[] = {
 
4717
    (char *) "self",(char *) "colour", NULL 
 
4718
  };
 
4719
  
 
4720
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Wizard_SetBitmapBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
4721
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4722
  if (!SWIG_IsOK(res1)) {
 
4723
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_SetBitmapBackgroundColour" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4724
  }
 
4725
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4726
  {
 
4727
    arg2 = &temp2;
 
4728
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
4729
  }
 
4730
  {
 
4731
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4732
    (arg1)->SetBitmapBackgroundColour((wxColour const &)*arg2);
 
4733
    wxPyEndAllowThreads(__tstate);
 
4734
    if (PyErr_Occurred()) SWIG_fail;
 
4735
  }
 
4736
  resultobj = SWIG_Py_Void();
 
4737
  return resultobj;
 
4738
fail:
 
4739
  return NULL;
 
4740
}
 
4741
 
 
4742
 
 
4743
SWIGINTERN PyObject *_wrap_Wizard_GetBitmapBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4744
  PyObject *resultobj = 0;
 
4745
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4746
  wxColour *result = 0 ;
 
4747
  void *argp1 = 0 ;
 
4748
  int res1 = 0 ;
 
4749
  PyObject *swig_obj[1] ;
 
4750
  
 
4751
  if (!args) SWIG_fail;
 
4752
  swig_obj[0] = args;
 
4753
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4754
  if (!SWIG_IsOK(res1)) {
 
4755
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_GetBitmapBackgroundColour" "', expected argument " "1"" of type '" "wxWizard const *""'"); 
 
4756
  }
 
4757
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4758
  {
 
4759
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4760
    {
 
4761
      wxColour const &_result_ref = ((wxWizard const *)arg1)->GetBitmapBackgroundColour();
 
4762
      result = (wxColour *) &_result_ref;
 
4763
    }
 
4764
    wxPyEndAllowThreads(__tstate);
 
4765
    if (PyErr_Occurred()) SWIG_fail;
 
4766
  }
 
4767
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 |  0 );
 
4768
  return resultobj;
 
4769
fail:
 
4770
  return NULL;
 
4771
}
 
4772
 
 
4773
 
 
4774
SWIGINTERN PyObject *_wrap_Wizard_SetBitmapPlacement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4775
  PyObject *resultobj = 0;
 
4776
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4777
  int arg2 ;
 
4778
  void *argp1 = 0 ;
 
4779
  int res1 = 0 ;
 
4780
  int val2 ;
 
4781
  int ecode2 = 0 ;
 
4782
  PyObject * obj0 = 0 ;
 
4783
  PyObject * obj1 = 0 ;
 
4784
  char *  kwnames[] = {
 
4785
    (char *) "self",(char *) "placement", NULL 
 
4786
  };
 
4787
  
 
4788
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Wizard_SetBitmapPlacement",kwnames,&obj0,&obj1)) SWIG_fail;
 
4789
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4790
  if (!SWIG_IsOK(res1)) {
 
4791
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_SetBitmapPlacement" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4792
  }
 
4793
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4794
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
4795
  if (!SWIG_IsOK(ecode2)) {
 
4796
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wizard_SetBitmapPlacement" "', expected argument " "2"" of type '" "int""'");
 
4797
  } 
 
4798
  arg2 = static_cast< int >(val2);
 
4799
  {
 
4800
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4801
    (arg1)->SetBitmapPlacement(arg2);
 
4802
    wxPyEndAllowThreads(__tstate);
 
4803
    if (PyErr_Occurred()) SWIG_fail;
 
4804
  }
 
4805
  resultobj = SWIG_Py_Void();
 
4806
  return resultobj;
 
4807
fail:
 
4808
  return NULL;
 
4809
}
 
4810
 
 
4811
 
 
4812
SWIGINTERN PyObject *_wrap_Wizard_GetBitmapPlacement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4813
  PyObject *resultobj = 0;
 
4814
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4815
  int result;
 
4816
  void *argp1 = 0 ;
 
4817
  int res1 = 0 ;
 
4818
  PyObject *swig_obj[1] ;
 
4819
  
 
4820
  if (!args) SWIG_fail;
 
4821
  swig_obj[0] = args;
 
4822
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4823
  if (!SWIG_IsOK(res1)) {
 
4824
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_GetBitmapPlacement" "', expected argument " "1"" of type '" "wxWizard const *""'"); 
 
4825
  }
 
4826
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4827
  {
 
4828
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4829
    result = (int)((wxWizard const *)arg1)->GetBitmapPlacement();
 
4830
    wxPyEndAllowThreads(__tstate);
 
4831
    if (PyErr_Occurred()) SWIG_fail;
 
4832
  }
 
4833
  resultobj = SWIG_From_int(static_cast< int >(result));
 
4834
  return resultobj;
 
4835
fail:
 
4836
  return NULL;
 
4837
}
 
4838
 
 
4839
 
 
4840
SWIGINTERN PyObject *_wrap_Wizard_SetMinimumBitmapWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4841
  PyObject *resultobj = 0;
 
4842
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4843
  int arg2 ;
 
4844
  void *argp1 = 0 ;
 
4845
  int res1 = 0 ;
 
4846
  int val2 ;
 
4847
  int ecode2 = 0 ;
 
4848
  PyObject * obj0 = 0 ;
 
4849
  PyObject * obj1 = 0 ;
 
4850
  char *  kwnames[] = {
 
4851
    (char *) "self",(char *) "w", NULL 
 
4852
  };
 
4853
  
 
4854
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Wizard_SetMinimumBitmapWidth",kwnames,&obj0,&obj1)) SWIG_fail;
 
4855
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4856
  if (!SWIG_IsOK(res1)) {
 
4857
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_SetMinimumBitmapWidth" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4858
  }
 
4859
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4860
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
4861
  if (!SWIG_IsOK(ecode2)) {
 
4862
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wizard_SetMinimumBitmapWidth" "', expected argument " "2"" of type '" "int""'");
 
4863
  } 
 
4864
  arg2 = static_cast< int >(val2);
 
4865
  {
 
4866
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4867
    (arg1)->SetMinimumBitmapWidth(arg2);
 
4868
    wxPyEndAllowThreads(__tstate);
 
4869
    if (PyErr_Occurred()) SWIG_fail;
 
4870
  }
 
4871
  resultobj = SWIG_Py_Void();
 
4872
  return resultobj;
 
4873
fail:
 
4874
  return NULL;
 
4875
}
 
4876
 
 
4877
 
 
4878
SWIGINTERN PyObject *_wrap_Wizard_GetMinimumBitmapWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4879
  PyObject *resultobj = 0;
 
4880
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4881
  int result;
 
4882
  void *argp1 = 0 ;
 
4883
  int res1 = 0 ;
 
4884
  PyObject *swig_obj[1] ;
 
4885
  
 
4886
  if (!args) SWIG_fail;
 
4887
  swig_obj[0] = args;
 
4888
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4889
  if (!SWIG_IsOK(res1)) {
 
4890
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_GetMinimumBitmapWidth" "', expected argument " "1"" of type '" "wxWizard const *""'"); 
 
4891
  }
 
4892
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4893
  {
 
4894
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4895
    result = (int)((wxWizard const *)arg1)->GetMinimumBitmapWidth();
 
4896
    wxPyEndAllowThreads(__tstate);
 
4897
    if (PyErr_Occurred()) SWIG_fail;
 
4898
  }
 
4899
  resultobj = SWIG_From_int(static_cast< int >(result));
 
4900
  return resultobj;
 
4901
fail:
 
4902
  return NULL;
 
4903
}
 
4904
 
 
4905
 
 
4906
SWIGINTERN PyObject *_wrap_Wizard_TileBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4907
  PyObject *resultobj = 0;
 
4908
  wxRect *arg1 = 0 ;
 
4909
  wxDC *arg2 = 0 ;
 
4910
  wxBitmap *arg3 = 0 ;
 
4911
  bool result;
 
4912
  wxRect temp1 ;
 
4913
  void *argp2 = 0 ;
 
4914
  int res2 = 0 ;
 
4915
  void *argp3 = 0 ;
 
4916
  int res3 = 0 ;
 
4917
  PyObject * obj0 = 0 ;
 
4918
  PyObject * obj1 = 0 ;
 
4919
  PyObject * obj2 = 0 ;
 
4920
  char *  kwnames[] = {
 
4921
    (char *) "rect",(char *) "dc",(char *) "bitmap", NULL 
 
4922
  };
 
4923
  
 
4924
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Wizard_TileBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
4925
  {
 
4926
    arg1 = &temp1;
 
4927
    if ( ! wxRect_helper(obj0, &arg1)) SWIG_fail;
 
4928
  }
 
4929
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC,  0 );
 
4930
  if (!SWIG_IsOK(res2)) {
 
4931
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wizard_TileBitmap" "', expected argument " "2"" of type '" "wxDC &""'"); 
 
4932
  }
 
4933
  if (!argp2) {
 
4934
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Wizard_TileBitmap" "', expected argument " "2"" of type '" "wxDC &""'"); 
 
4935
  }
 
4936
  arg2 = reinterpret_cast< wxDC * >(argp2);
 
4937
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap,  0  | 0);
 
4938
  if (!SWIG_IsOK(res3)) {
 
4939
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Wizard_TileBitmap" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
4940
  }
 
4941
  if (!argp3) {
 
4942
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Wizard_TileBitmap" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
4943
  }
 
4944
  arg3 = reinterpret_cast< wxBitmap * >(argp3);
 
4945
  {
 
4946
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4947
    result = (bool)wxWizard::TileBitmap((wxRect const &)*arg1,*arg2,(wxBitmap const &)*arg3);
 
4948
    wxPyEndAllowThreads(__tstate);
 
4949
    if (PyErr_Occurred()) SWIG_fail;
 
4950
  }
 
4951
  {
 
4952
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
4953
  }
 
4954
  return resultobj;
 
4955
fail:
 
4956
  return NULL;
 
4957
}
 
4958
 
 
4959
 
 
4960
SWIGINTERN PyObject *_wrap_Wizard_ShowPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4961
  PyObject *resultobj = 0;
 
4962
  wxWizard *arg1 = (wxWizard *) 0 ;
 
4963
  wxWizardPage *arg2 = (wxWizardPage *) 0 ;
 
4964
  bool arg3 = (bool) true ;
 
4965
  bool result;
 
4966
  void *argp1 = 0 ;
 
4967
  int res1 = 0 ;
 
4968
  void *argp2 = 0 ;
 
4969
  int res2 = 0 ;
 
4970
  bool val3 ;
 
4971
  int ecode3 = 0 ;
 
4972
  PyObject * obj0 = 0 ;
 
4973
  PyObject * obj1 = 0 ;
 
4974
  PyObject * obj2 = 0 ;
 
4975
  char *  kwnames[] = {
 
4976
    (char *) "self",(char *) "page",(char *) "goingForward", NULL 
 
4977
  };
 
4978
  
 
4979
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Wizard_ShowPage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
4980
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
4981
  if (!SWIG_IsOK(res1)) {
 
4982
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_ShowPage" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
4983
  }
 
4984
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
4985
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
4986
  if (!SWIG_IsOK(res2)) {
 
4987
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wizard_ShowPage" "', expected argument " "2"" of type '" "wxWizardPage *""'"); 
 
4988
  }
 
4989
  arg2 = reinterpret_cast< wxWizardPage * >(argp2);
 
4990
  if (obj2) {
 
4991
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
4992
    if (!SWIG_IsOK(ecode3)) {
 
4993
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Wizard_ShowPage" "', expected argument " "3"" of type '" "bool""'");
 
4994
    } 
 
4995
    arg3 = static_cast< bool >(val3);
 
4996
  }
 
4997
  {
 
4998
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4999
    result = (bool)(arg1)->ShowPage(arg2,arg3);
 
5000
    wxPyEndAllowThreads(__tstate);
 
5001
    if (PyErr_Occurred()) SWIG_fail;
 
5002
  }
 
5003
  {
 
5004
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
5005
  }
 
5006
  return resultobj;
 
5007
fail:
 
5008
  return NULL;
 
5009
}
 
5010
 
 
5011
 
 
5012
SWIGINTERN PyObject *_wrap_Wizard_HasNextPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
5013
  PyObject *resultobj = 0;
 
5014
  wxWizard *arg1 = (wxWizard *) 0 ;
 
5015
  wxWizardPage *arg2 = (wxWizardPage *) 0 ;
 
5016
  bool result;
 
5017
  void *argp1 = 0 ;
 
5018
  int res1 = 0 ;
 
5019
  void *argp2 = 0 ;
 
5020
  int res2 = 0 ;
 
5021
  PyObject * obj0 = 0 ;
 
5022
  PyObject * obj1 = 0 ;
 
5023
  char *  kwnames[] = {
 
5024
    (char *) "self",(char *) "page", NULL 
 
5025
  };
 
5026
  
 
5027
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Wizard_HasNextPage",kwnames,&obj0,&obj1)) SWIG_fail;
 
5028
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
5029
  if (!SWIG_IsOK(res1)) {
 
5030
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_HasNextPage" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
5031
  }
 
5032
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
5033
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
5034
  if (!SWIG_IsOK(res2)) {
 
5035
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wizard_HasNextPage" "', expected argument " "2"" of type '" "wxWizardPage *""'"); 
 
5036
  }
 
5037
  arg2 = reinterpret_cast< wxWizardPage * >(argp2);
 
5038
  {
 
5039
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5040
    result = (bool)(arg1)->HasNextPage(arg2);
 
5041
    wxPyEndAllowThreads(__tstate);
 
5042
    if (PyErr_Occurred()) SWIG_fail;
 
5043
  }
 
5044
  {
 
5045
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
5046
  }
 
5047
  return resultobj;
 
5048
fail:
 
5049
  return NULL;
 
5050
}
 
5051
 
 
5052
 
 
5053
SWIGINTERN PyObject *_wrap_Wizard_HasPrevPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
5054
  PyObject *resultobj = 0;
 
5055
  wxWizard *arg1 = (wxWizard *) 0 ;
 
5056
  wxWizardPage *arg2 = (wxWizardPage *) 0 ;
 
5057
  bool result;
 
5058
  void *argp1 = 0 ;
 
5059
  int res1 = 0 ;
 
5060
  void *argp2 = 0 ;
 
5061
  int res2 = 0 ;
 
5062
  PyObject * obj0 = 0 ;
 
5063
  PyObject * obj1 = 0 ;
 
5064
  char *  kwnames[] = {
 
5065
    (char *) "self",(char *) "page", NULL 
 
5066
  };
 
5067
  
 
5068
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Wizard_HasPrevPage",kwnames,&obj0,&obj1)) SWIG_fail;
 
5069
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWizard, 0 |  0 );
 
5070
  if (!SWIG_IsOK(res1)) {
 
5071
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wizard_HasPrevPage" "', expected argument " "1"" of type '" "wxWizard *""'"); 
 
5072
  }
 
5073
  arg1 = reinterpret_cast< wxWizard * >(argp1);
 
5074
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWizardPage, 0 |  0 );
 
5075
  if (!SWIG_IsOK(res2)) {
 
5076
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wizard_HasPrevPage" "', expected argument " "2"" of type '" "wxWizardPage *""'"); 
 
5077
  }
 
5078
  arg2 = reinterpret_cast< wxWizardPage * >(argp2);
 
5079
  {
 
5080
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5081
    result = (bool)(arg1)->HasPrevPage(arg2);
 
5082
    wxPyEndAllowThreads(__tstate);
 
5083
    if (PyErr_Occurred()) SWIG_fail;
 
5084
  }
 
5085
  {
 
5086
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
5087
  }
 
5088
  return resultobj;
 
5089
fail:
 
5090
  return NULL;
 
5091
}
 
5092
 
 
5093
 
 
5094
SWIGINTERN PyObject *Wizard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5095
  PyObject *obj;
 
5096
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
5097
  SWIG_TypeNewClientData(SWIGTYPE_p_wxWizard, SWIG_NewClientData(obj));
 
5098
  return SWIG_Py_Void();
 
5099
}
 
5100
 
 
5101
SWIGINTERN PyObject *Wizard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5102
  return SWIG_Python_InitShadowInstance(args);
 
5103
}
 
5104
 
 
5105
static PyMethodDef SwigMethods[] = {
 
5106
         { (char *)"new_WizardEvent", (PyCFunction) _wrap_new_WizardEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
5107
         { (char *)"WizardEvent_GetDirection", (PyCFunction)_wrap_WizardEvent_GetDirection, METH_O, NULL},
 
5108
         { (char *)"WizardEvent_GetPage", (PyCFunction)_wrap_WizardEvent_GetPage, METH_O, NULL},
 
5109
         { (char *)"WizardEvent_swigregister", WizardEvent_swigregister, METH_VARARGS, NULL},
 
5110
         { (char *)"WizardEvent_swiginit", WizardEvent_swiginit, METH_VARARGS, NULL},
 
5111
         { (char *)"WizardPage_Create", (PyCFunction) _wrap_WizardPage_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
5112
         { (char *)"WizardPage_GetPrev", (PyCFunction)_wrap_WizardPage_GetPrev, METH_O, NULL},
 
5113
         { (char *)"WizardPage_GetNext", (PyCFunction)_wrap_WizardPage_GetNext, METH_O, NULL},
 
5114
         { (char *)"WizardPage_GetBitmap", (PyCFunction)_wrap_WizardPage_GetBitmap, METH_O, NULL},
 
5115
         { (char *)"WizardPage_swigregister", WizardPage_swigregister, METH_VARARGS, NULL},
 
5116
         { (char *)"new_PyWizardPage", (PyCFunction) _wrap_new_PyWizardPage, METH_VARARGS | METH_KEYWORDS, NULL},
 
5117
         { (char *)"new_PrePyWizardPage", (PyCFunction)_wrap_new_PrePyWizardPage, METH_NOARGS, NULL},
 
5118
         { (char *)"PyWizardPage_Create", (PyCFunction) _wrap_PyWizardPage_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
5119
         { (char *)"PyWizardPage__setCallbackInfo", (PyCFunction) _wrap_PyWizardPage__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
 
5120
         { (char *)"PyWizardPage_DoMoveWindow", (PyCFunction) _wrap_PyWizardPage_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
 
5121
         { (char *)"PyWizardPage_DoSetSize", (PyCFunction) _wrap_PyWizardPage_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
5122
         { (char *)"PyWizardPage_DoSetClientSize", (PyCFunction) _wrap_PyWizardPage_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
5123
         { (char *)"PyWizardPage_DoSetVirtualSize", (PyCFunction) _wrap_PyWizardPage_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
5124
         { (char *)"PyWizardPage_DoGetSize", (PyCFunction)_wrap_PyWizardPage_DoGetSize, METH_O, NULL},
 
5125
         { (char *)"PyWizardPage_DoGetClientSize", (PyCFunction)_wrap_PyWizardPage_DoGetClientSize, METH_O, NULL},
 
5126
         { (char *)"PyWizardPage_DoGetPosition", (PyCFunction)_wrap_PyWizardPage_DoGetPosition, METH_O, NULL},
 
5127
         { (char *)"PyWizardPage_DoGetVirtualSize", (PyCFunction)_wrap_PyWizardPage_DoGetVirtualSize, METH_O, NULL},
 
5128
         { (char *)"PyWizardPage_DoGetBestSize", (PyCFunction)_wrap_PyWizardPage_DoGetBestSize, METH_O, NULL},
 
5129
         { (char *)"PyWizardPage_GetDefaultAttributes", (PyCFunction)_wrap_PyWizardPage_GetDefaultAttributes, METH_O, NULL},
 
5130
         { (char *)"PyWizardPage_OnInternalIdle", (PyCFunction)_wrap_PyWizardPage_OnInternalIdle, METH_O, NULL},
 
5131
         { (char *)"PyWizardPage_swigregister", PyWizardPage_swigregister, METH_VARARGS, NULL},
 
5132
         { (char *)"PyWizardPage_swiginit", PyWizardPage_swiginit, METH_VARARGS, NULL},
 
5133
         { (char *)"new_WizardPageSimple", (PyCFunction) _wrap_new_WizardPageSimple, METH_VARARGS | METH_KEYWORDS, NULL},
 
5134
         { (char *)"new_PreWizardPageSimple", (PyCFunction)_wrap_new_PreWizardPageSimple, METH_NOARGS, NULL},
 
5135
         { (char *)"WizardPageSimple_Create", (PyCFunction) _wrap_WizardPageSimple_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
5136
         { (char *)"WizardPageSimple_SetPrev", (PyCFunction) _wrap_WizardPageSimple_SetPrev, METH_VARARGS | METH_KEYWORDS, NULL},
 
5137
         { (char *)"WizardPageSimple_SetNext", (PyCFunction) _wrap_WizardPageSimple_SetNext, METH_VARARGS | METH_KEYWORDS, NULL},
 
5138
         { (char *)"WizardPageSimple_Chain", (PyCFunction) _wrap_WizardPageSimple_Chain, METH_VARARGS | METH_KEYWORDS, NULL},
 
5139
         { (char *)"WizardPageSimple_swigregister", WizardPageSimple_swigregister, METH_VARARGS, NULL},
 
5140
         { (char *)"WizardPageSimple_swiginit", WizardPageSimple_swiginit, METH_VARARGS, NULL},
 
5141
         { (char *)"new_Wizard", (PyCFunction) _wrap_new_Wizard, METH_VARARGS | METH_KEYWORDS, NULL},
 
5142
         { (char *)"new_PreWizard", (PyCFunction)_wrap_new_PreWizard, METH_NOARGS, NULL},
 
5143
         { (char *)"Wizard_Create", (PyCFunction) _wrap_Wizard_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
5144
         { (char *)"Wizard_Init", (PyCFunction)_wrap_Wizard_Init, METH_O, NULL},
 
5145
         { (char *)"Wizard_RunWizard", (PyCFunction) _wrap_Wizard_RunWizard, METH_VARARGS | METH_KEYWORDS, NULL},
 
5146
         { (char *)"Wizard_GetCurrentPage", (PyCFunction)_wrap_Wizard_GetCurrentPage, METH_O, NULL},
 
5147
         { (char *)"Wizard_SetPageSize", (PyCFunction) _wrap_Wizard_SetPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
5148
         { (char *)"Wizard_GetPageSize", (PyCFunction)_wrap_Wizard_GetPageSize, METH_O, NULL},
 
5149
         { (char *)"Wizard_FitToPage", (PyCFunction) _wrap_Wizard_FitToPage, METH_VARARGS | METH_KEYWORDS, NULL},
 
5150
         { (char *)"Wizard_GetPageAreaSizer", (PyCFunction)_wrap_Wizard_GetPageAreaSizer, METH_O, NULL},
 
5151
         { (char *)"Wizard_SetBorder", (PyCFunction) _wrap_Wizard_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
 
5152
         { (char *)"Wizard_GetBitmap", (PyCFunction)_wrap_Wizard_GetBitmap, METH_O, NULL},
 
5153
         { (char *)"Wizard_SetBitmap", (PyCFunction) _wrap_Wizard_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
5154
         { (char *)"Wizard_IsRunning", (PyCFunction)_wrap_Wizard_IsRunning, METH_O, NULL},
 
5155
         { (char *)"Wizard_SetBitmapBackgroundColour", (PyCFunction) _wrap_Wizard_SetBitmapBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
5156
         { (char *)"Wizard_GetBitmapBackgroundColour", (PyCFunction)_wrap_Wizard_GetBitmapBackgroundColour, METH_O, NULL},
 
5157
         { (char *)"Wizard_SetBitmapPlacement", (PyCFunction) _wrap_Wizard_SetBitmapPlacement, METH_VARARGS | METH_KEYWORDS, NULL},
 
5158
         { (char *)"Wizard_GetBitmapPlacement", (PyCFunction)_wrap_Wizard_GetBitmapPlacement, METH_O, NULL},
 
5159
         { (char *)"Wizard_SetMinimumBitmapWidth", (PyCFunction) _wrap_Wizard_SetMinimumBitmapWidth, METH_VARARGS | METH_KEYWORDS, NULL},
 
5160
         { (char *)"Wizard_GetMinimumBitmapWidth", (PyCFunction)_wrap_Wizard_GetMinimumBitmapWidth, METH_O, NULL},
 
5161
         { (char *)"Wizard_TileBitmap", (PyCFunction) _wrap_Wizard_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
5162
         { (char *)"Wizard_ShowPage", (PyCFunction) _wrap_Wizard_ShowPage, METH_VARARGS | METH_KEYWORDS, NULL},
 
5163
         { (char *)"Wizard_HasNextPage", (PyCFunction) _wrap_Wizard_HasNextPage, METH_VARARGS | METH_KEYWORDS, NULL},
 
5164
         { (char *)"Wizard_HasPrevPage", (PyCFunction) _wrap_Wizard_HasPrevPage, METH_VARARGS | METH_KEYWORDS, NULL},
 
5165
         { (char *)"Wizard_swigregister", Wizard_swigregister, METH_VARARGS, NULL},
 
5166
         { (char *)"Wizard_swiginit", Wizard_swiginit, METH_VARARGS, NULL},
 
5167
         { NULL, NULL, 0, NULL }
 
5168
};
 
5169
 
 
5170
 
 
5171
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
5172
 
 
5173
static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
 
5174
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
 
5175
}
 
5176
static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
 
5177
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
 
5178
}
 
5179
static void *_p_wxEventTo_p_wxObject(void *x) {
 
5180
    return (void *)((wxObject *)  ((wxEvent *) x));
 
5181
}
 
5182
static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
 
5183
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
 
5184
}
 
5185
static void *_p_wxWindowModalDialogEventTo_p_wxObject(void *x) {
 
5186
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowModalDialogEvent *) x));
 
5187
}
 
5188
static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
 
5189
    return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
 
5190
}
 
5191
static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
 
5192
    return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
 
5193
}
 
5194
static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
 
5195
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
 
5196
}
 
5197
static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
 
5198
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
 
5199
}
 
5200
static void *_p_wxMenuItemTo_p_wxObject(void *x) {
 
5201
    return (void *)((wxObject *)  ((wxMenuItem *) x));
 
5202
}
 
5203
static void *_p_wxImageTo_p_wxObject(void *x) {
 
5204
    return (void *)((wxObject *)  ((wxImage *) x));
 
5205
}
 
5206
static void *_p_wxPySizerTo_p_wxObject(void *x) {
 
5207
    return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
 
5208
}
 
5209
static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
 
5210
    return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
 
5211
}
 
5212
static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
 
5213
    return (void *)((wxObject *)  ((wxLayoutAlgorithm *) x));
 
5214
}
 
5215
static void *_p_wxPyAppTo_p_wxObject(void *x) {
 
5216
    return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
 
5217
}
 
5218
static void *_p_wxTextCtrlBaseTo_p_wxObject(void *x) {
 
5219
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxTextCtrlBase *) x));
 
5220
}
 
5221
static void *_p_wxBookCtrlBaseTo_p_wxObject(void *x) {
 
5222
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxBookCtrlBase *) x));
 
5223
}
 
5224
static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
 
5225
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
 
5226
}
 
5227
static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
 
5228
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
 
5229
}
 
5230
static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
 
5231
    return (void *)((wxObject *)  ((wxFindReplaceData *) x));
 
5232
}
 
5233
static void *_p_wxValidatorTo_p_wxObject(void *x) {
 
5234
    return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
 
5235
}
 
5236
static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
 
5237
    return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
 
5238
}
 
5239
static void *_p_wxEraseEventTo_p_wxObject(void *x) {
 
5240
    return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
 
5241
}
 
5242
static void *_p_wxMouseEventTo_p_wxObject(void *x) {
 
5243
    return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
 
5244
}
 
5245
static void *_p_wxCloseEventTo_p_wxObject(void *x) {
 
5246
    return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
 
5247
}
 
5248
static void *_p_wxWrapSizerTo_p_wxObject(void *x) {
 
5249
    return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxWrapSizer *) x));
 
5250
}
 
5251
static void *_p_wxPyWizardPageTo_p_wxObject(void *x) {
 
5252
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxWizardPage *) ((wxPyWizardPage *) x));
 
5253
}
 
5254
static void *_p_wxWizardPageTo_p_wxObject(void *x) {
 
5255
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxWizardPage *) x));
 
5256
}
 
5257
static void *_p_wxScrollEventTo_p_wxObject(void *x) {
 
5258
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
 
5259
}
 
5260
static void *_p_wxBookCtrlEventTo_p_wxObject(void *x) {
 
5261
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxBookCtrlEvent *) x));
 
5262
}
 
5263
static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
 
5264
    return (void *)((wxObject *)  ((wxPrintDialogData *) x));
 
5265
}
 
5266
static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
 
5267
    return (void *)((wxObject *)  ((wxPageSetupDialogData *) x));
 
5268
}
 
5269
static void *_p_wxPrinterTo_p_wxObject(void *x) {
 
5270
    return (void *)((wxObject *)  ((wxPrinter *) x));
 
5271
}
 
5272
static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
 
5273
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
 
5274
}
 
5275
static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
 
5276
    return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
 
5277
}
 
5278
static void *_p_wxGridSizerTo_p_wxObject(void *x) {
 
5279
    return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
 
5280
}
 
5281
static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
 
5282
    return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
 
5283
}
 
5284
static void *_p_wxControlTo_p_wxObject(void *x) {
 
5285
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
 
5286
}
 
5287
static void *_p_wxColourDataTo_p_wxObject(void *x) {
 
5288
    return (void *)((wxObject *)  ((wxColourData *) x));
 
5289
}
 
5290
static void *_p_wxMoveEventTo_p_wxObject(void *x) {
 
5291
    return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
 
5292
}
 
5293
static void *_p_wxSizeEventTo_p_wxObject(void *x) {
 
5294
    return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
 
5295
}
 
5296
static void *_p_wxActivateEventTo_p_wxObject(void *x) {
 
5297
    return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
 
5298
}
 
5299
static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
 
5300
    return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
 
5301
}
 
5302
static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
 
5303
    return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
 
5304
}
 
5305
static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
 
5306
    return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
 
5307
}
 
5308
static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
 
5309
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
 
5310
}
 
5311
static void *_p_wxIdleEventTo_p_wxObject(void *x) {
 
5312
    return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
 
5313
}
 
5314
static void *_p_wxDateEventTo_p_wxObject(void *x) {
 
5315
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
 
5316
}
 
5317
static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
 
5318
    return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
 
5319
}
 
5320
static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
 
5321
    return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
 
5322
}
 
5323
static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
 
5324
    return (void *)((wxObject *)  ((wxPyPrintout *) x));
 
5325
}
 
5326
static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
 
5327
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
 
5328
}
 
5329
static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
 
5330
    return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
 
5331
}
 
5332
static void *_p_wxKeyEventTo_p_wxObject(void *x) {
 
5333
    return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
 
5334
}
 
5335
static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
 
5336
    return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
 
5337
}
 
5338
static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
 
5339
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
 
5340
}
 
5341
static void *_p_wxSashEventTo_p_wxObject(void *x) {
 
5342
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
 
5343
}
 
5344
static void *_p_wxSimpleHtmlListBoxTo_p_wxObject(void *x) {
 
5345
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
 
5346
}
 
5347
static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
 
5348
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
 
5349
}
 
5350
static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
 
5351
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
 
5352
}
 
5353
static void *_p_wxPrintDataTo_p_wxObject(void *x) {
 
5354
    return (void *)((wxObject *)  ((wxPrintData *) x));
 
5355
}
 
5356
static void *_p_wxFontDataTo_p_wxObject(void *x) {
 
5357
    return (void *)((wxObject *)  ((wxFontData *) x));
 
5358
}
 
5359
static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
 
5360
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
 
5361
}
 
5362
static void *_p_wxFrameTo_p_wxObject(void *x) {
 
5363
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
 
5364
}
 
5365
static void *_p_wxPyPanelTo_p_wxObject(void *x) {
 
5366
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
 
5367
}
 
5368
static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
 
5369
    return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
 
5370
}
 
5371
static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
 
5372
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
 
5373
}
 
5374
static void *_p_wxFileSystemTo_p_wxObject(void *x) {
 
5375
    return (void *)((wxObject *)  ((wxFileSystem *) x));
 
5376
}
 
5377
static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
 
5378
    return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
 
5379
}
 
5380
static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
 
5381
    return (void *)((wxObject *)  ((wxPrintPreview *) x));
 
5382
}
 
5383
static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
 
5384
    return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
 
5385
}
 
5386
static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
 
5387
    return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
 
5388
}
 
5389
static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
 
5390
    return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
 
5391
}
 
5392
static void *_p_wxSizerTo_p_wxObject(void *x) {
 
5393
    return (void *)((wxObject *)  ((wxSizer *) x));
 
5394
}
 
5395
static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
 
5396
    return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
 
5397
}
 
5398
static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
 
5399
    return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
 
5400
}
 
5401
static void *_p_wxPaintEventTo_p_wxObject(void *x) {
 
5402
    return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
 
5403
}
 
5404
static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
 
5405
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
 
5406
}
 
5407
static void *_p_wxFSFileTo_p_wxObject(void *x) {
 
5408
    return (void *)((wxObject *)  ((wxFSFile *) x));
 
5409
}
 
5410
static void *_p_wxStandardDialogLayoutAdapterTo_p_wxObject(void *x) {
 
5411
    return (void *)((wxObject *) (wxDialogLayoutAdapter *) ((wxStandardDialogLayoutAdapter *) x));
 
5412
}
 
5413
static void *_p_wxDialogLayoutAdapterTo_p_wxObject(void *x) {
 
5414
    return (void *)((wxObject *)  ((wxDialogLayoutAdapter *) x));
 
5415
}
 
5416
static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
 
5417
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
 
5418
}
 
5419
static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
 
5420
    return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
 
5421
}
 
5422
static void *_p_wxMenuTo_p_wxObject(void *x) {
 
5423
    return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
 
5424
}
 
5425
static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
 
5426
    return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
 
5427
}
 
5428
static void *_p_wxSizerItemTo_p_wxObject(void *x) {
 
5429
    return (void *)((wxObject *)  ((wxSizerItem *) x));
 
5430
}
 
5431
static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
 
5432
    return (void *)((wxObject *)  ((wxPrintDialog *) x));
 
5433
}
 
5434
static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
 
5435
    return (void *)((wxObject *)  ((wxPageSetupDialog *) x));
 
5436
}
 
5437
static void *_p_wxFontDialogTo_p_wxObject(void *x) {
 
5438
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
 
5439
}
 
5440
static void *_p_wxDirDialogTo_p_wxObject(void *x) {
 
5441
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
 
5442
}
 
5443
static void *_p_wxColourDialogTo_p_wxObject(void *x) {
 
5444
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
 
5445
}
 
5446
static void *_p_wxDialogTo_p_wxObject(void *x) {
 
5447
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
 
5448
}
 
5449
static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
 
5450
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
 
5451
}
 
5452
static void *_p_wxPyEventTo_p_wxObject(void *x) {
 
5453
    return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
 
5454
}
 
5455
static void *_p_wxPyEvtHandlerTo_p_wxObject(void *x) {
 
5456
    return (void *)((wxObject *) (wxEvtHandler *) ((wxPyEvtHandler *) x));
 
5457
}
 
5458
static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
 
5459
    return (void *)((wxObject *)  ((wxEvtHandler *) x));
 
5460
}
 
5461
static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
 
5462
    return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
 
5463
}
 
5464
static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
 
5465
    return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
 
5466
}
 
5467
static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
 
5468
    return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
 
5469
}
 
5470
static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
 
5471
    return (void *)((wxObject *)  ((wxImageHandler *) x));
 
5472
}
 
5473
static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
 
5474
    return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
 
5475
}
 
5476
static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
 
5477
    return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
 
5478
}
 
5479
static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
 
5480
    return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
 
5481
}
 
5482
static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
 
5483
    return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
 
5484
}
 
5485
static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
 
5486
    return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
 
5487
}
 
5488
static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
 
5489
    return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
 
5490
}
 
5491
static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
 
5492
    return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
 
5493
}
 
5494
static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
 
5495
    return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
 
5496
}
 
5497
static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
 
5498
    return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
 
5499
}
 
5500
static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
 
5501
    return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
 
5502
}
 
5503
static void *_p_wxShowEventTo_p_wxObject(void *x) {
 
5504
    return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
 
5505
}
 
5506
static void *_p_wxWizardTo_p_wxObject(void *x) {
 
5507
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxWizard *) x));
 
5508
}
 
5509
static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
 
5510
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
 
5511
}
 
5512
static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
 
5513
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
 
5514
}
 
5515
static void *_p_wxPyHVScrolledWindowTo_p_wxObject(void *x) {
 
5516
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyHVScrolledWindow *) x));
 
5517
}
 
5518
static void *_p_wxPyHScrolledWindowTo_p_wxObject(void *x) {
 
5519
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyHScrolledWindow *) x));
 
5520
}
 
5521
static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
 
5522
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
 
5523
}
 
5524
static void *_p_wxTipWindowTo_p_wxObject(void *x) {
 
5525
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
 
5526
}
 
5527
static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
 
5528
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
 
5529
}
 
5530
static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
 
5531
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
 
5532
}
 
5533
static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
 
5534
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
 
5535
}
 
5536
static void *_p_wxSashWindowTo_p_wxObject(void *x) {
 
5537
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
 
5538
}
 
5539
static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
 
5540
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
 
5541
}
 
5542
static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
 
5543
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
 
5544
}
 
5545
static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
 
5546
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
 
5547
}
 
5548
static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
 
5549
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
 
5550
}
 
5551
static void *_p_wxWindowTo_p_wxObject(void *x) {
 
5552
    return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
 
5553
}
 
5554
static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
 
5555
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
 
5556
}
 
5557
static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
 
5558
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxGenericProgressDialog *) ((wxProgressDialog *) x));
 
5559
}
 
5560
static void *_p_wxGenericProgressDialogTo_p_wxObject(void *x) {
 
5561
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxGenericProgressDialog *) x));
 
5562
}
 
5563
static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
 
5564
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
 
5565
}
 
5566
static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
 
5567
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
 
5568
}
 
5569
static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
 
5570
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
 
5571
}
 
5572
static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
 
5573
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
 
5574
}
 
5575
static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
 
5576
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
 
5577
}
 
5578
static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
 
5579
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
 
5580
}
 
5581
static void *_p_wxFileDialogTo_p_wxObject(void *x) {
 
5582
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
 
5583
}
 
5584
static void *_p_wxPyWindowTo_p_wxObject(void *x) {
 
5585
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
 
5586
}
 
5587
static void *_p_wxThreadEventTo_p_wxObject(void *x) {
 
5588
    return (void *)((wxObject *) (wxEvent *) ((wxThreadEvent *) x));
 
5589
}
 
5590
static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
 
5591
    return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
 
5592
}
 
5593
static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
 
5594
    return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
 
5595
}
 
5596
static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
 
5597
    return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
 
5598
}
 
5599
static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
 
5600
    return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
 
5601
}
 
5602
static void *_p_wxWizardPageSimpleTo_p_wxObject(void *x) {
 
5603
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxWizardPage *) ((wxWizardPageSimple *) x));
 
5604
}
 
5605
static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
 
5606
    return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
 
5607
}
 
5608
static void *_p_wxPanelTo_p_wxObject(void *x) {
 
5609
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
 
5610
}
 
5611
static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
 
5612
    return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
 
5613
}
 
5614
static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
 
5615
    return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
 
5616
}
 
5617
static void *_p_wxMenuEventTo_p_wxObject(void *x) {
 
5618
    return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
 
5619
}
 
5620
static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
 
5621
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
 
5622
}
 
5623
static void *_p_wxWizardEventTo_p_wxObject(void *x) {
 
5624
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxWizardEvent *) x));
 
5625
}
 
5626
static void *_p_wxCommandEventTo_p_wxObject(void *x) {
 
5627
    return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
 
5628
}
 
5629
static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
 
5630
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
 
5631
}
 
5632
static void *_p_wxStatusBarTo_p_wxObject(void *x) {
 
5633
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
 
5634
}
 
5635
static void *_p_wxFocusEventTo_p_wxObject(void *x) {
 
5636
    return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
 
5637
}
 
5638
static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
 
5639
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
 
5640
}
 
5641
static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
 
5642
    return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
 
5643
}
 
5644
static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
 
5645
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
 
5646
}
 
5647
static void *_p_wxMenuBarTo_p_wxObject(void *x) {
 
5648
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
 
5649
}
 
5650
static void *_p_wxFontDialogTo_p_wxDialog(void *x) {
 
5651
    return (void *)((wxDialog *)  ((wxFontDialog *) x));
 
5652
}
 
5653
static void *_p_wxDirDialogTo_p_wxDialog(void *x) {
 
5654
    return (void *)((wxDialog *)  ((wxDirDialog *) x));
 
5655
}
 
5656
static void *_p_wxColourDialogTo_p_wxDialog(void *x) {
 
5657
    return (void *)((wxDialog *)  ((wxColourDialog *) x));
 
5658
}
 
5659
static void *_p_wxWizardTo_p_wxDialog(void *x) {
 
5660
    return (void *)((wxDialog *)  ((wxWizard *) x));
 
5661
}
 
5662
static void *_p_wxFindReplaceDialogTo_p_wxDialog(void *x) {
 
5663
    return (void *)((wxDialog *)  ((wxFindReplaceDialog *) x));
 
5664
}
 
5665
static void *_p_wxProgressDialogTo_p_wxDialog(void *x) {
 
5666
    return (void *)((wxDialog *) (wxGenericProgressDialog *) ((wxProgressDialog *) x));
 
5667
}
 
5668
static void *_p_wxGenericProgressDialogTo_p_wxDialog(void *x) {
 
5669
    return (void *)((wxDialog *)  ((wxGenericProgressDialog *) x));
 
5670
}
 
5671
static void *_p_wxMessageDialogTo_p_wxDialog(void *x) {
 
5672
    return (void *)((wxDialog *)  ((wxMessageDialog *) x));
 
5673
}
 
5674
static void *_p_wxNumberEntryDialogTo_p_wxDialog(void *x) {
 
5675
    return (void *)((wxDialog *)  ((wxNumberEntryDialog *) x));
 
5676
}
 
5677
static void *_p_wxPasswordEntryDialogTo_p_wxDialog(void *x) {
 
5678
    return (void *)((wxDialog *) (wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
 
5679
}
 
5680
static void *_p_wxTextEntryDialogTo_p_wxDialog(void *x) {
 
5681
    return (void *)((wxDialog *)  ((wxTextEntryDialog *) x));
 
5682
}
 
5683
static void *_p_wxSingleChoiceDialogTo_p_wxDialog(void *x) {
 
5684
    return (void *)((wxDialog *)  ((wxSingleChoiceDialog *) x));
 
5685
}
 
5686
static void *_p_wxMultiChoiceDialogTo_p_wxDialog(void *x) {
 
5687
    return (void *)((wxDialog *)  ((wxMultiChoiceDialog *) x));
 
5688
}
 
5689
static void *_p_wxFileDialogTo_p_wxDialog(void *x) {
 
5690
    return (void *)((wxDialog *)  ((wxFileDialog *) x));
 
5691
}
 
5692
static void *_p_wxWizardPageSimpleTo_p_wxWizardPage(void *x) {
 
5693
    return (void *)((wxWizardPage *)  ((wxWizardPageSimple *) x));
 
5694
}
 
5695
static void *_p_wxPyWizardPageTo_p_wxWizardPage(void *x) {
 
5696
    return (void *)((wxWizardPage *)  ((wxPyWizardPage *) x));
 
5697
}
 
5698
static void *_p_wxFrameTo_p_wxTopLevelWindow(void *x) {
 
5699
    return (void *)((wxTopLevelWindow *)  ((wxFrame *) x));
 
5700
}
 
5701
static void *_p_wxMiniFrameTo_p_wxTopLevelWindow(void *x) {
 
5702
    return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMiniFrame *) x));
 
5703
}
 
5704
static void *_p_wxFontDialogTo_p_wxTopLevelWindow(void *x) {
 
5705
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFontDialog *) x));
 
5706
}
 
5707
static void *_p_wxDirDialogTo_p_wxTopLevelWindow(void *x) {
 
5708
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxDirDialog *) x));
 
5709
}
 
5710
static void *_p_wxColourDialogTo_p_wxTopLevelWindow(void *x) {
 
5711
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxColourDialog *) x));
 
5712
}
 
5713
static void *_p_wxDialogTo_p_wxTopLevelWindow(void *x) {
 
5714
    return (void *)((wxTopLevelWindow *)  ((wxDialog *) x));
 
5715
}
 
5716
static void *_p_wxSplashScreenTo_p_wxTopLevelWindow(void *x) {
 
5717
    return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxSplashScreen *) x));
 
5718
}
 
5719
static void *_p_wxTipWindowTo_p_wxTopLevelWindow(void *x) {
 
5720
    return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxTipWindow *) x));
 
5721
}
 
5722
static void *_p_wxMDIParentFrameTo_p_wxTopLevelWindow(void *x) {
 
5723
    return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIParentFrame *) x));
 
5724
}
 
5725
static void *_p_wxMDIChildFrameTo_p_wxTopLevelWindow(void *x) {
 
5726
    return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxMDIChildFrame *) x));
 
5727
}
 
5728
static void *_p_wxWizardTo_p_wxTopLevelWindow(void *x) {
 
5729
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxWizard *) x));
 
5730
}
 
5731
static void *_p_wxNumberEntryDialogTo_p_wxTopLevelWindow(void *x) {
 
5732
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxNumberEntryDialog *) x));
 
5733
}
 
5734
static void *_p_wxPasswordEntryDialogTo_p_wxTopLevelWindow(void *x) {
 
5735
    return (void *)((wxTopLevelWindow *) (wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
 
5736
}
 
5737
static void *_p_wxTextEntryDialogTo_p_wxTopLevelWindow(void *x) {
 
5738
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxTextEntryDialog *) x));
 
5739
}
 
5740
static void *_p_wxSingleChoiceDialogTo_p_wxTopLevelWindow(void *x) {
 
5741
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxSingleChoiceDialog *) x));
 
5742
}
 
5743
static void *_p_wxMultiChoiceDialogTo_p_wxTopLevelWindow(void *x) {
 
5744
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMultiChoiceDialog *) x));
 
5745
}
 
5746
static void *_p_wxFileDialogTo_p_wxTopLevelWindow(void *x) {
 
5747
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFileDialog *) x));
 
5748
}
 
5749
static void *_p_wxMessageDialogTo_p_wxTopLevelWindow(void *x) {
 
5750
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxMessageDialog *) x));
 
5751
}
 
5752
static void *_p_wxGenericProgressDialogTo_p_wxTopLevelWindow(void *x) {
 
5753
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxGenericProgressDialog *) x));
 
5754
}
 
5755
static void *_p_wxProgressDialogTo_p_wxTopLevelWindow(void *x) {
 
5756
    return (void *)((wxTopLevelWindow *) (wxDialog *)(wxGenericProgressDialog *) ((wxProgressDialog *) x));
 
5757
}
 
5758
static void *_p_wxFindReplaceDialogTo_p_wxTopLevelWindow(void *x) {
 
5759
    return (void *)((wxTopLevelWindow *) (wxDialog *) ((wxFindReplaceDialog *) x));
 
5760
}
 
5761
static void *_p_wxPreviewFrameTo_p_wxTopLevelWindow(void *x) {
 
5762
    return (void *)((wxTopLevelWindow *) (wxFrame *) ((wxPreviewFrame *) x));
 
5763
}
 
5764
static void *_p_wxPyPreviewFrameTo_p_wxTopLevelWindow(void *x) {
 
5765
    return (void *)((wxTopLevelWindow *) (wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
 
5766
}
 
5767
static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
 
5768
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
 
5769
}
 
5770
static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
 
5771
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
 
5772
}
 
5773
static void *_p_wxWizardPageTo_p_wxWindow(void *x) {
 
5774
    return (void *)((wxWindow *) (wxPanel *) ((wxWizardPage *) x));
 
5775
}
 
5776
static void *_p_wxPyWizardPageTo_p_wxWindow(void *x) {
 
5777
    return (void *)((wxWindow *) (wxPanel *)(wxWizardPage *) ((wxPyWizardPage *) x));
 
5778
}
 
5779
static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
 
5780
    return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
 
5781
}
 
5782
static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
 
5783
    return (void *)((wxWindow *)  ((wxMenuBar *) x));
 
5784
}
 
5785
static void *_p_wxTextCtrlBaseTo_p_wxWindow(void *x) {
 
5786
    return (void *)((wxWindow *) (wxControl *) ((wxTextCtrlBase *) x));
 
5787
}
 
5788
static void *_p_wxBookCtrlBaseTo_p_wxWindow(void *x) {
 
5789
    return (void *)((wxWindow *) (wxControl *) ((wxBookCtrlBase *) x));
 
5790
}
 
5791
static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
 
5792
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
 
5793
}
 
5794
static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
 
5795
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
 
5796
}
 
5797
static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
 
5798
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
 
5799
}
 
5800
static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
 
5801
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
 
5802
}
 
5803
static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
 
5804
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
 
5805
}
 
5806
static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
 
5807
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
 
5808
}
 
5809
static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
 
5810
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
 
5811
}
 
5812
static void *_p_wxGenericProgressDialogTo_p_wxWindow(void *x) {
 
5813
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxGenericProgressDialog *) x));
 
5814
}
 
5815
static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
 
5816
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxGenericProgressDialog *) ((wxProgressDialog *) x));
 
5817
}
 
5818
static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
 
5819
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
 
5820
}
 
5821
static void *_p_wxPanelTo_p_wxWindow(void *x) {
 
5822
    return (void *)((wxWindow *)  ((wxPanel *) x));
 
5823
}
 
5824
static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
 
5825
    return (void *)((wxWindow *)  ((wxStatusBar *) x));
 
5826
}
 
5827
static void *_p_wxPyHVScrolledWindowTo_p_wxWindow(void *x) {
 
5828
    return (void *)((wxWindow *) (wxPanel *) ((wxPyHVScrolledWindow *) x));
 
5829
}
 
5830
static void *_p_wxPyHScrolledWindowTo_p_wxWindow(void *x) {
 
5831
    return (void *)((wxWindow *) (wxPanel *) ((wxPyHScrolledWindow *) x));
 
5832
}
 
5833
static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
 
5834
    return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
 
5835
}
 
5836
static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
 
5837
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
 
5838
}
 
5839
static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
 
5840
    return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
 
5841
}
 
5842
static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
 
5843
    return (void *)((wxWindow *)  ((wxPopupWindow *) x));
 
5844
}
 
5845
static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
 
5846
    return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
 
5847
}
 
5848
static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
 
5849
    return (void *)((wxWindow *)  ((wxSashWindow *) x));
 
5850
}
 
5851
static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
 
5852
    return (void *)((wxWindow *)  ((wxSplitterWindow *) x));
 
5853
}
 
5854
static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
 
5855
    return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
 
5856
}
 
5857
static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
 
5858
    return (void *)((wxWindow *)  ((wxTopLevelWindow *) x));
 
5859
}
 
5860
static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
 
5861
    return (void *)((wxWindow *)  ((wxSplashScreenWindow *) x));
 
5862
}
 
5863
static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
 
5864
    return (void *)((wxWindow *)  ((wxMDIClientWindow *) x));
 
5865
}
 
5866
static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
 
5867
    return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
 
5868
}
 
5869
static void *_p_wxControlTo_p_wxWindow(void *x) {
 
5870
    return (void *)((wxWindow *)  ((wxControl *) x));
 
5871
}
 
5872
static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
 
5873
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
 
5874
}
 
5875
static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
 
5876
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
 
5877
}
 
5878
static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
 
5879
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
 
5880
}
 
5881
static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
 
5882
    return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
 
5883
}
 
5884
static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
 
5885
    return (void *)((wxWindow *)  ((wxPyWindow *) x));
 
5886
}
 
5887
static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
 
5888
    return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
 
5889
}
 
5890
static void *_p_wxSimpleHtmlListBoxTo_p_wxWindow(void *x) {
 
5891
    return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
 
5892
}
 
5893
static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
 
5894
    return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
 
5895
}
 
5896
static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
 
5897
    return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
 
5898
}
 
5899
static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
 
5900
    return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
 
5901
}
 
5902
static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
 
5903
    return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
 
5904
}
 
5905
static void *_p_wxWizardTo_p_wxWindow(void *x) {
 
5906
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxWizard *) x));
 
5907
}
 
5908
static void *_p_wxWizardPageSimpleTo_p_wxWindow(void *x) {
 
5909
    return (void *)((wxWindow *) (wxPanel *)(wxWizardPage *) ((wxWizardPageSimple *) x));
 
5910
}
 
5911
static void *_p_wxFrameTo_p_wxWindow(void *x) {
 
5912
    return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
 
5913
}
 
5914
static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
 
5915
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
 
5916
}
 
5917
static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
 
5918
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
 
5919
}
 
5920
static void *_p_wxDialogTo_p_wxWindow(void *x) {
 
5921
    return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
 
5922
}
 
5923
static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
 
5924
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
 
5925
}
 
5926
static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
 
5927
    return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
 
5928
}
 
5929
static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
 
5930
    return (void *)((wxCommandEvent *)  ((wxSashEvent *) x));
 
5931
}
 
5932
static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
 
5933
    return (void *)((wxCommandEvent *)  ((wxWindowDestroyEvent *) x));
 
5934
}
 
5935
static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
 
5936
    return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
 
5937
}
 
5938
static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
 
5939
    return (void *)((wxCommandEvent *)  ((wxClipboardTextEvent *) x));
 
5940
}
 
5941
static void *_p_wxBookCtrlEventTo_p_wxCommandEvent(void *x) {
 
5942
    return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxBookCtrlEvent *) x));
 
5943
}
 
5944
static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
 
5945
    return (void *)((wxCommandEvent *)  ((wxScrollEvent *) x));
 
5946
}
 
5947
static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
 
5948
    return (void *)((wxCommandEvent *)  ((wxPyCommandEvent *) x));
 
5949
}
 
5950
static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
 
5951
    return (void *)((wxCommandEvent *)  ((wxContextMenuEvent *) x));
 
5952
}
 
5953
static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
 
5954
    return (void *)((wxCommandEvent *)  ((wxChildFocusEvent *) x));
 
5955
}
 
5956
static void *_p_wxWizardEventTo_p_wxCommandEvent(void *x) {
 
5957
    return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxWizardEvent *) x));
 
5958
}
 
5959
static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
 
5960
    return (void *)((wxCommandEvent *)  ((wxDateEvent *) x));
 
5961
}
 
5962
static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
 
5963
    return (void *)((wxCommandEvent *)  ((wxWindowCreateEvent *) x));
 
5964
}
 
5965
static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
 
5966
    return (void *)((wxCommandEvent *)  ((wxNotifyEvent *) x));
 
5967
}
 
5968
static void *_p_wxWindowModalDialogEventTo_p_wxCommandEvent(void *x) {
 
5969
    return (void *)((wxCommandEvent *)  ((wxWindowModalDialogEvent *) x));
 
5970
}
 
5971
static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
 
5972
    return (void *)((wxCommandEvent *)  ((wxUpdateUIEvent *) x));
 
5973
}
 
5974
static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
 
5975
    return (void *)((wxCommandEvent *)  ((wxFindDialogEvent *) x));
 
5976
}
 
5977
static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
 
5978
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
 
5979
}
 
5980
static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
 
5981
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
 
5982
}
 
5983
static void *_p_wxWizardPageTo_p_wxEvtHandler(void *x) {
 
5984
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxWizardPage *) x));
 
5985
}
 
5986
static void *_p_wxPyWizardPageTo_p_wxEvtHandler(void *x) {
 
5987
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxWizardPage *) ((wxPyWizardPage *) x));
 
5988
}
 
5989
static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
 
5990
    return (void *)((wxEvtHandler *)  ((wxEventBlocker *) x));
 
5991
}
 
5992
static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
 
5993
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
 
5994
}
 
5995
static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
 
5996
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
 
5997
}
 
5998
static void *_p_wxTextCtrlBaseTo_p_wxEvtHandler(void *x) {
 
5999
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxTextCtrlBase *) x));
 
6000
}
 
6001
static void *_p_wxBookCtrlBaseTo_p_wxEvtHandler(void *x) {
 
6002
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxBookCtrlBase *) x));
 
6003
}
 
6004
static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
 
6005
    return (void *)((wxEvtHandler *)  ((wxValidator *) x));
 
6006
}
 
6007
static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
 
6008
    return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
 
6009
}
 
6010
static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
 
6011
    return (void *)((wxEvtHandler *)  ((wxMenu *) x));
 
6012
}
 
6013
static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
 
6014
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
 
6015
}
 
6016
static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
 
6017
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
 
6018
}
 
6019
static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
 
6020
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
 
6021
}
 
6022
static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
 
6023
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
 
6024
}
 
6025
static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
 
6026
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
 
6027
}
 
6028
static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
 
6029
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
 
6030
}
 
6031
static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
 
6032
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
 
6033
}
 
6034
static void *_p_wxGenericProgressDialogTo_p_wxEvtHandler(void *x) {
 
6035
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxGenericProgressDialog *) x));
 
6036
}
 
6037
static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
 
6038
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxGenericProgressDialog *) ((wxProgressDialog *) x));
 
6039
}
 
6040
static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
 
6041
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
 
6042
}
 
6043
static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
 
6044
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
 
6045
}
 
6046
static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
 
6047
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
 
6048
}
 
6049
static void *_p_wxPyHVScrolledWindowTo_p_wxEvtHandler(void *x) {
 
6050
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyHVScrolledWindow *) x));
 
6051
}
 
6052
static void *_p_wxPyHScrolledWindowTo_p_wxEvtHandler(void *x) {
 
6053
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyHScrolledWindow *) x));
 
6054
}
 
6055
static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
 
6056
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
 
6057
}
 
6058
static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
 
6059
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
 
6060
}
 
6061
static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
 
6062
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
 
6063
}
 
6064
static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
 
6065
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
 
6066
}
 
6067
static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
 
6068
    return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
 
6069
}
 
6070
static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
 
6071
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
 
6072
}
 
6073
static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
 
6074
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
 
6075
}
 
6076
static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
 
6077
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
 
6078
}
 
6079
static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
 
6080
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
 
6081
}
 
6082
static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
 
6083
    return (void *)((wxEvtHandler *)  ((wxWindow *) x));
 
6084
}
 
6085
static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
 
6086
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
 
6087
}
 
6088
static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
 
6089
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
 
6090
}
 
6091
static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
 
6092
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
 
6093
}
 
6094
static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
 
6095
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
 
6096
}
 
6097
static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
 
6098
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
 
6099
}
 
6100
static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
 
6101
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
 
6102
}
 
6103
static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
 
6104
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
 
6105
}
 
6106
static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
 
6107
    return (void *)((wxEvtHandler *)  ((wxPyApp *) x));
 
6108
}
 
6109
static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
 
6110
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
 
6111
}
 
6112
static void *_p_wxPyEvtHandlerTo_p_wxEvtHandler(void *x) {
 
6113
    return (void *)((wxEvtHandler *)  ((wxPyEvtHandler *) x));
 
6114
}
 
6115
static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
 
6116
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
 
6117
}
 
6118
static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
 
6119
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
 
6120
}
 
6121
static void *_p_wxSimpleHtmlListBoxTo_p_wxEvtHandler(void *x) {
 
6122
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
 
6123
}
 
6124
static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
 
6125
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
 
6126
}
 
6127
static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
 
6128
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
 
6129
}
 
6130
static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
 
6131
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
 
6132
}
 
6133
static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
 
6134
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
 
6135
}
 
6136
static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
 
6137
    return (void *)((wxEvtHandler *)  ((wxPyTaskBarIcon *) x));
 
6138
}
 
6139
static void *_p_wxWizardTo_p_wxEvtHandler(void *x) {
 
6140
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxWizard *) x));
 
6141
}
 
6142
static void *_p_wxWizardPageSimpleTo_p_wxEvtHandler(void *x) {
 
6143
    return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxWizardPage *) ((wxWizardPageSimple *) x));
 
6144
}
 
6145
static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
 
6146
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
 
6147
}
 
6148
static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
 
6149
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
 
6150
}
 
6151
static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
 
6152
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
 
6153
}
 
6154
static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
 
6155
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
 
6156
}
 
6157
static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
 
6158
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
 
6159
}
 
6160
static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
 
6161
    return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
 
6162
}
 
6163
static void *_p_wxBookCtrlEventTo_p_wxNotifyEvent(void *x) {
 
6164
    return (void *)((wxNotifyEvent *)  ((wxBookCtrlEvent *) x));
 
6165
}
 
6166
static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
 
6167
    return (void *)((wxNotifyEvent *)  ((wxSplitterEvent *) x));
 
6168
}
 
6169
static void *_p_wxWizardEventTo_p_wxNotifyEvent(void *x) {
 
6170
    return (void *)((wxNotifyEvent *)  ((wxWizardEvent *) x));
 
6171
}
 
6172
static void *_p_wxSimpleHtmlListBoxTo_p_wxPanel(void *x) {
 
6173
    return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
 
6174
}
 
6175
static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
 
6176
    return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
 
6177
}
 
6178
static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
 
6179
    return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
 
6180
}
 
6181
static void *_p_wxWizardPageSimpleTo_p_wxPanel(void *x) {
 
6182
    return (void *)((wxPanel *) (wxWizardPage *) ((wxWizardPageSimple *) x));
 
6183
}
 
6184
static void *_p_wxPyWizardPageTo_p_wxPanel(void *x) {
 
6185
    return (void *)((wxPanel *) (wxWizardPage *) ((wxPyWizardPage *) x));
 
6186
}
 
6187
static void *_p_wxWizardPageTo_p_wxPanel(void *x) {
 
6188
    return (void *)((wxPanel *)  ((wxWizardPage *) x));
 
6189
}
 
6190
static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
 
6191
    return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
 
6192
}
 
6193
static void *_p_wxPyHVScrolledWindowTo_p_wxPanel(void *x) {
 
6194
    return (void *)((wxPanel *)  ((wxPyHVScrolledWindow *) x));
 
6195
}
 
6196
static void *_p_wxPyHScrolledWindowTo_p_wxPanel(void *x) {
 
6197
    return (void *)((wxPanel *)  ((wxPyHScrolledWindow *) x));
 
6198
}
 
6199
static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
 
6200
    return (void *)((wxPanel *)  ((wxPyVScrolledWindow *) x));
 
6201
}
 
6202
static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
 
6203
    return (void *)((wxPanel *)  ((wxScrolledWindow *) x));
 
6204
}
 
6205
static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
 
6206
    return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
 
6207
}
 
6208
static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
 
6209
    return (void *)((wxPanel *)  ((wxPreviewControlBar *) x));
 
6210
}
 
6211
static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
 
6212
    return (void *)((wxPanel *)  ((wxPyPanel *) x));
 
6213
}
 
6214
static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
 
6215
    return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
 
6216
}
 
6217
static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
 
6218
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
 
6219
}
 
6220
static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
 
6221
    return (void *)((wxEvent *)  ((wxMenuEvent *) x));
 
6222
}
 
6223
static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
 
6224
    return (void *)((wxEvent *)  ((wxCloseEvent *) x));
 
6225
}
 
6226
static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
 
6227
    return (void *)((wxEvent *)  ((wxMouseEvent *) x));
 
6228
}
 
6229
static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
 
6230
    return (void *)((wxEvent *)  ((wxEraseEvent *) x));
 
6231
}
 
6232
static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
 
6233
    return (void *)((wxEvent *)  ((wxSetCursorEvent *) x));
 
6234
}
 
6235
static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
 
6236
    return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
 
6237
}
 
6238
static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
 
6239
    return (void *)((wxEvent *)  ((wxInitDialogEvent *) x));
 
6240
}
 
6241
static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
 
6242
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
 
6243
}
 
6244
static void *_p_wxBookCtrlEventTo_p_wxEvent(void *x) {
 
6245
    return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxBookCtrlEvent *) x));
 
6246
}
 
6247
static void *_p_wxWindowModalDialogEventTo_p_wxEvent(void *x) {
 
6248
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowModalDialogEvent *) x));
 
6249
}
 
6250
static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
 
6251
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
 
6252
}
 
6253
static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
 
6254
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
 
6255
}
 
6256
static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
 
6257
    return (void *)((wxEvent *)  ((wxMouseCaptureLostEvent *) x));
 
6258
}
 
6259
static void *_p_wxPyEventTo_p_wxEvent(void *x) {
 
6260
    return (void *)((wxEvent *)  ((wxPyEvent *) x));
 
6261
}
 
6262
static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
 
6263
    return (void *)((wxEvent *)  ((wxCalculateLayoutEvent *) x));
 
6264
}
 
6265
static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
 
6266
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
 
6267
}
 
6268
static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
 
6269
    return (void *)((wxEvent *)  ((wxQueryNewPaletteEvent *) x));
 
6270
}
 
6271
static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
 
6272
    return (void *)((wxEvent *)  ((wxMaximizeEvent *) x));
 
6273
}
 
6274
static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
 
6275
    return (void *)((wxEvent *)  ((wxIconizeEvent *) x));
 
6276
}
 
6277
static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
 
6278
    return (void *)((wxEvent *)  ((wxActivateEvent *) x));
 
6279
}
 
6280
static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
 
6281
    return (void *)((wxEvent *)  ((wxSizeEvent *) x));
 
6282
}
 
6283
static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
 
6284
    return (void *)((wxEvent *)  ((wxMoveEvent *) x));
 
6285
}
 
6286
static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
 
6287
    return (void *)((wxEvent *)  ((wxIdleEvent *) x));
 
6288
}
 
6289
static void *_p_wxDateEventTo_p_wxEvent(void *x) {
 
6290
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
 
6291
}
 
6292
static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
 
6293
    return (void *)((wxEvent *)  ((wxPaintEvent *) x));
 
6294
}
 
6295
static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
 
6296
    return (void *)((wxEvent *)  ((wxNcPaintEvent *) x));
 
6297
}
 
6298
static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
 
6299
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
 
6300
}
 
6301
static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
 
6302
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
 
6303
}
 
6304
static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
 
6305
    return (void *)((wxEvent *)  ((wxPaletteChangedEvent *) x));
 
6306
}
 
6307
static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
 
6308
    return (void *)((wxEvent *)  ((wxDisplayChangedEvent *) x));
 
6309
}
 
6310
static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
 
6311
    return (void *)((wxEvent *)  ((wxMouseCaptureChangedEvent *) x));
 
6312
}
 
6313
static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
 
6314
    return (void *)((wxEvent *)  ((wxSysColourChangedEvent *) x));
 
6315
}
 
6316
static void *_p_wxThreadEventTo_p_wxEvent(void *x) {
 
6317
    return (void *)((wxEvent *)  ((wxThreadEvent *) x));
 
6318
}
 
6319
static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
 
6320
    return (void *)((wxEvent *)  ((wxDropFilesEvent *) x));
 
6321
}
 
6322
static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
 
6323
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
 
6324
}
 
6325
static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
 
6326
    return (void *)((wxEvent *)  ((wxFocusEvent *) x));
 
6327
}
 
6328
static void *_p_wxSashEventTo_p_wxEvent(void *x) {
 
6329
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
 
6330
}
 
6331
static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
 
6332
    return (void *)((wxEvent *)  ((wxQueryLayoutInfoEvent *) x));
 
6333
}
 
6334
static void *_p_wxShowEventTo_p_wxEvent(void *x) {
 
6335
    return (void *)((wxEvent *)  ((wxShowEvent *) x));
 
6336
}
 
6337
static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
 
6338
    return (void *)((wxEvent *)  ((wxCommandEvent *) x));
 
6339
}
 
6340
static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
 
6341
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
 
6342
}
 
6343
static void *_p_wxWizardEventTo_p_wxEvent(void *x) {
 
6344
    return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxWizardEvent *) x));
 
6345
}
 
6346
static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
 
6347
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
 
6348
}
 
6349
static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
 
6350
    return (void *)((wxEvent *)  ((wxNavigationKeyEvent *) x));
 
6351
}
 
6352
static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
 
6353
    return (void *)((wxEvent *)  ((wxKeyEvent *) x));
 
6354
}
 
6355
static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
 
6356
    return (void *)((wxEvent *)  ((wxScrollWinEvent *) x));
 
6357
}
 
6358
static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
 
6359
    return (void *)((wxEvent *)  ((wxTaskBarIconEvent *) x));
 
6360
}
 
6361
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
 
6362
static swig_type_info _swigt__p_double = {"_p_double", "double *|wxDouble *", 0, 0, (void*)0, 0};
 
6363
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
 
6364
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
 
6365
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
 
6366
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
 
6367
static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
 
6368
static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
 
6369
static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
 
6370
static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
 
6371
static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
 
6372
static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
 
6373
static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
 
6374
static swig_type_info _swigt__p_wxBookCtrlEvent = {"_p_wxBookCtrlEvent", 0, 0, 0, 0, 0};
 
6375
static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
 
6376
static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
 
6377
static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
 
6378
static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
 
6379
static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
 
6380
static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
 
6381
static swig_type_info _swigt__p_wxWindowModalDialogEvent = {"_p_wxWindowModalDialogEvent", 0, 0, 0, 0, 0};
 
6382
static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
 
6383
static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
 
6384
static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
 
6385
static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", "wxDialog *", 0, 0, (void*)0, 0};
 
6386
static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
 
6387
static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
 
6388
static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
 
6389
static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
 
6390
static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
 
6391
static swig_type_info _swigt__p_wxGenericProgressDialog = {"_p_wxGenericProgressDialog", 0, 0, 0, 0, 0};
 
6392
static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
 
6393
static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
 
6394
static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
 
6395
static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
 
6396
static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
 
6397
static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
 
6398
static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
 
6399
static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
 
6400
static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
 
6401
static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
 
6402
static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
 
6403
static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
 
6404
static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
 
6405
static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
 
6406
static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
 
6407
static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
 
6408
static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
 
6409
static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
 
6410
static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
 
6411
static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
 
6412
static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
 
6413
static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
 
6414
static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
 
6415
static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
 
6416
static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
 
6417
static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
 
6418
static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
 
6419
static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
 
6420
static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
 
6421
static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
 
6422
static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
 
6423
static swig_type_info _swigt__p_wxThreadEvent = {"_p_wxThreadEvent", 0, 0, 0, 0, 0};
 
6424
static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
 
6425
static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
 
6426
static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
 
6427
static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
 
6428
static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
 
6429
static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
 
6430
static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
 
6431
static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
 
6432
static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
 
6433
static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
 
6434
static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
 
6435
static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
 
6436
static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
 
6437
static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
 
6438
static swig_type_info _swigt__p_wxTextCtrlBase = {"_p_wxTextCtrlBase", 0, 0, 0, 0, 0};
 
6439
static swig_type_info _swigt__p_wxBookCtrlBase = {"_p_wxBookCtrlBase", 0, 0, 0, 0, 0};
 
6440
static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
 
6441
static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
 
6442
static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
 
6443
static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
 
6444
static swig_type_info _swigt__p_wxPyHVScrolledWindow = {"_p_wxPyHVScrolledWindow", 0, 0, 0, 0, 0};
 
6445
static swig_type_info _swigt__p_wxPyHScrolledWindow = {"_p_wxPyHScrolledWindow", 0, 0, 0, 0, 0};
 
6446
static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
 
6447
static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", 0, 0, 0, 0, 0};
 
6448
static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
 
6449
static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
 
6450
static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
 
6451
static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
 
6452
static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
 
6453
static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
 
6454
static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
 
6455
static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
 
6456
static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
 
6457
static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
 
6458
static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
 
6459
static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
 
6460
static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
 
6461
static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
 
6462
static swig_type_info _swigt__p_wxPyEvtHandler = {"_p_wxPyEvtHandler", 0, 0, 0, 0, 0};
 
6463
static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
 
6464
static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
 
6465
static swig_type_info _swigt__p_wxSimpleHtmlListBox = {"_p_wxSimpleHtmlListBox", 0, 0, 0, 0, 0};
 
6466
static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
 
6467
static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
 
6468
static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
 
6469
static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
 
6470
static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
 
6471
static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
 
6472
static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
 
6473
static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
 
6474
static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
 
6475
static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
 
6476
static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
 
6477
static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
 
6478
static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
 
6479
static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
 
6480
static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
 
6481
static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
 
6482
static swig_type_info _swigt__p_wxWrapSizer = {"_p_wxWrapSizer", 0, 0, 0, 0, 0};
 
6483
static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
 
6484
static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
 
6485
static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
 
6486
static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
 
6487
static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
 
6488
static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
 
6489
static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
 
6490
static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
 
6491
static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
 
6492
static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
 
6493
static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
 
6494
static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
 
6495
static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
 
6496
static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
 
6497
static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
 
6498
static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
 
6499
static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
 
6500
static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
 
6501
static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
 
6502
static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
 
6503
static swig_type_info _swigt__p_wxStandardDialogLayoutAdapter = {"_p_wxStandardDialogLayoutAdapter", 0, 0, 0, 0, 0};
 
6504
static swig_type_info _swigt__p_wxDialogLayoutAdapter = {"_p_wxDialogLayoutAdapter", 0, 0, 0, 0, 0};
 
6505
static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
 
6506
static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
 
6507
static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
 
6508
static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
 
6509
static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
 
6510
static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
 
6511
static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
 
6512
static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
 
6513
static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
 
6514
static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
 
6515
static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
 
6516
static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
 
6517
static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
 
6518
static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
 
6519
static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
 
6520
static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
 
6521
static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
 
6522
static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
 
6523
static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
 
6524
static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
 
6525
static swig_type_info _swigt__p_wxPyWizardPage = {"_p_wxPyWizardPage", "wxPyWizardPage *", 0, 0, (void*)0, 0};
 
6526
static swig_type_info _swigt__p_wxRefCounter = {"_p_wxRefCounter", "wxRefCounter *|wxObjectRefData *", 0, 0, (void*)0, 0};
 
6527
static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
 
6528
static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", "wxTopLevelWindow *", 0, 0, (void*)0, 0};
 
6529
static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
 
6530
static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
 
6531
static swig_type_info _swigt__p_wxWizard = {"_p_wxWizard", "wxWizard *", 0, 0, (void*)0, 0};
 
6532
static swig_type_info _swigt__p_wxWizardEvent = {"_p_wxWizardEvent", "wxWizardEvent *", 0, 0, (void*)0, 0};
 
6533
static swig_type_info _swigt__p_wxWizardPage = {"_p_wxWizardPage", "wxWizardPage *", 0, 0, (void*)0, 0};
 
6534
static swig_type_info _swigt__p_wxWizardPageSimple = {"_p_wxWizardPageSimple", "wxWizardPageSimple *", 0, 0, (void*)0, 0};
 
6535
 
 
6536
static swig_type_info *swig_type_initial[] = {
 
6537
  &_swigt__p_char,
 
6538
  &_swigt__p_double,
 
6539
  &_swigt__p_int,
 
6540
  &_swigt__p_unsigned_char,
 
6541
  &_swigt__p_unsigned_int,
 
6542
  &_swigt__p_unsigned_long,
 
6543
  &_swigt__p_wxANIHandler,
 
6544
  &_swigt__p_wxAcceleratorTable,
 
6545
  &_swigt__p_wxActivateEvent,
 
6546
  &_swigt__p_wxBMPHandler,
 
6547
  &_swigt__p_wxBitmap,
 
6548
  &_swigt__p_wxBookCtrlBase,
 
6549
  &_swigt__p_wxBookCtrlEvent,
 
6550
  &_swigt__p_wxBoxSizer,
 
6551
  &_swigt__p_wxCURHandler,
 
6552
  &_swigt__p_wxCalculateLayoutEvent,
 
6553
  &_swigt__p_wxChildFocusEvent,
 
6554
  &_swigt__p_wxClipboardTextEvent,
 
6555
  &_swigt__p_wxCloseEvent,
 
6556
  &_swigt__p_wxColour,
 
6557
  &_swigt__p_wxColourData,
 
6558
  &_swigt__p_wxColourDialog,
 
6559
  &_swigt__p_wxCommandEvent,
 
6560
  &_swigt__p_wxContextMenuEvent,
 
6561
  &_swigt__p_wxControl,
 
6562
  &_swigt__p_wxControlWithItems,
 
6563
  &_swigt__p_wxDC,
 
6564
  &_swigt__p_wxDateEvent,
 
6565
  &_swigt__p_wxDialog,
 
6566
  &_swigt__p_wxDialogLayoutAdapter,
 
6567
  &_swigt__p_wxDirDialog,
 
6568
  &_swigt__p_wxDisplayChangedEvent,
 
6569
  &_swigt__p_wxDropFilesEvent,
 
6570
  &_swigt__p_wxDuplexMode,
 
6571
  &_swigt__p_wxEraseEvent,
 
6572
  &_swigt__p_wxEvent,
 
6573
  &_swigt__p_wxEventBlocker,
 
6574
  &_swigt__p_wxEvtHandler,
 
6575
  &_swigt__p_wxFSFile,
 
6576
  &_swigt__p_wxFileDialog,
 
6577
  &_swigt__p_wxFileSystem,
 
6578
  &_swigt__p_wxFindDialogEvent,
 
6579
  &_swigt__p_wxFindReplaceData,
 
6580
  &_swigt__p_wxFindReplaceDialog,
 
6581
  &_swigt__p_wxFlexGridSizer,
 
6582
  &_swigt__p_wxFocusEvent,
 
6583
  &_swigt__p_wxFontData,
 
6584
  &_swigt__p_wxFontDialog,
 
6585
  &_swigt__p_wxFrame,
 
6586
  &_swigt__p_wxGBSizerItem,
 
6587
  &_swigt__p_wxGIFHandler,
 
6588
  &_swigt__p_wxGenericProgressDialog,
 
6589
  &_swigt__p_wxGridBagSizer,
 
6590
  &_swigt__p_wxGridSizer,
 
6591
  &_swigt__p_wxICOHandler,
 
6592
  &_swigt__p_wxIconizeEvent,
 
6593
  &_swigt__p_wxIdleEvent,
 
6594
  &_swigt__p_wxImage,
 
6595
  &_swigt__p_wxImageHandler,
 
6596
  &_swigt__p_wxIndividualLayoutConstraint,
 
6597
  &_swigt__p_wxInitDialogEvent,
 
6598
  &_swigt__p_wxJPEGHandler,
 
6599
  &_swigt__p_wxKeyEvent,
 
6600
  &_swigt__p_wxLayoutAlgorithm,
 
6601
  &_swigt__p_wxLayoutConstraints,
 
6602
  &_swigt__p_wxMDIChildFrame,
 
6603
  &_swigt__p_wxMDIClientWindow,
 
6604
  &_swigt__p_wxMDIParentFrame,
 
6605
  &_swigt__p_wxMaximizeEvent,
 
6606
  &_swigt__p_wxMenu,
 
6607
  &_swigt__p_wxMenuBar,
 
6608
  &_swigt__p_wxMenuEvent,
 
6609
  &_swigt__p_wxMenuItem,
 
6610
  &_swigt__p_wxMessageDialog,
 
6611
  &_swigt__p_wxMiniFrame,
 
6612
  &_swigt__p_wxMouseCaptureChangedEvent,
 
6613
  &_swigt__p_wxMouseCaptureLostEvent,
 
6614
  &_swigt__p_wxMouseEvent,
 
6615
  &_swigt__p_wxMoveEvent,
 
6616
  &_swigt__p_wxMultiChoiceDialog,
 
6617
  &_swigt__p_wxNavigationKeyEvent,
 
6618
  &_swigt__p_wxNcPaintEvent,
 
6619
  &_swigt__p_wxNotifyEvent,
 
6620
  &_swigt__p_wxNumberEntryDialog,
 
6621
  &_swigt__p_wxObject,
 
6622
  &_swigt__p_wxPCXHandler,
 
6623
  &_swigt__p_wxPNGHandler,
 
6624
  &_swigt__p_wxPNMHandler,
 
6625
  &_swigt__p_wxPageSetupDialog,
 
6626
  &_swigt__p_wxPageSetupDialogData,
 
6627
  &_swigt__p_wxPaintEvent,
 
6628
  &_swigt__p_wxPaletteChangedEvent,
 
6629
  &_swigt__p_wxPanel,
 
6630
  &_swigt__p_wxPaperSize,
 
6631
  &_swigt__p_wxPasswordEntryDialog,
 
6632
  &_swigt__p_wxPopupWindow,
 
6633
  &_swigt__p_wxPreviewCanvas,
 
6634
  &_swigt__p_wxPreviewControlBar,
 
6635
  &_swigt__p_wxPreviewFrame,
 
6636
  &_swigt__p_wxPrintData,
 
6637
  &_swigt__p_wxPrintDialog,
 
6638
  &_swigt__p_wxPrintDialogData,
 
6639
  &_swigt__p_wxPrintPreview,
 
6640
  &_swigt__p_wxPrinter,
 
6641
  &_swigt__p_wxProgressDialog,
 
6642
  &_swigt__p_wxPyApp,
 
6643
  &_swigt__p_wxPyCommandEvent,
 
6644
  &_swigt__p_wxPyEvent,
 
6645
  &_swigt__p_wxPyEvtHandler,
 
6646
  &_swigt__p_wxPyHScrolledWindow,
 
6647
  &_swigt__p_wxPyHVScrolledWindow,
 
6648
  &_swigt__p_wxPyHtmlListBox,
 
6649
  &_swigt__p_wxPyImageHandler,
 
6650
  &_swigt__p_wxPyPanel,
 
6651
  &_swigt__p_wxPyPopupTransientWindow,
 
6652
  &_swigt__p_wxPyPreviewControlBar,
 
6653
  &_swigt__p_wxPyPreviewFrame,
 
6654
  &_swigt__p_wxPyPrintPreview,
 
6655
  &_swigt__p_wxPyPrintout,
 
6656
  &_swigt__p_wxPyScrolledWindow,
 
6657
  &_swigt__p_wxPySizer,
 
6658
  &_swigt__p_wxPyTaskBarIcon,
 
6659
  &_swigt__p_wxPyVListBox,
 
6660
  &_swigt__p_wxPyVScrolledWindow,
 
6661
  &_swigt__p_wxPyValidator,
 
6662
  &_swigt__p_wxPyWindow,
 
6663
  &_swigt__p_wxPyWizardPage,
 
6664
  &_swigt__p_wxQueryLayoutInfoEvent,
 
6665
  &_swigt__p_wxQueryNewPaletteEvent,
 
6666
  &_swigt__p_wxRefCounter,
 
6667
  &_swigt__p_wxSashEvent,
 
6668
  &_swigt__p_wxSashLayoutWindow,
 
6669
  &_swigt__p_wxSashWindow,
 
6670
  &_swigt__p_wxScrollEvent,
 
6671
  &_swigt__p_wxScrollWinEvent,
 
6672
  &_swigt__p_wxScrolledWindow,
 
6673
  &_swigt__p_wxSetCursorEvent,
 
6674
  &_swigt__p_wxShowEvent,
 
6675
  &_swigt__p_wxSimpleHtmlListBox,
 
6676
  &_swigt__p_wxSingleChoiceDialog,
 
6677
  &_swigt__p_wxSize,
 
6678
  &_swigt__p_wxSizeEvent,
 
6679
  &_swigt__p_wxSizer,
 
6680
  &_swigt__p_wxSizerItem,
 
6681
  &_swigt__p_wxSplashScreen,
 
6682
  &_swigt__p_wxSplashScreenWindow,
 
6683
  &_swigt__p_wxSplitterEvent,
 
6684
  &_swigt__p_wxSplitterWindow,
 
6685
  &_swigt__p_wxStandardDialogLayoutAdapter,
 
6686
  &_swigt__p_wxStaticBoxSizer,
 
6687
  &_swigt__p_wxStatusBar,
 
6688
  &_swigt__p_wxStdDialogButtonSizer,
 
6689
  &_swigt__p_wxSysColourChangedEvent,
 
6690
  &_swigt__p_wxTGAHandler,
 
6691
  &_swigt__p_wxTIFFHandler,
 
6692
  &_swigt__p_wxTaskBarIconEvent,
 
6693
  &_swigt__p_wxTextCtrlBase,
 
6694
  &_swigt__p_wxTextEntryDialog,
 
6695
  &_swigt__p_wxThreadEvent,
 
6696
  &_swigt__p_wxTipWindow,
 
6697
  &_swigt__p_wxTopLevelWindow,
 
6698
  &_swigt__p_wxUpdateUIEvent,
 
6699
  &_swigt__p_wxValidator,
 
6700
  &_swigt__p_wxVisualAttributes,
 
6701
  &_swigt__p_wxWindow,
 
6702
  &_swigt__p_wxWindowCreateEvent,
 
6703
  &_swigt__p_wxWindowDestroyEvent,
 
6704
  &_swigt__p_wxWindowModalDialogEvent,
 
6705
  &_swigt__p_wxWizard,
 
6706
  &_swigt__p_wxWizardEvent,
 
6707
  &_swigt__p_wxWizardPage,
 
6708
  &_swigt__p_wxWizardPageSimple,
 
6709
  &_swigt__p_wxWrapSizer,
 
6710
  &_swigt__p_wxXPMHandler,
 
6711
};
 
6712
 
 
6713
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
 
6714
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
 
6715
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
 
6716
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
 
6717
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
 
6718
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
 
6719
static swig_cast_info _swigc__p_wxBitmap[] = {  {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
 
6720
static swig_cast_info _swigc__p_wxColour[] = {  {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
 
6721
static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6722
static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6723
static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6724
static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6725
static swig_cast_info _swigc__p_wxBookCtrlEvent[] = {{&_swigt__p_wxBookCtrlEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6726
static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6727
static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6728
static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6729
static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6730
static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6731
static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6732
static swig_cast_info _swigc__p_wxWindowModalDialogEvent[] = {{&_swigt__p_wxWindowModalDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6733
static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6734
static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6735
static swig_cast_info _swigc__p_wxCommandEvent[] = {  {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxBookCtrlEvent, _p_wxBookCtrlEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxWizardEvent, _p_wxWizardEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxCommandEvent, 0, 0, 0},  {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxWindowModalDialogEvent, _p_wxWindowModalDialogEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
 
6736
static swig_cast_info _swigc__p_wxDC[] = {  {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
 
6737
static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6738
static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6739
static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6740
static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6741
static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6742
static swig_cast_info _swigc__p_wxGenericProgressDialog[] = {{&_swigt__p_wxGenericProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6743
static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6744
static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6745
static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6746
static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6747
static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6748
static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6749
static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6750
static swig_cast_info _swigc__p_wxDialog[] = {  {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxDialog, 0, 0, 0},  {&_swigt__p_wxWizard, _p_wxWizardTo_p_wxDialog, 0, 0},  {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxGenericProgressDialog, _p_wxGenericProgressDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxDialog, 0, 0},  {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxDialog, 0, 0},{0, 0, 0, 0}};
 
6751
static swig_cast_info _swigc__p_wxDuplexMode[] = {  {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
 
6752
static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6753
static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6754
static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6755
static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6756
static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6757
static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6758
static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6759
static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6760
static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6761
static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6762
static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6763
static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6764
static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6765
static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6766
static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6767
static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6768
static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6769
static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6770
static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6771
static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6772
static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6773
static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6774
static swig_cast_info _swigc__p_wxThreadEvent[] = {{&_swigt__p_wxThreadEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6775
static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6776
static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6777
static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6778
static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6779
static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6780
static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6781
static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6782
static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6783
static swig_cast_info _swigc__p_wxEvent[] = {  {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxWindowModalDialogEvent, _p_wxWindowModalDialogEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxBookCtrlEvent, _p_wxBookCtrlEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxEvent, 0, 0, 0},  {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxThreadEvent, _p_wxThreadEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxWizardEvent, _p_wxWizardEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
 
6784
static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
 
6785
static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
 
6786
static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
 
6787
static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
 
6788
static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
 
6789
static swig_cast_info _swigc__p_wxTextCtrlBase[] = {{&_swigt__p_wxTextCtrlBase, 0, 0, 0},{0, 0, 0, 0}};
 
6790
static swig_cast_info _swigc__p_wxBookCtrlBase[] = {{&_swigt__p_wxBookCtrlBase, 0, 0, 0},{0, 0, 0, 0}};
 
6791
static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
 
6792
static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
 
6793
static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
 
6794
static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6795
static swig_cast_info _swigc__p_wxPyHVScrolledWindow[] = {{&_swigt__p_wxPyHVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6796
static swig_cast_info _swigc__p_wxPyHScrolledWindow[] = {{&_swigt__p_wxPyHScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6797
static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6798
static swig_cast_info _swigc__p_wxScrolledWindow[] = {{&_swigt__p_wxScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6799
static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6800
static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6801
static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6802
static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6803
static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6804
static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6805
static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6806
static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6807
static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
 
6808
static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
 
6809
static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
 
6810
static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
 
6811
static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
 
6812
static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
 
6813
static swig_cast_info _swigc__p_wxPyEvtHandler[] = {{&_swigt__p_wxPyEvtHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6814
static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
 
6815
static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
 
6816
static swig_cast_info _swigc__p_wxSimpleHtmlListBox[] = {{&_swigt__p_wxSimpleHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
 
6817
static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
 
6818
static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
 
6819
static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
 
6820
static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
 
6821
static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
 
6822
static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
 
6823
static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
 
6824
static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
 
6825
static swig_cast_info _swigc__p_wxEvtHandler[] = {  {&_swigt__p_wxWizardPage, _p_wxWizardPageTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyWizardPage, _p_wxPyWizardPageTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxTextCtrlBase, _p_wxTextCtrlBaseTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxBookCtrlBase, _p_wxBookCtrlBaseTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxGenericProgressDialog, _p_wxGenericProgressDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyHVScrolledWindow, _p_wxPyHVScrolledWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyHScrolledWindow, _p_wxPyHScrolledWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxEvtHandler, 0, 0, 0},  {&_swigt__p_wxPyEvtHandler, _p_wxPyEvtHandlerTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxWizard, _p_wxWizardTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxWizardPageSimple, _p_wxWizardPageSimpleTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
 
6826
static swig_cast_info _swigc__p_wxNotifyEvent[] = {  {&_swigt__p_wxBookCtrlEvent, _p_wxBookCtrlEventTo_p_wxNotifyEvent, 0, 0},  {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxNotifyEvent, 0, 0},  {&_swigt__p_wxNotifyEvent, 0, 0, 0},  {&_swigt__p_wxWizardEvent, _p_wxWizardEventTo_p_wxNotifyEvent, 0, 0},{0, 0, 0, 0}};
 
6827
static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
 
6828
static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
 
6829
static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
 
6830
static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
 
6831
static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
 
6832
static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
 
6833
static swig_cast_info _swigc__p_wxWrapSizer[] = {{&_swigt__p_wxWrapSizer, 0, 0, 0},{0, 0, 0, 0}};
 
6834
static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
 
6835
static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
 
6836
static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
 
6837
static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
 
6838
static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
 
6839
static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
 
6840
static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
 
6841
static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
 
6842
static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
 
6843
static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
 
6844
static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
 
6845
static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
 
6846
static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
 
6847
static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
 
6848
static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
 
6849
static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
 
6850
static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
 
6851
static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
 
6852
static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
 
6853
static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
 
6854
static swig_cast_info _swigc__p_wxStandardDialogLayoutAdapter[] = {{&_swigt__p_wxStandardDialogLayoutAdapter, 0, 0, 0},{0, 0, 0, 0}};
 
6855
static swig_cast_info _swigc__p_wxDialogLayoutAdapter[] = {{&_swigt__p_wxDialogLayoutAdapter, 0, 0, 0},{0, 0, 0, 0}};
 
6856
static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
 
6857
static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
 
6858
static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6859
static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
 
6860
static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6861
static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6862
static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6863
static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6864
static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6865
static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6866
static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6867
static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6868
static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6869
static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6870
static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6871
static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6872
static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6873
static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
 
6874
static swig_cast_info _swigc__p_wxObject[] = {  {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0},  {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxWindowModalDialogEvent, _p_wxWindowModalDialogEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0},  {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0},  {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0},  {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0},  {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0},  {&_swigt__p_wxBookCtrlBase, _p_wxBookCtrlBaseTo_p_wxObject, 0, 0},  {&_swigt__p_wxTextCtrlBase, _p_wxTextCtrlBaseTo_p_wxObject, 0, 0},  {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0},  {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},  {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},  {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxWrapSizer, _p_wxWrapSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxWizardPage, _p_wxWizardPageTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyWizardPage, _p_wxPyWizardPageTo_p_wxObject, 0, 0},  {&_swigt__p_wxBookCtrlEvent, _p_wxBookCtrlEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0},  {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0},  {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0},  {&_swigt__p_wxObject, 0, 0, 0},  {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0},  {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0},  {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0},  {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0},  {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0},  {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0},  {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0},  {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxObject, 0, 0},  {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0},  {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0},  {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0},  {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0},  {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0},  {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0},  {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0},  {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0},  {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0},  {&_swigt__p_wxStandardDialogLayoutAdapter, _p_wxStandardDialogLayoutAdapterTo_p_wxObject, 0, 0},  {&_swigt__p_wxDialogLayoutAdapter, _p_wxDialogLayoutAdapterTo_p_wxObject, 0, 0},  {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0},  {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0},  {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyEvtHandler, _p_wxPyEvtHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxWizard, _p_wxWizardTo_p_wxObject, 0, 0},  {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyHVScrolledWindow, _p_wxPyHVScrolledWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyHScrolledWindow, _p_wxPyHScrolledWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxGenericProgressDialog, _p_wxGenericProgressDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxThreadEvent, _p_wxThreadEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxWizardPageSimple, _p_wxWizardPageSimpleTo_p_wxObject, 0, 0},  {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0},  {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxWizardEvent, _p_wxWizardEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0},  {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0},  {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
 
6875
static swig_cast_info _swigc__p_wxPanel[] = {  {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0},  {&_swigt__p_wxWizardPageSimple, _p_wxWizardPageSimpleTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPyWizardPage, _p_wxPyWizardPageTo_p_wxPanel, 0, 0},  {&_swigt__p_wxWizardPage, _p_wxWizardPageTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPyHVScrolledWindow, _p_wxPyHVScrolledWindowTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPyHScrolledWindow, _p_wxPyHScrolledWindowTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0},  {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0},  {&_swigt__p_wxPanel, 0, 0, 0},{0, 0, 0, 0}};
 
6876
static swig_cast_info _swigc__p_wxPaperSize[] = {  {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
 
6877
static swig_cast_info _swigc__p_wxPyWizardPage[] = {  {&_swigt__p_wxPyWizardPage, 0, 0, 0},{0, 0, 0, 0}};
 
6878
static swig_cast_info _swigc__p_wxRefCounter[] = {  {&_swigt__p_wxRefCounter, 0, 0, 0},{0, 0, 0, 0}};
 
6879
static swig_cast_info _swigc__p_wxSize[] = {  {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
 
6880
static swig_cast_info _swigc__p_wxTopLevelWindow[] = {  {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxTopLevelWindow, 0, 0, 0},  {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxWizard, _p_wxWizardTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxGenericProgressDialog, _p_wxGenericProgressDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxTopLevelWindow, 0, 0},  {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxTopLevelWindow, 0, 0},{0, 0, 0, 0}};
 
6881
static swig_cast_info _swigc__p_wxVisualAttributes[] = {  {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
 
6882
static swig_cast_info _swigc__p_wxWindow[] = {  {&_swigt__p_wxWizardPage, _p_wxWizardPageTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyWizardPage, _p_wxPyWizardPageTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0},  {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0},  {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},  {&_swigt__p_wxTextCtrlBase, _p_wxTextCtrlBaseTo_p_wxWindow, 0, 0},  {&_swigt__p_wxBookCtrlBase, _p_wxBookCtrlBaseTo_p_wxWindow, 0, 0},  {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxGenericProgressDialog, _p_wxGenericProgressDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0},  {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0},  {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyHVScrolledWindow, _p_wxPyHVScrolledWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyHScrolledWindow, _p_wxPyHScrolledWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxWindow, 0, 0, 0},  {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0},  {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0},  {&_swigt__p_wxWizard, _p_wxWizardTo_p_wxWindow, 0, 0},  {&_swigt__p_wxWizardPageSimple, _p_wxWizardPageSimpleTo_p_wxWindow, 0, 0},  {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0},  {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0},  {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
 
6883
static swig_cast_info _swigc__p_wxWizard[] = {  {&_swigt__p_wxWizard, 0, 0, 0},{0, 0, 0, 0}};
 
6884
static swig_cast_info _swigc__p_wxWizardEvent[] = {  {&_swigt__p_wxWizardEvent, 0, 0, 0},{0, 0, 0, 0}};
 
6885
static swig_cast_info _swigc__p_wxWizardPage[] = {  {&_swigt__p_wxWizardPageSimple, _p_wxWizardPageSimpleTo_p_wxWizardPage, 0, 0},  {&_swigt__p_wxWizardPage, 0, 0, 0},  {&_swigt__p_wxPyWizardPage, _p_wxPyWizardPageTo_p_wxWizardPage, 0, 0},{0, 0, 0, 0}};
 
6886
static swig_cast_info _swigc__p_wxWizardPageSimple[] = {  {&_swigt__p_wxWizardPageSimple, 0, 0, 0},{0, 0, 0, 0}};
 
6887
 
 
6888
static swig_cast_info *swig_cast_initial[] = {
 
6889
  _swigc__p_char,
 
6890
  _swigc__p_double,
 
6891
  _swigc__p_int,
 
6892
  _swigc__p_unsigned_char,
 
6893
  _swigc__p_unsigned_int,
 
6894
  _swigc__p_unsigned_long,
 
6895
  _swigc__p_wxANIHandler,
 
6896
  _swigc__p_wxAcceleratorTable,
 
6897
  _swigc__p_wxActivateEvent,
 
6898
  _swigc__p_wxBMPHandler,
 
6899
  _swigc__p_wxBitmap,
 
6900
  _swigc__p_wxBookCtrlBase,
 
6901
  _swigc__p_wxBookCtrlEvent,
 
6902
  _swigc__p_wxBoxSizer,
 
6903
  _swigc__p_wxCURHandler,
 
6904
  _swigc__p_wxCalculateLayoutEvent,
 
6905
  _swigc__p_wxChildFocusEvent,
 
6906
  _swigc__p_wxClipboardTextEvent,
 
6907
  _swigc__p_wxCloseEvent,
 
6908
  _swigc__p_wxColour,
 
6909
  _swigc__p_wxColourData,
 
6910
  _swigc__p_wxColourDialog,
 
6911
  _swigc__p_wxCommandEvent,
 
6912
  _swigc__p_wxContextMenuEvent,
 
6913
  _swigc__p_wxControl,
 
6914
  _swigc__p_wxControlWithItems,
 
6915
  _swigc__p_wxDC,
 
6916
  _swigc__p_wxDateEvent,
 
6917
  _swigc__p_wxDialog,
 
6918
  _swigc__p_wxDialogLayoutAdapter,
 
6919
  _swigc__p_wxDirDialog,
 
6920
  _swigc__p_wxDisplayChangedEvent,
 
6921
  _swigc__p_wxDropFilesEvent,
 
6922
  _swigc__p_wxDuplexMode,
 
6923
  _swigc__p_wxEraseEvent,
 
6924
  _swigc__p_wxEvent,
 
6925
  _swigc__p_wxEventBlocker,
 
6926
  _swigc__p_wxEvtHandler,
 
6927
  _swigc__p_wxFSFile,
 
6928
  _swigc__p_wxFileDialog,
 
6929
  _swigc__p_wxFileSystem,
 
6930
  _swigc__p_wxFindDialogEvent,
 
6931
  _swigc__p_wxFindReplaceData,
 
6932
  _swigc__p_wxFindReplaceDialog,
 
6933
  _swigc__p_wxFlexGridSizer,
 
6934
  _swigc__p_wxFocusEvent,
 
6935
  _swigc__p_wxFontData,
 
6936
  _swigc__p_wxFontDialog,
 
6937
  _swigc__p_wxFrame,
 
6938
  _swigc__p_wxGBSizerItem,
 
6939
  _swigc__p_wxGIFHandler,
 
6940
  _swigc__p_wxGenericProgressDialog,
 
6941
  _swigc__p_wxGridBagSizer,
 
6942
  _swigc__p_wxGridSizer,
 
6943
  _swigc__p_wxICOHandler,
 
6944
  _swigc__p_wxIconizeEvent,
 
6945
  _swigc__p_wxIdleEvent,
 
6946
  _swigc__p_wxImage,
 
6947
  _swigc__p_wxImageHandler,
 
6948
  _swigc__p_wxIndividualLayoutConstraint,
 
6949
  _swigc__p_wxInitDialogEvent,
 
6950
  _swigc__p_wxJPEGHandler,
 
6951
  _swigc__p_wxKeyEvent,
 
6952
  _swigc__p_wxLayoutAlgorithm,
 
6953
  _swigc__p_wxLayoutConstraints,
 
6954
  _swigc__p_wxMDIChildFrame,
 
6955
  _swigc__p_wxMDIClientWindow,
 
6956
  _swigc__p_wxMDIParentFrame,
 
6957
  _swigc__p_wxMaximizeEvent,
 
6958
  _swigc__p_wxMenu,
 
6959
  _swigc__p_wxMenuBar,
 
6960
  _swigc__p_wxMenuEvent,
 
6961
  _swigc__p_wxMenuItem,
 
6962
  _swigc__p_wxMessageDialog,
 
6963
  _swigc__p_wxMiniFrame,
 
6964
  _swigc__p_wxMouseCaptureChangedEvent,
 
6965
  _swigc__p_wxMouseCaptureLostEvent,
 
6966
  _swigc__p_wxMouseEvent,
 
6967
  _swigc__p_wxMoveEvent,
 
6968
  _swigc__p_wxMultiChoiceDialog,
 
6969
  _swigc__p_wxNavigationKeyEvent,
 
6970
  _swigc__p_wxNcPaintEvent,
 
6971
  _swigc__p_wxNotifyEvent,
 
6972
  _swigc__p_wxNumberEntryDialog,
 
6973
  _swigc__p_wxObject,
 
6974
  _swigc__p_wxPCXHandler,
 
6975
  _swigc__p_wxPNGHandler,
 
6976
  _swigc__p_wxPNMHandler,
 
6977
  _swigc__p_wxPageSetupDialog,
 
6978
  _swigc__p_wxPageSetupDialogData,
 
6979
  _swigc__p_wxPaintEvent,
 
6980
  _swigc__p_wxPaletteChangedEvent,
 
6981
  _swigc__p_wxPanel,
 
6982
  _swigc__p_wxPaperSize,
 
6983
  _swigc__p_wxPasswordEntryDialog,
 
6984
  _swigc__p_wxPopupWindow,
 
6985
  _swigc__p_wxPreviewCanvas,
 
6986
  _swigc__p_wxPreviewControlBar,
 
6987
  _swigc__p_wxPreviewFrame,
 
6988
  _swigc__p_wxPrintData,
 
6989
  _swigc__p_wxPrintDialog,
 
6990
  _swigc__p_wxPrintDialogData,
 
6991
  _swigc__p_wxPrintPreview,
 
6992
  _swigc__p_wxPrinter,
 
6993
  _swigc__p_wxProgressDialog,
 
6994
  _swigc__p_wxPyApp,
 
6995
  _swigc__p_wxPyCommandEvent,
 
6996
  _swigc__p_wxPyEvent,
 
6997
  _swigc__p_wxPyEvtHandler,
 
6998
  _swigc__p_wxPyHScrolledWindow,
 
6999
  _swigc__p_wxPyHVScrolledWindow,
 
7000
  _swigc__p_wxPyHtmlListBox,
 
7001
  _swigc__p_wxPyImageHandler,
 
7002
  _swigc__p_wxPyPanel,
 
7003
  _swigc__p_wxPyPopupTransientWindow,
 
7004
  _swigc__p_wxPyPreviewControlBar,
 
7005
  _swigc__p_wxPyPreviewFrame,
 
7006
  _swigc__p_wxPyPrintPreview,
 
7007
  _swigc__p_wxPyPrintout,
 
7008
  _swigc__p_wxPyScrolledWindow,
 
7009
  _swigc__p_wxPySizer,
 
7010
  _swigc__p_wxPyTaskBarIcon,
 
7011
  _swigc__p_wxPyVListBox,
 
7012
  _swigc__p_wxPyVScrolledWindow,
 
7013
  _swigc__p_wxPyValidator,
 
7014
  _swigc__p_wxPyWindow,
 
7015
  _swigc__p_wxPyWizardPage,
 
7016
  _swigc__p_wxQueryLayoutInfoEvent,
 
7017
  _swigc__p_wxQueryNewPaletteEvent,
 
7018
  _swigc__p_wxRefCounter,
 
7019
  _swigc__p_wxSashEvent,
 
7020
  _swigc__p_wxSashLayoutWindow,
 
7021
  _swigc__p_wxSashWindow,
 
7022
  _swigc__p_wxScrollEvent,
 
7023
  _swigc__p_wxScrollWinEvent,
 
7024
  _swigc__p_wxScrolledWindow,
 
7025
  _swigc__p_wxSetCursorEvent,
 
7026
  _swigc__p_wxShowEvent,
 
7027
  _swigc__p_wxSimpleHtmlListBox,
 
7028
  _swigc__p_wxSingleChoiceDialog,
 
7029
  _swigc__p_wxSize,
 
7030
  _swigc__p_wxSizeEvent,
 
7031
  _swigc__p_wxSizer,
 
7032
  _swigc__p_wxSizerItem,
 
7033
  _swigc__p_wxSplashScreen,
 
7034
  _swigc__p_wxSplashScreenWindow,
 
7035
  _swigc__p_wxSplitterEvent,
 
7036
  _swigc__p_wxSplitterWindow,
 
7037
  _swigc__p_wxStandardDialogLayoutAdapter,
 
7038
  _swigc__p_wxStaticBoxSizer,
 
7039
  _swigc__p_wxStatusBar,
 
7040
  _swigc__p_wxStdDialogButtonSizer,
 
7041
  _swigc__p_wxSysColourChangedEvent,
 
7042
  _swigc__p_wxTGAHandler,
 
7043
  _swigc__p_wxTIFFHandler,
 
7044
  _swigc__p_wxTaskBarIconEvent,
 
7045
  _swigc__p_wxTextCtrlBase,
 
7046
  _swigc__p_wxTextEntryDialog,
 
7047
  _swigc__p_wxThreadEvent,
 
7048
  _swigc__p_wxTipWindow,
 
7049
  _swigc__p_wxTopLevelWindow,
 
7050
  _swigc__p_wxUpdateUIEvent,
 
7051
  _swigc__p_wxValidator,
 
7052
  _swigc__p_wxVisualAttributes,
 
7053
  _swigc__p_wxWindow,
 
7054
  _swigc__p_wxWindowCreateEvent,
 
7055
  _swigc__p_wxWindowDestroyEvent,
 
7056
  _swigc__p_wxWindowModalDialogEvent,
 
7057
  _swigc__p_wxWizard,
 
7058
  _swigc__p_wxWizardEvent,
 
7059
  _swigc__p_wxWizardPage,
 
7060
  _swigc__p_wxWizardPageSimple,
 
7061
  _swigc__p_wxWrapSizer,
 
7062
  _swigc__p_wxXPMHandler,
 
7063
};
 
7064
 
 
7065
 
 
7066
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
 
7067
 
 
7068
static swig_const_info swig_const_table[] = {
 
7069
{0, 0, 0, 0.0, 0, 0}};
 
7070
 
 
7071
#ifdef __cplusplus
 
7072
}
 
7073
#endif
 
7074
/* -----------------------------------------------------------------------------
 
7075
 * Type initialization:
 
7076
 * This problem is tough by the requirement that no dynamic 
 
7077
 * memory is used. Also, since swig_type_info structures store pointers to 
 
7078
 * swig_cast_info structures and swig_cast_info structures store pointers back
 
7079
 * to swig_type_info structures, we need some lookup code at initialization. 
 
7080
 * The idea is that swig generates all the structures that are needed. 
 
7081
 * The runtime then collects these partially filled structures. 
 
7082
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
7083
 * swig_module, and does all the lookup, filling in the swig_module.types
 
7084
 * array with the correct data and linking the correct swig_cast_info
 
7085
 * structures together.
 
7086
 *
 
7087
 * The generated swig_type_info structures are assigned staticly to an initial 
 
7088
 * array. We just loop though that array, and handle each type individually.
 
7089
 * First we lookup if this type has been already loaded, and if so, use the
 
7090
 * loaded structure instead of the generated one. Then we have to fill in the
 
7091
 * cast linked list. The cast data is initially stored in something like a
 
7092
 * two-dimensional array. Each row corresponds to a type (there are the same
 
7093
 * number of rows as there are in the swig_type_initial array). Each entry in
 
7094
 * a column is one of the swig_cast_info structures for that type.
 
7095
 * The cast_initial array is actually an array of arrays, because each row has
 
7096
 * a variable number of columns. So to actually build the cast linked list,
 
7097
 * we find the array of casts associated with the type, and loop through it 
 
7098
 * adding the casts to the list. The one last trick we need to do is making
 
7099
 * sure the type pointer in the swig_cast_info struct is correct.
 
7100
 *
 
7101
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
7102
 * There are three cases to handle:
 
7103
 *  1) If the cast->type has already been loaded AND the type we are adding
 
7104
 *     casting info to has not been loaded (it is in this module), THEN we
 
7105
 *     replace the cast->type pointer with the type pointer that has already
 
7106
 *     been loaded.
 
7107
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
7108
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 
7109
 *     the previous module so we just ignore it.
 
7110
 *  3) Finally, if cast->type has not already been loaded, then we add that
 
7111
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 
7112
 *     be correct.
 
7113
 * ----------------------------------------------------------------------------- */
 
7114
 
 
7115
#ifdef __cplusplus
 
7116
extern "C" {
 
7117
#if 0
 
7118
} /* c-mode */
 
7119
#endif
 
7120
#endif
 
7121
 
 
7122
#if 0
 
7123
#define SWIGRUNTIME_DEBUG
 
7124
#endif
 
7125
 
 
7126
SWIGRUNTIME void
 
7127
SWIG_InitializeModule(void *clientdata) {
 
7128
  size_t i;
 
7129
  swig_module_info *module_head;
 
7130
  static int init_run = 0;
 
7131
  
 
7132
  clientdata = clientdata;
 
7133
  
 
7134
  if (init_run) return;
 
7135
  init_run = 1;
 
7136
  
 
7137
  /* Initialize the swig_module */
 
7138
  swig_module.type_initial = swig_type_initial;
 
7139
  swig_module.cast_initial = swig_cast_initial;
 
7140
  
 
7141
  /* Try and load any already created modules */
 
7142
  module_head = SWIG_GetModule(clientdata);
 
7143
  if (module_head) {
 
7144
    swig_module.next = module_head->next;
 
7145
    module_head->next = &swig_module;
 
7146
  } else {
 
7147
    /* This is the first module loaded */
 
7148
    swig_module.next = &swig_module;
 
7149
    SWIG_SetModule(clientdata, &swig_module);
 
7150
  }
 
7151
  
 
7152
  /* Now work on filling in swig_module.types */
 
7153
#ifdef SWIGRUNTIME_DEBUG
 
7154
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
 
7155
#endif
 
7156
  for (i = 0; i < swig_module.size; ++i) {
 
7157
    swig_type_info *type = 0;
 
7158
    swig_type_info *ret;
 
7159
    swig_cast_info *cast;
 
7160
    
 
7161
#ifdef SWIGRUNTIME_DEBUG
 
7162
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
 
7163
#endif
 
7164
    
 
7165
    /* if there is another module already loaded */
 
7166
    if (swig_module.next != &swig_module) {
 
7167
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
 
7168
    }
 
7169
    if (type) {
 
7170
      /* Overwrite clientdata field */
 
7171
#ifdef SWIGRUNTIME_DEBUG
 
7172
      printf("SWIG_InitializeModule: found type %s\n", type->name);
 
7173
#endif
 
7174
      if (swig_module.type_initial[i]->clientdata) {
 
7175
        type->clientdata = swig_module.type_initial[i]->clientdata;
 
7176
#ifdef SWIGRUNTIME_DEBUG
 
7177
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
 
7178
#endif
 
7179
      }
 
7180
    } else {
 
7181
      type = swig_module.type_initial[i];
 
7182
    }
 
7183
    
 
7184
    /* Insert casting types */
 
7185
    cast = swig_module.cast_initial[i];
 
7186
    while (cast->type) {
 
7187
      /* Don't need to add information already in the list */
 
7188
      ret = 0;
 
7189
#ifdef SWIGRUNTIME_DEBUG
 
7190
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
 
7191
#endif
 
7192
      if (swig_module.next != &swig_module) {
 
7193
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
 
7194
#ifdef SWIGRUNTIME_DEBUG
 
7195
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
 
7196
#endif
 
7197
      }
 
7198
      if (ret) {
 
7199
        if (type == swig_module.type_initial[i]) {
 
7200
#ifdef SWIGRUNTIME_DEBUG
 
7201
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
 
7202
#endif
 
7203
          cast->type = ret;
 
7204
          ret = 0;
 
7205
        } else {
 
7206
          /* Check for casting already in the list */
 
7207
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
 
7208
#ifdef SWIGRUNTIME_DEBUG
 
7209
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
 
7210
#endif
 
7211
          if (!ocast) ret = 0;
 
7212
        }
 
7213
      }
 
7214
      
 
7215
      if (!ret) {
 
7216
#ifdef SWIGRUNTIME_DEBUG
 
7217
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
 
7218
#endif
 
7219
        if (type->cast) {
 
7220
          type->cast->prev = cast;
 
7221
          cast->next = type->cast;
 
7222
        }
 
7223
        type->cast = cast;
 
7224
      }
 
7225
      cast++;
 
7226
    }
 
7227
    /* Set entry in modules->types array equal to the type */
 
7228
    swig_module.types[i] = type;
 
7229
  }
 
7230
  swig_module.types[i] = 0;
 
7231
  
 
7232
#ifdef SWIGRUNTIME_DEBUG
 
7233
  printf("**** SWIG_InitializeModule: Cast List ******\n");
 
7234
  for (i = 0; i < swig_module.size; ++i) {
 
7235
    int j = 0;
 
7236
    swig_cast_info *cast = swig_module.cast_initial[i];
 
7237
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
 
7238
    while (cast->type) {
 
7239
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
 
7240
      cast++;
 
7241
      ++j;
 
7242
    }
 
7243
    printf("---- Total casts: %d\n",j);
 
7244
  }
 
7245
  printf("**** SWIG_InitializeModule: Cast List ******\n");
 
7246
#endif
 
7247
}
 
7248
 
 
7249
/* This function will propagate the clientdata field of type to
 
7250
* any new swig_type_info structures that have been added into the list
 
7251
* of equivalent types.  It is like calling
 
7252
* SWIG_TypeClientData(type, clientdata) a second time.
 
7253
*/
 
7254
SWIGRUNTIME void
 
7255
SWIG_PropagateClientData(void) {
 
7256
  size_t i;
 
7257
  swig_cast_info *equiv;
 
7258
  static int init_run = 0;
 
7259
  
 
7260
  if (init_run) return;
 
7261
  init_run = 1;
 
7262
  
 
7263
  for (i = 0; i < swig_module.size; i++) {
 
7264
    if (swig_module.types[i]->clientdata) {
 
7265
      equiv = swig_module.types[i]->cast;
 
7266
      while (equiv) {
 
7267
        if (!equiv->converter) {
 
7268
          if (equiv->type && !equiv->type->clientdata)
 
7269
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
 
7270
        }
 
7271
        equiv = equiv->next;
 
7272
      }
 
7273
    }
 
7274
  }
 
7275
}
 
7276
 
 
7277
#ifdef __cplusplus
 
7278
#if 0
 
7279
{
 
7280
  /* c-mode */
 
7281
#endif
 
7282
}
 
7283
#endif
 
7284
 
 
7285
 
 
7286
 
 
7287
#ifdef __cplusplus
 
7288
extern "C" {
 
7289
#endif
 
7290
  
 
7291
  /* Python-specific SWIG API */
 
7292
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
 
7293
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
 
7294
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
7295
  
 
7296
  /* -----------------------------------------------------------------------------
 
7297
   * global variable support code.
 
7298
   * ----------------------------------------------------------------------------- */
 
7299
  
 
7300
  typedef struct swig_globalvar {
 
7301
    char       *name;                  /* Name of global variable */
 
7302
    PyObject *(*get_attr)(void);       /* Return the current value */
 
7303
    int       (*set_attr)(PyObject *); /* Set the value */
 
7304
    struct swig_globalvar *next;
 
7305
  } swig_globalvar;
 
7306
  
 
7307
  typedef struct swig_varlinkobject {
 
7308
    PyObject_HEAD
 
7309
    swig_globalvar *vars;
 
7310
  } swig_varlinkobject;
 
7311
  
 
7312
  SWIGINTERN PyObject *
 
7313
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
 
7314
    return PyString_FromString("<Swig global variables>");
 
7315
  }
 
7316
  
 
7317
  SWIGINTERN PyObject *
 
7318
  swig_varlink_str(swig_varlinkobject *v) {
 
7319
    PyObject *str = PyString_FromString("(");
 
7320
    swig_globalvar  *var;
 
7321
    for (var = v->vars; var; var=var->next) {
 
7322
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
 
7323
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
 
7324
    }
 
7325
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
 
7326
    return str;
 
7327
  }
 
7328
  
 
7329
  SWIGINTERN int
 
7330
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
 
7331
    PyObject *str = swig_varlink_str(v);
 
7332
    fprintf(fp,"Swig global variables ");
 
7333
    fprintf(fp,"%s\n", PyString_AsString(str));
 
7334
    Py_DECREF(str);
 
7335
    return 0;
 
7336
  }
 
7337
  
 
7338
  SWIGINTERN void
 
7339
  swig_varlink_dealloc(swig_varlinkobject *v) {
 
7340
    swig_globalvar *var = v->vars;
 
7341
    while (var) {
 
7342
      swig_globalvar *n = var->next;
 
7343
      free(var->name);
 
7344
      free(var);
 
7345
      var = n;
 
7346
    }
 
7347
  }
 
7348
  
 
7349
  SWIGINTERN PyObject *
 
7350
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
 
7351
    PyObject *res = NULL;
 
7352
    swig_globalvar *var = v->vars;
 
7353
    while (var) {
 
7354
      if (strcmp(var->name,n) == 0) {
 
7355
        res = (*var->get_attr)();
 
7356
        break;
 
7357
      }
 
7358
      var = var->next;
 
7359
    }
 
7360
    if (res == NULL && !PyErr_Occurred()) {
 
7361
      PyErr_SetString(PyExc_NameError,"Unknown C global variable");
 
7362
    }
 
7363
    return res;
 
7364
  }
 
7365
  
 
7366
  SWIGINTERN int
 
7367
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
 
7368
    int res = 1;
 
7369
    swig_globalvar *var = v->vars;
 
7370
    while (var) {
 
7371
      if (strcmp(var->name,n) == 0) {
 
7372
        res = (*var->set_attr)(p);
 
7373
        break;
 
7374
      }
 
7375
      var = var->next;
 
7376
    }
 
7377
    if (res == 1 && !PyErr_Occurred()) {
 
7378
      PyErr_SetString(PyExc_NameError,"Unknown C global variable");
 
7379
    }
 
7380
    return res;
 
7381
  }
 
7382
  
 
7383
  SWIGINTERN PyTypeObject*
 
7384
  swig_varlink_type(void) {
 
7385
    static char varlink__doc__[] = "Swig var link object";
 
7386
    static PyTypeObject varlink_type;
 
7387
    static int type_init = 0;  
 
7388
    if (!type_init) {
 
7389
      const PyTypeObject tmp
 
7390
      = {
 
7391
        PyObject_HEAD_INIT(NULL)
 
7392
        0,                                  /* Number of items in variable part (ob_size) */
 
7393
        (char *)"swigvarlink",              /* Type name (tp_name) */
 
7394
        sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
 
7395
        0,                                  /* Itemsize (tp_itemsize) */
 
7396
        (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */ 
 
7397
        (printfunc) swig_varlink_print,     /* Print (tp_print) */
 
7398
        (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
 
7399
        (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
 
7400
        0,                                  /* tp_compare */
 
7401
        (reprfunc) swig_varlink_repr,       /* tp_repr */
 
7402
        0,                                  /* tp_as_number */
 
7403
        0,                                  /* tp_as_sequence */
 
7404
        0,                                  /* tp_as_mapping */
 
7405
        0,                                  /* tp_hash */
 
7406
        0,                                  /* tp_call */
 
7407
        (reprfunc)swig_varlink_str,        /* tp_str */
 
7408
        0,                                  /* tp_getattro */
 
7409
        0,                                  /* tp_setattro */
 
7410
        0,                                  /* tp_as_buffer */
 
7411
        0,                                  /* tp_flags */
 
7412
        varlink__doc__,                     /* tp_doc */
 
7413
        0,                                  /* tp_traverse */
 
7414
        0,                                  /* tp_clear */
 
7415
        0,                                  /* tp_richcompare */
 
7416
        0,                                  /* tp_weaklistoffset */
 
7417
#if PY_VERSION_HEX >= 0x02020000
 
7418
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
 
7419
#endif
 
7420
#if PY_VERSION_HEX >= 0x02030000
 
7421
        0,                                  /* tp_del */
 
7422
#endif
 
7423
#ifdef COUNT_ALLOCS
 
7424
        0,0,0,0                             /* tp_alloc -> tp_next */
 
7425
#endif
 
7426
      };
 
7427
      varlink_type = tmp;
 
7428
      varlink_type.ob_type = &PyType_Type;
 
7429
      type_init = 1;
 
7430
    }
 
7431
    return &varlink_type;
 
7432
  }
 
7433
  
 
7434
  /* Create a variable linking object for use later */
 
7435
  SWIGINTERN PyObject *
 
7436
  SWIG_Python_newvarlink(void) {
 
7437
    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
 
7438
    if (result) {
 
7439
      result->vars = 0;
 
7440
    }
 
7441
    return ((PyObject*) result);
 
7442
  }
 
7443
  
 
7444
  SWIGINTERN void 
 
7445
  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
 
7446
    swig_varlinkobject *v = (swig_varlinkobject *) p;
 
7447
    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
 
7448
    if (gv) {
 
7449
      size_t size = strlen(name)+1;
 
7450
      gv->name = (char *)malloc(size);
 
7451
      if (gv->name) {
 
7452
        strncpy(gv->name,name,size);
 
7453
        gv->get_attr = get_attr;
 
7454
        gv->set_attr = set_attr;
 
7455
        gv->next = v->vars;
 
7456
      }
 
7457
    }
 
7458
    v->vars = gv;
 
7459
  }
 
7460
  
 
7461
  SWIGINTERN PyObject *
 
7462
  SWIG_globals() {
 
7463
    static PyObject *_SWIG_globals = 0; 
 
7464
    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
 
7465
    return _SWIG_globals;
 
7466
  }
 
7467
  
 
7468
  /* -----------------------------------------------------------------------------
 
7469
   * constants/methods manipulation
 
7470
   * ----------------------------------------------------------------------------- */
 
7471
  
 
7472
  /* Install Constants */
 
7473
  SWIGINTERN void
 
7474
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
 
7475
    PyObject *obj = 0;
 
7476
    size_t i;
 
7477
    for (i = 0; constants[i].type; ++i) {
 
7478
      switch(constants[i].type) {
 
7479
      case SWIG_PY_POINTER:
 
7480
        obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
 
7481
        break;
 
7482
      case SWIG_PY_BINARY:
 
7483
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
 
7484
        break;
 
7485
      default:
 
7486
        obj = 0;
 
7487
        break;
 
7488
      }
 
7489
      if (obj) {
 
7490
        PyDict_SetItemString(d, constants[i].name, obj);
 
7491
        Py_DECREF(obj);
 
7492
      }
 
7493
    }
 
7494
  }
 
7495
  
 
7496
  /* -----------------------------------------------------------------------------*/
 
7497
  /* Fix SwigMethods to carry the callback ptrs when needed */
 
7498
  /* -----------------------------------------------------------------------------*/
 
7499
  
 
7500
  SWIGINTERN void
 
7501
  SWIG_Python_FixMethods(PyMethodDef *methods,
 
7502
    swig_const_info *const_table,
 
7503
    swig_type_info **types,
 
7504
    swig_type_info **types_initial) {
 
7505
    size_t i;
 
7506
    for (i = 0; methods[i].ml_name; ++i) {
 
7507
      const char *c = methods[i].ml_doc;
 
7508
      if (c && (c = strstr(c, "swig_ptr: "))) {
 
7509
        int j;
 
7510
        swig_const_info *ci = 0;
 
7511
        const char *name = c + 10;
 
7512
        for (j = 0; const_table[j].type; ++j) {
 
7513
          if (strncmp(const_table[j].name, name, 
 
7514
              strlen(const_table[j].name)) == 0) {
 
7515
            ci = &(const_table[j]);
 
7516
            break;
 
7517
          }
 
7518
        }
 
7519
        if (ci) {
 
7520
          size_t shift = (ci->ptype) - types;
 
7521
          swig_type_info *ty = types_initial[shift];
 
7522
          size_t ldoc = (c - methods[i].ml_doc);
 
7523
          size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
 
7524
          char *ndoc = (char*)malloc(ldoc + lptr + 10);
 
7525
          if (ndoc) {
 
7526
            char *buff = ndoc;
 
7527
            void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
 
7528
            if (ptr) {
 
7529
              strncpy(buff, methods[i].ml_doc, ldoc);
 
7530
              buff += ldoc;
 
7531
              strncpy(buff, "swig_ptr: ", 10);
 
7532
              buff += 10;
 
7533
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
 
7534
              methods[i].ml_doc = ndoc;
 
7535
            }
 
7536
          }
 
7537
        }
 
7538
      }
 
7539
    }
 
7540
  } 
 
7541
  
 
7542
#ifdef __cplusplus
 
7543
}
 
7544
#endif
 
7545
 
 
7546
/* -----------------------------------------------------------------------------*
 
7547
 *  Partial Init method
 
7548
 * -----------------------------------------------------------------------------*/
 
7549
 
 
7550
#ifdef __cplusplus
 
7551
extern "C"
 
7552
#endif
 
7553
SWIGEXPORT void SWIG_init(void) {
 
7554
  PyObject *m, *d;
 
7555
  
 
7556
  /* Fix SwigMethods to carry the callback ptrs when needed */
 
7557
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
 
7558
  
 
7559
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
 
7560
  d = PyModule_GetDict(m);
 
7561
  
 
7562
  SWIG_InitializeModule(0);
 
7563
  SWIG_InstallConstants(d,swig_const_table);
 
7564
  
 
7565
  
 
7566
  SWIG_Python_SetConstant(d, "WIZARD_EX_HELPBUTTON",SWIG_From_int(static_cast< int >(wxWIZARD_EX_HELPBUTTON)));
 
7567
  SWIG_Python_SetConstant(d, "WIZARD_VALIGN_TOP",SWIG_From_int(static_cast< int >(wxWIZARD_VALIGN_TOP)));
 
7568
  SWIG_Python_SetConstant(d, "WIZARD_VALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxWIZARD_VALIGN_CENTRE)));
 
7569
  SWIG_Python_SetConstant(d, "WIZARD_VALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxWIZARD_VALIGN_BOTTOM)));
 
7570
  SWIG_Python_SetConstant(d, "WIZARD_HALIGN_LEFT",SWIG_From_int(static_cast< int >(wxWIZARD_HALIGN_LEFT)));
 
7571
  SWIG_Python_SetConstant(d, "WIZARD_HALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxWIZARD_HALIGN_CENTRE)));
 
7572
  SWIG_Python_SetConstant(d, "WIZARD_HALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxWIZARD_HALIGN_RIGHT)));
 
7573
  SWIG_Python_SetConstant(d, "WIZARD_TILE",SWIG_From_int(static_cast< int >(wxWIZARD_TILE)));
 
7574
  PyDict_SetItemString(d, "wxEVT_WIZARD_PAGE_CHANGED", PyInt_FromLong(wxEVT_WIZARD_PAGE_CHANGED));
 
7575
  PyDict_SetItemString(d, "wxEVT_WIZARD_PAGE_CHANGING", PyInt_FromLong(wxEVT_WIZARD_PAGE_CHANGING));
 
7576
  PyDict_SetItemString(d, "wxEVT_WIZARD_CANCEL", PyInt_FromLong(wxEVT_WIZARD_CANCEL));
 
7577
  PyDict_SetItemString(d, "wxEVT_WIZARD_HELP", PyInt_FromLong(wxEVT_WIZARD_HELP));
 
7578
  PyDict_SetItemString(d, "wxEVT_WIZARD_FINISHED", PyInt_FromLong(wxEVT_WIZARD_FINISHED));
 
7579
  PyDict_SetItemString(d, "wxEVT_WIZARD_PAGE_SHOWN", PyInt_FromLong(wxEVT_WIZARD_PAGE_SHOWN));
 
7580
  
 
7581
  
 
7582
}
 
7583