← Back to branch summary

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

« back to all changes in this revision

Viewing changes to wxPython/src/gtk/_controls_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:
wxPython/src/gtk/_controls_wrap.cpp
 
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_bool swig_types[0]
 
2467
#define SWIGTYPE_p_char swig_types[1]
 
2468
#define SWIGTYPE_p_double swig_types[2]
 
2469
#define SWIGTYPE_p_int swig_types[3]
 
2470
#define SWIGTYPE_p_long swig_types[4]
 
2471
#define SWIGTYPE_p_unsigned_char swig_types[5]
 
2472
#define SWIGTYPE_p_unsigned_int swig_types[6]
 
2473
#define SWIGTYPE_p_unsigned_long swig_types[7]
 
2474
#define SWIGTYPE_p_void swig_types[8]
 
2475
#define SWIGTYPE_p_wxANIHandler swig_types[9]
 
2476
#define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
 
2477
#define SWIGTYPE_p_wxActivateEvent swig_types[11]
 
2478
#define SWIGTYPE_p_wxAnyButton swig_types[12]
 
2479
#define SWIGTYPE_p_wxArrayInt swig_types[13]
 
2480
#define SWIGTYPE_p_wxArrayString swig_types[14]
 
2481
#define SWIGTYPE_p_wxBMPHandler swig_types[15]
 
2482
#define SWIGTYPE_p_wxBitmap swig_types[16]
 
2483
#define SWIGTYPE_p_wxBitmapButton swig_types[17]
 
2484
#define SWIGTYPE_p_wxBookCtrlBase swig_types[18]
 
2485
#define SWIGTYPE_p_wxBookCtrlEvent swig_types[19]
 
2486
#define SWIGTYPE_p_wxBoxSizer swig_types[20]
 
2487
#define SWIGTYPE_p_wxButton swig_types[21]
 
2488
#define SWIGTYPE_p_wxCURHandler swig_types[22]
 
2489
#define SWIGTYPE_p_wxCheckBox swig_types[23]
 
2490
#define SWIGTYPE_p_wxCheckListBox swig_types[24]
 
2491
#define SWIGTYPE_p_wxChildFocusEvent swig_types[25]
 
2492
#define SWIGTYPE_p_wxChoice swig_types[26]
 
2493
#define SWIGTYPE_p_wxChoicebook swig_types[27]
 
2494
#define SWIGTYPE_p_wxClipboardTextEvent swig_types[28]
 
2495
#define SWIGTYPE_p_wxCloseEvent swig_types[29]
 
2496
#define SWIGTYPE_p_wxCollapsiblePane swig_types[30]
 
2497
#define SWIGTYPE_p_wxCollapsiblePaneEvent swig_types[31]
 
2498
#define SWIGTYPE_p_wxColour swig_types[32]
 
2499
#define SWIGTYPE_p_wxColourPickerCtrl swig_types[33]
 
2500
#define SWIGTYPE_p_wxColourPickerEvent swig_types[34]
 
2501
#define SWIGTYPE_p_wxComboBox swig_types[35]
 
2502
#define SWIGTYPE_p_wxCommandEvent swig_types[36]
 
2503
#define SWIGTYPE_p_wxCommandLinkButton swig_types[37]
 
2504
#define SWIGTYPE_p_wxContextHelp swig_types[38]
 
2505
#define SWIGTYPE_p_wxContextHelpButton swig_types[39]
 
2506
#define SWIGTYPE_p_wxContextMenuEvent swig_types[40]
 
2507
#define SWIGTYPE_p_wxControl swig_types[41]
 
2508
#define SWIGTYPE_p_wxControlWithItems swig_types[42]
 
2509
#define SWIGTYPE_p_wxCursor swig_types[43]
 
2510
#define SWIGTYPE_p_wxDC swig_types[44]
 
2511
#define SWIGTYPE_p_wxDateEvent swig_types[45]
 
2512
#define SWIGTYPE_p_wxDatePickerCtrl swig_types[46]
 
2513
#define SWIGTYPE_p_wxDatePickerCtrlBase swig_types[47]
 
2514
#define SWIGTYPE_p_wxDatePickerCtrlGeneric swig_types[48]
 
2515
#define SWIGTYPE_p_wxDateTime swig_types[49]
 
2516
#define SWIGTYPE_p_wxDirFilterListCtrl swig_types[50]
 
2517
#define SWIGTYPE_p_wxDirItemData swig_types[51]
 
2518
#define SWIGTYPE_p_wxDirPickerCtrl swig_types[52]
 
2519
#define SWIGTYPE_p_wxDisplayChangedEvent swig_types[53]
 
2520
#define SWIGTYPE_p_wxDropFilesEvent swig_types[54]
 
2521
#define SWIGTYPE_p_wxDuplexMode swig_types[55]
 
2522
#define SWIGTYPE_p_wxEraseEvent swig_types[56]
 
2523
#define SWIGTYPE_p_wxEvent swig_types[57]
 
2524
#define SWIGTYPE_p_wxEventBlocker swig_types[58]
 
2525
#define SWIGTYPE_p_wxEvtHandler swig_types[59]
 
2526
#define SWIGTYPE_p_wxFSFile swig_types[60]
 
2527
#define SWIGTYPE_p_wxFileCtrl swig_types[61]
 
2528
#define SWIGTYPE_p_wxFileCtrlEvent swig_types[62]
 
2529
#define SWIGTYPE_p_wxFileDirPickerEvent swig_types[63]
 
2530
#define SWIGTYPE_p_wxFilePickerCtrl swig_types[64]
 
2531
#define SWIGTYPE_p_wxFileSystem swig_types[65]
 
2532
#define SWIGTYPE_p_wxFlexGridSizer swig_types[66]
 
2533
#define SWIGTYPE_p_wxFocusEvent swig_types[67]
 
2534
#define SWIGTYPE_p_wxFont swig_types[68]
 
2535
#define SWIGTYPE_p_wxFontPickerCtrl swig_types[69]
 
2536
#define SWIGTYPE_p_wxFontPickerEvent swig_types[70]
 
2537
#define SWIGTYPE_p_wxGBSizerItem swig_types[71]
 
2538
#define SWIGTYPE_p_wxGIFHandler swig_types[72]
 
2539
#define SWIGTYPE_p_wxGauge swig_types[73]
 
2540
#define SWIGTYPE_p_wxGenericDirCtrl swig_types[74]
 
2541
#define SWIGTYPE_p_wxGenericDragImage swig_types[75]
 
2542
#define SWIGTYPE_p_wxGridBagSizer swig_types[76]
 
2543
#define SWIGTYPE_p_wxGridSizer swig_types[77]
 
2544
#define SWIGTYPE_p_wxHelpEvent swig_types[78]
 
2545
#define SWIGTYPE_p_wxHelpProvider swig_types[79]
 
2546
#define SWIGTYPE_p_wxHyperlinkCtrl swig_types[80]
 
2547
#define SWIGTYPE_p_wxHyperlinkEvent swig_types[81]
 
2548
#define SWIGTYPE_p_wxICOHandler swig_types[82]
 
2549
#define SWIGTYPE_p_wxIcon swig_types[83]
 
2550
#define SWIGTYPE_p_wxIconizeEvent swig_types[84]
 
2551
#define SWIGTYPE_p_wxIdleEvent swig_types[85]
 
2552
#define SWIGTYPE_p_wxImage swig_types[86]
 
2553
#define SWIGTYPE_p_wxImageHandler swig_types[87]
 
2554
#define SWIGTYPE_p_wxImageList swig_types[88]
 
2555
#define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[89]
 
2556
#define SWIGTYPE_p_wxInfoBar swig_types[90]
 
2557
#define SWIGTYPE_p_wxInitDialogEvent swig_types[91]
 
2558
#define SWIGTYPE_p_wxItemContainer swig_types[92]
 
2559
#define SWIGTYPE_p_wxJPEGHandler swig_types[93]
 
2560
#define SWIGTYPE_p_wxKeyEvent swig_types[94]
 
2561
#define SWIGTYPE_p_wxLayoutConstraints swig_types[95]
 
2562
#define SWIGTYPE_p_wxListBox swig_types[96]
 
2563
#define SWIGTYPE_p_wxListEvent swig_types[97]
 
2564
#define SWIGTYPE_p_wxListItem swig_types[98]
 
2565
#define SWIGTYPE_p_wxListItemAttr swig_types[99]
 
2566
#define SWIGTYPE_p_wxListView swig_types[100]
 
2567
#define SWIGTYPE_p_wxListbook swig_types[101]
 
2568
#define SWIGTYPE_p_wxMaximizeEvent swig_types[102]
 
2569
#define SWIGTYPE_p_wxMemoryDC swig_types[103]
 
2570
#define SWIGTYPE_p_wxMenu swig_types[104]
 
2571
#define SWIGTYPE_p_wxMenuBar swig_types[105]
 
2572
#define SWIGTYPE_p_wxMenuEvent swig_types[106]
 
2573
#define SWIGTYPE_p_wxMenuItem swig_types[107]
 
2574
#define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[108]
 
2575
#define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[109]
 
2576
#define SWIGTYPE_p_wxMouseEvent swig_types[110]
 
2577
#define SWIGTYPE_p_wxMoveEvent swig_types[111]
 
2578
#define SWIGTYPE_p_wxNavigationKeyEvent swig_types[112]
 
2579
#define SWIGTYPE_p_wxNcPaintEvent swig_types[113]
 
2580
#define SWIGTYPE_p_wxNotebook swig_types[114]
 
2581
#define SWIGTYPE_p_wxNotifyEvent swig_types[115]
 
2582
#define SWIGTYPE_p_wxObject swig_types[116]
 
2583
#define SWIGTYPE_p_wxPCXHandler swig_types[117]
 
2584
#define SWIGTYPE_p_wxPNGHandler swig_types[118]
 
2585
#define SWIGTYPE_p_wxPNMHandler swig_types[119]
 
2586
#define SWIGTYPE_p_wxPaintEvent swig_types[120]
 
2587
#define SWIGTYPE_p_wxPaletteChangedEvent swig_types[121]
 
2588
#define SWIGTYPE_p_wxPaperSize swig_types[122]
 
2589
#define SWIGTYPE_p_wxPickerBase swig_types[123]
 
2590
#define SWIGTYPE_p_wxPoint swig_types[124]
 
2591
#define SWIGTYPE_p_wxPyApp swig_types[125]
 
2592
#define SWIGTYPE_p_wxPyCommandEvent swig_types[126]
 
2593
#define SWIGTYPE_p_wxPyControl swig_types[127]
 
2594
#define SWIGTYPE_p_wxPyEvent swig_types[128]
 
2595
#define SWIGTYPE_p_wxPyEvtHandler swig_types[129]
 
2596
#define SWIGTYPE_p_wxPyImageHandler swig_types[130]
 
2597
#define SWIGTYPE_p_wxPyListCtrl swig_types[131]
 
2598
#define SWIGTYPE_p_wxPyPickerBase swig_types[132]
 
2599
#define SWIGTYPE_p_wxPySizer swig_types[133]
 
2600
#define SWIGTYPE_p_wxPyTreeCtrl swig_types[134]
 
2601
#define SWIGTYPE_p_wxPyTreeItemData swig_types[135]
 
2602
#define SWIGTYPE_p_wxPyValidator swig_types[136]
 
2603
#define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[137]
 
2604
#define SWIGTYPE_p_wxRadioBox swig_types[138]
 
2605
#define SWIGTYPE_p_wxRadioButton swig_types[139]
 
2606
#define SWIGTYPE_p_wxRect swig_types[140]
 
2607
#define SWIGTYPE_p_wxRefCounter swig_types[141]
 
2608
#define SWIGTYPE_p_wxScrollBar swig_types[142]
 
2609
#define SWIGTYPE_p_wxScrollEvent swig_types[143]
 
2610
#define SWIGTYPE_p_wxScrollWinEvent swig_types[144]
 
2611
#define SWIGTYPE_p_wxSearchCtrl swig_types[145]
 
2612
#define SWIGTYPE_p_wxSearchCtrlBase swig_types[146]
 
2613
#define SWIGTYPE_p_wxSetCursorEvent swig_types[147]
 
2614
#define SWIGTYPE_p_wxShowEvent swig_types[148]
 
2615
#define SWIGTYPE_p_wxSimpleHelpProvider swig_types[149]
 
2616
#define SWIGTYPE_p_wxSize swig_types[150]
 
2617
#define SWIGTYPE_p_wxSizeEvent swig_types[151]
 
2618
#define SWIGTYPE_p_wxSizer swig_types[152]
 
2619
#define SWIGTYPE_p_wxSizerItem swig_types[153]
 
2620
#define SWIGTYPE_p_wxSlider swig_types[154]
 
2621
#define SWIGTYPE_p_wxSpinButton swig_types[155]
 
2622
#define SWIGTYPE_p_wxSpinCtrl swig_types[156]
 
2623
#define SWIGTYPE_p_wxSpinCtrlDouble swig_types[157]
 
2624
#define SWIGTYPE_p_wxSpinDoubleEvent swig_types[158]
 
2625
#define SWIGTYPE_p_wxSpinEvent swig_types[159]
 
2626
#define SWIGTYPE_p_wxStaticBitmap swig_types[160]
 
2627
#define SWIGTYPE_p_wxStaticBox swig_types[161]
 
2628
#define SWIGTYPE_p_wxStaticBoxSizer swig_types[162]
 
2629
#define SWIGTYPE_p_wxStaticLine swig_types[163]
 
2630
#define SWIGTYPE_p_wxStaticText swig_types[164]
 
2631
#define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[165]
 
2632
#define SWIGTYPE_p_wxString swig_types[166]
 
2633
#define SWIGTYPE_p_wxSysColourChangedEvent swig_types[167]
 
2634
#define SWIGTYPE_p_wxTGAHandler swig_types[168]
 
2635
#define SWIGTYPE_p_wxTIFFHandler swig_types[169]
 
2636
#define SWIGTYPE_p_wxTextAreaBase swig_types[170]
 
2637
#define SWIGTYPE_p_wxTextAttr swig_types[171]
 
2638
#define SWIGTYPE_p_wxTextCtrl swig_types[172]
 
2639
#define SWIGTYPE_p_wxTextCtrlBase swig_types[173]
 
2640
#define SWIGTYPE_p_wxTextCtrlIface swig_types[174]
 
2641
#define SWIGTYPE_p_wxTextEntry swig_types[175]
 
2642
#define SWIGTYPE_p_wxTextEntryBase swig_types[176]
 
2643
#define SWIGTYPE_p_wxTextUrlEvent swig_types[177]
 
2644
#define SWIGTYPE_p_wxThreadEvent swig_types[178]
 
2645
#define SWIGTYPE_p_wxToggleButton swig_types[179]
 
2646
#define SWIGTYPE_p_wxToolBar swig_types[180]
 
2647
#define SWIGTYPE_p_wxToolBarBase swig_types[181]
 
2648
#define SWIGTYPE_p_wxToolBarToolBase swig_types[182]
 
2649
#define SWIGTYPE_p_wxToolbook swig_types[183]
 
2650
#define SWIGTYPE_p_wxTreeEvent swig_types[184]
 
2651
#define SWIGTYPE_p_wxTreeItemId swig_types[185]
 
2652
#define SWIGTYPE_p_wxTreebook swig_types[186]
 
2653
#define SWIGTYPE_p_wxUpdateUIEvent swig_types[187]
 
2654
#define SWIGTYPE_p_wxValidator swig_types[188]
 
2655
#define SWIGTYPE_p_wxVisualAttributes swig_types[189]
 
2656
#define SWIGTYPE_p_wxWindow swig_types[190]
 
2657
#define SWIGTYPE_p_wxWindowBase swig_types[191]
 
2658
#define SWIGTYPE_p_wxWindowCreateEvent swig_types[192]
 
2659
#define SWIGTYPE_p_wxWindowDestroyEvent swig_types[193]
 
2660
#define SWIGTYPE_p_wxWithImages swig_types[194]
 
2661
#define SWIGTYPE_p_wxWrapSizer swig_types[195]
 
2662
#define SWIGTYPE_p_wxXPMHandler swig_types[196]
 
2663
static swig_type_info *swig_types[198];
 
2664
static swig_module_info swig_module = {swig_types, 197, 0, 0, 0, 0};
 
2665
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 
2666
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
2667
 
 
2668
/* -------- TYPES TABLE (END) -------- */
 
2669
 
 
2670
#if (PY_VERSION_HEX <= 0x02000000)
 
2671
# if !defined(SWIG_PYTHON_CLASSIC)
 
2672
#  error "This python version requires to use swig with the '-classic' option"
 
2673
# endif
 
2674
#endif
 
2675
#if (PY_VERSION_HEX <= 0x02020000)
 
2676
# error "This python version requires to use swig with the '-nomodern' option"
 
2677
#endif
 
2678
#if (PY_VERSION_HEX <= 0x02020000)
 
2679
# error "This python version requires to use swig with the '-nomodernargs' option"
 
2680
#endif
 
2681
#ifndef METH_O
 
2682
# error "This python version requires to use swig with the '-nofastunpack' option"
 
2683
#endif
 
2684
 
 
2685
/*-----------------------------------------------
 
2686
              @(target):= _controls_.so
 
2687
  ------------------------------------------------*/
 
2688
#define SWIG_init    init_controls_
 
2689
 
 
2690
#define SWIG_name    "_controls_"
 
2691
 
 
2692
#define SWIGVERSION 0x010329 
 
2693
 
 
2694
 
 
2695
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
 
2696
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
 
2697
 
 
2698
 
 
2699
#include <stdexcept>
 
2700
 
 
2701
 
 
2702
namespace swig {
 
2703
  class PyObject_ptr {
 
2704
  protected:
 
2705
    PyObject *_obj;
 
2706
 
 
2707
  public:
 
2708
    PyObject_ptr() :_obj(0)
 
2709
    {
 
2710
    }
 
2711
 
 
2712
    PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
 
2713
    {
 
2714
      Py_XINCREF(_obj);      
 
2715
    }
 
2716
    
 
2717
    PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
 
2718
    {
 
2719
      if (initial_ref) Py_XINCREF(_obj);
 
2720
    }
 
2721
    
 
2722
    PyObject_ptr & operator=(const PyObject_ptr& item) 
 
2723
    {
 
2724
      Py_XINCREF(item._obj);
 
2725
      Py_XDECREF(_obj);
 
2726
      _obj = item._obj;
 
2727
      return *this;      
 
2728
    }
 
2729
    
 
2730
    ~PyObject_ptr() 
 
2731
    {
 
2732
      Py_XDECREF(_obj);
 
2733
    }
 
2734
    
 
2735
    operator PyObject *() const
 
2736
    {
 
2737
      return _obj;
 
2738
    }
 
2739
 
 
2740
    PyObject *operator->() const
 
2741
    {
 
2742
      return _obj;
 
2743
    }
 
2744
  };
 
2745
}
 
2746
 
 
2747
 
 
2748
namespace swig {
 
2749
  struct PyObject_var : PyObject_ptr {
 
2750
    PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
 
2751
    
 
2752
    PyObject_var & operator = (PyObject* obj)
 
2753
    {
 
2754
      Py_XDECREF(_obj);
 
2755
      _obj = obj;
 
2756
      return *this;      
 
2757
    }
 
2758
  };
 
2759
}
 
2760
 
 
2761
 
 
2762
#include "wx/wxPython/wxPython.h"
 
2763
#include "wx/wxPython/pyclasses.h"
 
2764
 
 
2765
 static const wxString wxPyPanelNameStr(wxPanelNameStr); 
 
2766
 static const wxString wxPyEmptyString(wxEmptyString); 
 
2767
 static const wxString wxPyControlNameStr(wxControlNameStr); 
 
2768
 
 
2769
    const wxArrayString wxPyEmptyStringArray;
 
2770
 
 
2771
 static const wxString wxPyButtonNameStr(wxButtonNameStr); 
 
2772
 
 
2773
  #define SWIG_From_long   PyInt_FromLong 
 
2774
 
 
2775
 
 
2776
SWIGINTERNINLINE PyObject *
 
2777
SWIG_From_int  (int value)
 
2778
{    
 
2779
  return SWIG_From_long  (value);
 
2780
}
 
2781
 
 
2782
 
 
2783
#include <limits.h>
 
2784
#ifndef LLONG_MIN
 
2785
# define LLONG_MIN      LONG_LONG_MIN
 
2786
#endif
 
2787
#ifndef LLONG_MAX
 
2788
# define LLONG_MAX      LONG_LONG_MAX
 
2789
#endif
 
2790
#ifndef ULLONG_MAX
 
2791
# define ULLONG_MAX     ULONG_LONG_MAX
 
2792
#endif
 
2793
 
 
2794
 
 
2795
SWIGINTERN int
 
2796
SWIG_AsVal_long (PyObject* obj, long* val)
 
2797
{
 
2798
    if (PyNumber_Check(obj)) {
 
2799
        if (val) *val = PyInt_AsLong(obj);
 
2800
        return SWIG_OK;
 
2801
    }
 
2802
    return SWIG_TypeError;
 
2803
}
 
2804
 
 
2805
 
 
2806
SWIGINTERN int
 
2807
SWIG_AsVal_int (PyObject * obj, int *val)
 
2808
{
 
2809
  long v;
 
2810
  int res = SWIG_AsVal_long (obj, &v);
 
2811
  if (SWIG_IsOK(res)) {
 
2812
    if ((v < INT_MIN || v > INT_MAX)) {
 
2813
      return SWIG_OverflowError;
 
2814
    } else {
 
2815
      if (val) *val = static_cast< int >(v);
 
2816
    }
 
2817
  }  
 
2818
  return res;
 
2819
}
 
2820
 
 
2821
 
 
2822
SWIGINTERN int
 
2823
SWIG_AsVal_bool (PyObject *obj, bool *val)
 
2824
{
 
2825
  if (obj == Py_True) {
 
2826
    if (val) *val = true;
 
2827
    return SWIG_OK;
 
2828
  } else if (obj == Py_False) {
 
2829
    if (val) *val = false;
 
2830
    return SWIG_OK;
 
2831
  } else {
 
2832
    long v = 0;
 
2833
    int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
 
2834
    if (SWIG_IsOK(res) && val) *val = v ? true : false;
 
2835
    return res;
 
2836
  }
 
2837
}
 
2838
 
 
2839
 static const wxString wxPyCheckBoxNameStr(wxCheckBoxNameStr); 
 
2840
 static const wxString wxPyChoiceNameStr(wxChoiceNameStr); 
 
2841
 static const wxString wxPyComboBoxNameStr(wxComboBoxNameStr); 
 
2842
SWIGINTERN void wxComboBox_SetMark(wxComboBox *self,long from,long to){
 
2843
            self->SetSelection(from, to);
 
2844
        }
 
2845
SWIGINTERN bool wxComboBox_IsEmpty(wxComboBox *self){
 
2846
            return self->wxItemContainer::IsEmpty();
 
2847
        }
 
2848
 static const wxString wxPyGaugeNameStr(wxGaugeNameStr); 
 
2849
 static const wxString wxPyStaticBitmapNameStr(wxStaticBitmapNameStr); 
 
2850
 static const wxString wxPyStaticBoxNameStr(wxStaticBoxNameStr); 
 
2851
 static const wxString wxPyStaticTextNameStr(wxStaticTextNameStr); 
 
2852
 static const wxString wxPyStaticLineNameStr(wxStaticLineNameStr); 
 
2853
 
 
2854
#include <wx/checklst.h>
 
2855
 
 
2856
 static const wxString wxPyListBoxNameStr(wxListBoxNameStr); 
 
2857
SWIGINTERN void wxListBox_Insert(wxListBox *self,wxString const &item,int pos,PyObject *clientData=NULL){
 
2858
            if (clientData)
 
2859
            {
 
2860
                wxPyClientData* data = new wxPyClientData(clientData);
 
2861
                self->Insert(item, pos, data);
 
2862
            }
 
2863
            else
 
2864
                self->Insert(item, pos);
 
2865
        }
 
2866
 
 
2867
SWIGINTERN int 
 
2868
SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
 
2869
{
 
2870
    long v = 0;
 
2871
    int res = SWIG_AsVal_long(obj, &v);
 
2872
    if (SWIG_IsOK(res)) {
 
2873
        if ( v < 0) {
 
2874
            return SWIG_ValueError;
 
2875
        }
 
2876
        else if (val)
 
2877
            *val = (unsigned long)v;
 
2878
    }
 
2879
    return res;
 
2880
}
 
2881
 
 
2882
 
 
2883
SWIGINTERN int
 
2884
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
 
2885
{
 
2886
  unsigned long v;
 
2887
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
 
2888
  if (SWIG_IsOK(res)) {
 
2889
    if ((v > UINT_MAX)) {
 
2890
      return SWIG_OverflowError;
 
2891
    } else {
 
2892
      if (val) *val = static_cast< unsigned int >(v);
 
2893
    }
 
2894
  }  
 
2895
  return res;
 
2896
}
 
2897
 
 
2898
SWIGINTERN PyObject *wxListBox_GetSelections(wxListBox *self){
 
2899
            wxPyBlock_t blocked = wxPyBeginBlockThreads();
 
2900
            wxArrayInt lst;
 
2901
            self->GetSelections(lst);
 
2902
            PyObject *tup = PyTuple_New(lst.GetCount());
 
2903
            for (size_t i=0; i<lst.GetCount(); i++)
 
2904
            {
 
2905
                PyTuple_SetItem(tup, i, PyInt_FromLong(lst[i]));
 
2906
            }
 
2907
            wxPyEndBlockThreads(blocked);
 
2908
            return tup;
 
2909
        }
 
2910
SWIGINTERN void wxListBox_SetItemForegroundColour(wxListBox *self,int item,wxColour const &c){
 
2911
            #ifdef __WXMSW__
 
2912
                 if (self->GetWindowStyle() & wxLB_OWNERDRAW)
 
2913
                     self->GetItem(item)->SetTextColour(c);
 
2914
            #endif
 
2915
        }
 
2916
SWIGINTERN void wxListBox_SetItemBackgroundColour(wxListBox *self,int item,wxColour const &c){
 
2917
            #ifdef __WXMSW__
 
2918
                 if (self->GetWindowStyle() & wxLB_OWNERDRAW)
 
2919
                     self->GetItem(item)->SetBackgroundColour(c);
 
2920
            #endif
 
2921
        }
 
2922
SWIGINTERN void wxListBox_SetItemFont(wxListBox *self,int item,wxFont const &f){
 
2923
            #ifdef __WXMSW__
 
2924
                 if (self->GetWindowStyle() & wxLB_OWNERDRAW)
 
2925
                     self->GetItem(item)->SetFont(f);
 
2926
            #endif
 
2927
        }
 
2928
 static const wxString wxPyTextCtrlNameStr(wxTextCtrlNameStr); 
 
2929
SWIGINTERN void wxTextCtrl_MacCheckSpelling(wxTextCtrl *self,bool check){}
 
2930
SWIGINTERN void wxTextCtrl_write(wxTextCtrl *self,wxString const &text){
 
2931
            self->AppendText(text);
 
2932
        }
 
2933
 static const wxString wxPyScrollBarNameStr(wxScrollBarNameStr); 
 
2934
 static const wxString wxPySPIN_BUTTON_NAME(wxSPIN_BUTTON_NAME); 
 
2935
 static const wxString wxPySpinCtrlNameStr(_T("wxSpinCtrl")); 
 
2936
 
 
2937
SWIGINTERN int
 
2938
SWIG_AsVal_double (PyObject *obj, double* val)
 
2939
{
 
2940
    if (PyNumber_Check(obj)) {
 
2941
        if (val) *val = PyFloat_AsDouble(obj);
 
2942
        return SWIG_OK;
 
2943
    }
 
2944
    return SWIG_TypeError;
 
2945
}
 
2946
 
 
2947
 
 
2948
  #define SWIG_From_double   PyFloat_FromDouble 
 
2949
 
 
2950
 
 
2951
SWIGINTERNINLINE PyObject* 
 
2952
SWIG_From_unsigned_SS_long  (unsigned long value)
 
2953
{
 
2954
  return (value > LONG_MAX) ?
 
2955
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value)); 
 
2956
}
 
2957
 
 
2958
 
 
2959
SWIGINTERNINLINE PyObject *
 
2960
SWIG_From_unsigned_SS_int  (unsigned int value)
 
2961
{    
 
2962
  return SWIG_From_unsigned_SS_long  (value);
 
2963
}
 
2964
 
 
2965
 static const wxString wxPyRadioBoxNameStr(wxRadioBoxNameStr); 
 
2966
 static const wxString wxPyRadioButtonNameStr(wxRadioButtonNameStr); 
 
2967
 
 
2968
SWIGINTERNINLINE PyObject *
 
2969
SWIG_From_size_t  (size_t value)
 
2970
{    
 
2971
  return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
 
2972
}
 
2973
 
 
2974
 
 
2975
#include <wx/slider.h>
 
2976
 
 
2977
 
 
2978
 static const wxString wxPySliderNameStr(wxSliderNameStr); 
 
2979
 static const wxString wxPyToggleButtonNameStr(_T("wxToggleButton")); 
 
2980
 
 
2981
#if !wxUSE_TOGGLEBTN
 
2982
// implement dummy items for platforms that don't have this class
 
2983
 
 
2984
#define wxEVT_COMMAND_TOGGLEBUTTON_CLICKED 0
 
2985
    
 
2986
class wxToggleButton : public wxAnyButton
 
2987
{
 
2988
public:
 
2989
    wxToggleButton(wxWindow *, wxWindowID, const wxString&,
 
2990
                   const wxPoint&, const wxSize&, long,
 
2991
                   const wxValidator&, const wxString&)
 
2992
        { wxPyRaiseNotImplemented(); }
 
2993
    
 
2994
    wxToggleButton()
 
2995
        { wxPyRaiseNotImplemented(); }
 
2996
};
 
2997
#endif
 
2998
 
 
2999
 static const wxString wxPyNotebookNameStr(wxNotebookNameStr); 
 
3000
 
 
3001
SWIGINTERNINLINE int
 
3002
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
 
3003
{
 
3004
  unsigned long v;
 
3005
  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
 
3006
  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
 
3007
  return res;
 
3008
}
 
3009
 
 
3010
 static const wxString wxPyToolBarNameStr(wxToolBarNameStr); 
 
3011
SWIGINTERN PyObject *wxToolBarToolBase_GetClientData(wxToolBarToolBase *self){
 
3012
            wxPyUserData* udata = (wxPyUserData*)self->GetClientData();
 
3013
            return wxPyUserData::SafeGetData(udata);
 
3014
        }
 
3015
SWIGINTERN void wxToolBarToolBase_SetClientData(wxToolBarToolBase *self,PyObject *clientData){
 
3016
            self->SetClientData(new wxPyUserData(clientData));
 
3017
        }
 
3018
SWIGINTERN wxToolBarToolBase *wxToolBarBase_DoAddTool(wxToolBarBase *self,int id,wxString const &label,wxBitmap const &bitmap,wxBitmap const &bmpDisabled=wxNullBitmap,wxItemKind kind=wxITEM_NORMAL,wxString const &shortHelp=wxPyEmptyString,wxString const &longHelp=wxPyEmptyString,PyObject *clientData=NULL){
 
3019
            wxPyUserData* udata = NULL;
 
3020
            if (clientData && clientData != Py_None)
 
3021
                udata = new wxPyUserData(clientData);
 
3022
            return self->AddTool(id, label, bitmap, bmpDisabled, kind,
 
3023
                                 shortHelp, longHelp, udata);
 
3024
        }
 
3025
SWIGINTERN wxToolBarToolBase *wxToolBarBase_DoInsertTool(wxToolBarBase *self,size_t pos,int id,wxString const &label,wxBitmap const &bitmap,wxBitmap const &bmpDisabled=wxNullBitmap,wxItemKind kind=wxITEM_NORMAL,wxString const &shortHelp=wxPyEmptyString,wxString const &longHelp=wxPyEmptyString,PyObject *clientData=NULL){
 
3026
            wxPyUserData* udata = NULL;
 
3027
            if (clientData && clientData != Py_None)
 
3028
                udata = new wxPyUserData(clientData);
 
3029
            return self->InsertTool(pos, id, label, bitmap, bmpDisabled, kind,
 
3030
                                    shortHelp, longHelp, udata);
 
3031
        }
 
3032
SWIGINTERN PyObject *wxToolBarBase_GetToolClientData(wxToolBarBase *self,int id){
 
3033
            wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(id);
 
3034
            return wxPyUserData::SafeGetData(udata);
 
3035
        }
 
3036
SWIGINTERN void wxToolBarBase_SetToolClientData(wxToolBarBase *self,int id,PyObject *clientData){
 
3037
            self->SetToolClientData(id, new wxPyUserData(clientData));
 
3038
        }
 
3039
 
 
3040
#include <wx/listctrl.h>
 
3041
 
 
3042
 static const wxString wxPyListCtrlNameStr(wxListCtrlNameStr); 
 
3043
SWIGINTERN void wxListItemAttr_Destroy(wxListItemAttr *self){ delete self; }
 
3044
 // Python aware sorting function for wxPyListCtrl
 
3045
    static int wxCALLBACK wxPyListCtrl_SortItems(wxIntPtr item1, wxIntPtr item2, wxIntPtr funcPtr) {
 
3046
        int retval = 0;
 
3047
        PyObject* func = (PyObject*)funcPtr;
 
3048
        wxPyBlock_t blocked = wxPyBeginBlockThreads();
 
3049
 
 
3050
        PyObject* args = Py_BuildValue("(ii)", item1, item2);
 
3051
        PyObject* result = PyEval_CallObject(func, args);
 
3052
        Py_DECREF(args);
 
3053
        if (result) {
 
3054
            retval = PyInt_AsLong(result);
 
3055
            Py_DECREF(result);
 
3056
        }
 
3057
 
 
3058
        wxPyEndBlockThreads(blocked);
 
3059
        return retval;
 
3060
    }
 
3061
 
 
3062
  // C++ Version of a Python aware class
 
3063
class wxPyListCtrl : public wxListCtrl {
 
3064
    DECLARE_ABSTRACT_CLASS(wxPyListCtrl)
 
3065
public:
 
3066
    wxPyListCtrl() : wxListCtrl() {}
 
3067
    wxPyListCtrl(wxWindow* parent, wxWindowID id,
 
3068
                 const wxPoint& pos,
 
3069
                 const wxSize& size,
 
3070
                 long style,
 
3071
                 const wxValidator& validator,
 
3072
                 const wxString& name) :
 
3073
        wxListCtrl(parent, id, pos, size, style, validator, name) {}
 
3074
 
 
3075
    bool Create(wxWindow* parent, wxWindowID id,
 
3076
                const wxPoint& pos,
 
3077
                const wxSize& size,
 
3078
                long style,
 
3079
                const wxValidator& validator,
 
3080
                const wxString& name) {
 
3081
        return wxListCtrl::Create(parent, id, pos, size, style, validator, name);
 
3082
    }
 
3083
 
 
3084
    DEC_PYCALLBACK_STRING_LONGLONG(OnGetItemText);
 
3085
    DEC_PYCALLBACK_LISTATTR_LONG(OnGetItemAttr);
 
3086
 
 
3087
    // use the virtual version to avoid a confusing assert in the base class
 
3088
    DEC_PYCALLBACK_INT_LONG_virtual(OnGetItemImage);
 
3089
    DEC_PYCALLBACK_INT_LONGLONG(OnGetItemColumnImage);
 
3090
 
 
3091
    PYPRIVATE;
 
3092
};
 
3093
 
 
3094
IMPLEMENT_ABSTRACT_CLASS(wxPyListCtrl, wxListCtrl);
 
3095
 
 
3096
IMP_PYCALLBACK_STRING_LONGLONG(wxPyListCtrl, wxListCtrl, OnGetItemText);
 
3097
IMP_PYCALLBACK_LISTATTR_LONG(wxPyListCtrl, wxListCtrl, OnGetItemAttr);
 
3098
IMP_PYCALLBACK_INT_LONG_virtual(wxPyListCtrl, wxListCtrl, OnGetItemImage);
 
3099
IMP_PYCALLBACK_INT_LONGLONG(wxPyListCtrl, wxListCtrl, OnGetItemColumnImage);
 
3100
 
 
3101
 
 
3102
SWIGINTERN wxListItem *wxPyListCtrl_GetColumn(wxPyListCtrl *self,int col){
 
3103
            wxListItem item;
 
3104
            item.SetMask( wxLIST_MASK_STATE |
 
3105
                          wxLIST_MASK_TEXT  |
 
3106
                          wxLIST_MASK_IMAGE |
 
3107
                          wxLIST_MASK_DATA  |
 
3108
                          wxLIST_SET_ITEM   |
 
3109
                          wxLIST_MASK_WIDTH |
 
3110
                          wxLIST_MASK_FORMAT
 
3111
                          );
 
3112
            if (self->GetColumn(col, item))
 
3113
                return new wxListItem(item);
 
3114
            else
 
3115
                return NULL;
 
3116
        }
 
3117
SWIGINTERN bool wxPyListCtrl_HasColumnOrderSupport(){
 
3118
        #ifdef wxHAS_LISTCTRL_COLUMN_ORDER
 
3119
            return true;
 
3120
        #else
 
3121
            return false;
 
3122
        #endif
 
3123
        }
 
3124
SWIGINTERN int wxPyListCtrl_GetColumnOrder(wxPyListCtrl const *self,int col){
 
3125
        #ifdef wxHAS_LISTCTRL_COLUMN_ORDER
 
3126
            return self->GetColumnOrder(col);
 
3127
        #else
 
3128
            wxPyRaiseNotImplemented();
 
3129
            return 0;
 
3130
        #endif
 
3131
        }
 
3132
SWIGINTERN int wxPyListCtrl_GetColumnIndexFromOrder(wxPyListCtrl const *self,int order){
 
3133
        #ifdef wxHAS_LISTCTRL_COLUMN_ORDER
 
3134
            return self->GetColumnIndexFromOrder(order);
 
3135
        #else
 
3136
            wxPyRaiseNotImplemented();
 
3137
            return 0;
 
3138
        #endif
 
3139
        }
 
3140
SWIGINTERN wxArrayInt wxPyListCtrl_GetColumnsOrder(wxPyListCtrl const *self){
 
3141
        #ifdef wxHAS_LISTCTRL_COLUMN_ORDER
 
3142
            return self->GetColumnsOrder();
 
3143
        #else
 
3144
            wxPyRaiseNotImplemented();
 
3145
            return wxArrayInt();
 
3146
        #endif
 
3147
        }
 
3148
SWIGINTERN bool wxPyListCtrl_SetColumnsOrder(wxPyListCtrl *self,wxArrayInt const &orders){
 
3149
        #ifdef wxHAS_LISTCTRL_COLUMN_ORDER
 
3150
            return self->SetColumnsOrder(orders);
 
3151
        #else
 
3152
            wxPyRaiseNotImplemented();
 
3153
            return false;
 
3154
        #endif
 
3155
        }
 
3156
SWIGINTERN wxListItem *wxPyListCtrl_GetItem(wxPyListCtrl *self,long itemId,int col=0){
 
3157
            wxListItem* info = new wxListItem;
 
3158
            info->m_itemId = itemId;
 
3159
            info->m_col = col;
 
3160
            info->m_mask = 0xFFFF;
 
3161
            info->m_stateMask = 0xFFFF;
 
3162
            self->GetItem(*info);
 
3163
            return info;
 
3164
        }
 
3165
SWIGINTERN wxPoint wxPyListCtrl_GetItemPosition(wxPyListCtrl *self,long item){
 
3166
            wxPoint pos;
 
3167
            self->GetItemPosition(item, pos);
 
3168
            return pos;
 
3169
        }
 
3170
SWIGINTERN wxRect wxPyListCtrl_GetItemRect(wxPyListCtrl *self,long item,int code=wxLIST_RECT_BOUNDS){
 
3171
            wxRect rect;
 
3172
            self->GetItemRect(item, rect, code);
 
3173
            return rect;
 
3174
        }
 
3175
SWIGINTERN bool wxPyListCtrl_SortItems(wxPyListCtrl *self,PyObject *func){
 
3176
                        {
 
3177
                                wxPyThreadBlocker blocker;
 
3178
                                if (!PyCallable_Check(func))
 
3179
                                        return false;
 
3180
            }
 
3181
            return self->SortItems((wxListCtrlCompare)wxPyListCtrl_SortItems, (long)func);
 
3182
        }
 
3183
SWIGINTERN wxWindow *wxPyListCtrl_GetMainWindow(wxPyListCtrl *self){
 
3184
        
 
3185
 
 
3186
 
 
3187
            return (wxWindow*)self->m_mainWin;
 
3188
        
 
3189
        }
 
3190
 
 
3191
#include <wx/treectrl.h>
 
3192
#include "wx/wxPython/pytree.h"
 
3193
 
 
3194
 static const wxString wxPyTreeCtrlNameStr(_T("wxTreeCtrl")); 
 
3195
SWIGINTERN bool wxTreeItemId___eq__(wxTreeItemId *self,wxTreeItemId const *other){ return other ? (*self == *other) : false; }
 
3196
SWIGINTERN bool wxTreeItemId___ne__(wxTreeItemId *self,wxTreeItemId const *other){ return other ? (*self != *other) : true;  }
 
3197
SWIGINTERN void wxPyTreeItemData_Destroy(wxPyTreeItemData *self){ delete self; }
 
3198
 
 
3199
    static wxTreeItemId wxNullTreeItemId;
 
3200
 
 
3201
 // C++ version of Python aware wxTreeCtrl
 
3202
class wxPyTreeCtrl : public wxTreeCtrl {
 
3203
    DECLARE_ABSTRACT_CLASS(wxPyTreeCtrl)
 
3204
public:
 
3205
    wxPyTreeCtrl() : wxTreeCtrl() {}
 
3206
    wxPyTreeCtrl(wxWindow *parent, wxWindowID id,
 
3207
                 const wxPoint& pos,
 
3208
                 const wxSize& size,
 
3209
                 long style,
 
3210
                 const wxValidator& validator,
 
3211
                 const wxString& name) :
 
3212
        wxTreeCtrl(parent, id, pos, size, style, validator, name) {}
 
3213
 
 
3214
    bool Create(wxWindow *parent, wxWindowID id,
 
3215
                const wxPoint& pos,
 
3216
                const wxSize& size,
 
3217
                long style,
 
3218
                const wxValidator& validator,
 
3219
                const wxString& name) {
 
3220
        return wxTreeCtrl::Create(parent, id, pos, size, style, validator, name);
 
3221
    }
 
3222
 
 
3223
 
 
3224
    int OnCompareItems(const wxTreeItemId& item1,
 
3225
                       const wxTreeItemId& item2) {
 
3226
        int rval = 0;
 
3227
        bool found;
 
3228
        wxPyBlock_t blocked = wxPyBeginBlockThreads();
 
3229
        if ((found = wxPyCBH_findCallback(m_myInst, "OnCompareItems"))) {
 
3230
            PyObject *o1 = wxPyConstructObject((void*)&item1, wxT("wxTreeItemId"), false);
 
3231
            PyObject *o2 = wxPyConstructObject((void*)&item2, wxT("wxTreeItemId"), false);
 
3232
            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)",o1,o2));
 
3233
            Py_DECREF(o1);
 
3234
            Py_DECREF(o2);
 
3235
        }
 
3236
        wxPyEndBlockThreads(blocked);
 
3237
        if (! found)
 
3238
            rval = wxTreeCtrl::OnCompareItems(item1, item2);
 
3239
        return rval;
 
3240
    }
 
3241
    PYPRIVATE;
 
3242
};
 
3243
 
 
3244
IMPLEMENT_ABSTRACT_CLASS(wxPyTreeCtrl, wxTreeCtrl);
 
3245
 
 
3246
 
 
3247
SWIGINTERN wxPyTreeItemData *wxPyTreeCtrl_GetItemData(wxPyTreeCtrl *self,wxTreeItemId const &item){
 
3248
            wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
 
3249
            return data;
 
3250
        }
 
3251
SWIGINTERN PyObject *wxPyTreeCtrl_GetItemPyData(wxPyTreeCtrl *self,wxTreeItemId const &item){
 
3252
            wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
 
3253
            return wxPyTreeItemData::SafeGetData(data);
 
3254
        }
 
3255
SWIGINTERN void wxPyTreeCtrl_SetItemData(wxPyTreeCtrl *self,wxTreeItemId const &item,wxPyTreeItemData *data){
 
3256
            self->SetItemData(item, data);
 
3257
        }
 
3258
SWIGINTERN void wxPyTreeCtrl_SetItemPyData(wxPyTreeCtrl *self,wxTreeItemId const &item,PyObject *obj){
 
3259
            wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
 
3260
            if (data == NULL) {
 
3261
                data = new wxPyTreeItemData(obj);
 
3262
                self->SetItemData(item, data);
 
3263
            } else {
 
3264
                data->SetData(obj);
 
3265
            }
 
3266
        }
 
3267
SWIGINTERN PyObject *wxPyTreeCtrl_GetSelections(wxPyTreeCtrl *self){
 
3268
            wxPyBlock_t blocked = wxPyBeginBlockThreads();
 
3269
            PyObject*           rval = PyList_New(0);
 
3270
            wxArrayTreeItemIds  array;
 
3271
            size_t              num, x;
 
3272
            num = self->GetSelections(array);
 
3273
            for (x=0; x < num; x++) {
 
3274
                wxTreeItemId *tii = new wxTreeItemId(array.Item(x));
 
3275
                PyObject* item = wxPyConstructObject((void*)tii, wxT("wxTreeItemId"), true);
 
3276
                PyList_Append(rval, item);
 
3277
                Py_DECREF(item);
 
3278
            }
 
3279
            wxPyEndBlockThreads(blocked);
 
3280
            return rval;
 
3281
        }
 
3282
SWIGINTERN PyObject *wxPyTreeCtrl_GetFirstChild(wxPyTreeCtrl *self,wxTreeItemId const &item){
 
3283
            void* cookie = 0;
 
3284
            wxTreeItemId* ritem = new wxTreeItemId(self->GetFirstChild(item, cookie));
 
3285
            wxPyBlock_t blocked = wxPyBeginBlockThreads();
 
3286
            PyObject* tup = PyTuple_New(2);
 
3287
            PyTuple_SET_ITEM(tup, 0, wxPyConstructObject(ritem, wxT("wxTreeItemId"), true));
 
3288
            PyTuple_SET_ITEM(tup, 1, wxPyMakeSwigPtr(cookie, wxT("void")));
 
3289
            wxPyEndBlockThreads(blocked);
 
3290
            return tup;
 
3291
        }
 
3292
SWIGINTERN PyObject *wxPyTreeCtrl_GetNextChild(wxPyTreeCtrl *self,wxTreeItemId const &item,void *cookie){
 
3293
            wxTreeItemId* ritem = new wxTreeItemId(self->GetNextChild(item, cookie));
 
3294
            wxPyBlock_t blocked = wxPyBeginBlockThreads();
 
3295
            PyObject* tup = PyTuple_New(2);
 
3296
            PyTuple_SET_ITEM(tup, 0, wxPyConstructObject(ritem, wxT("wxTreeItemId"), true));
 
3297
            PyTuple_SET_ITEM(tup, 1, wxPyMakeSwigPtr(cookie, wxT("void")));
 
3298
            wxPyEndBlockThreads(blocked);
 
3299
            return tup;
 
3300
        }
 
3301
SWIGINTERN PyObject *wxPyTreeCtrl_GetBoundingRect(wxPyTreeCtrl *self,wxTreeItemId const &item,bool textOnly=false){
 
3302
             wxRect rect;
 
3303
            if (self->GetBoundingRect(item, rect, textOnly)) {
 
3304
                wxPyBlock_t blocked = wxPyBeginBlockThreads();
 
3305
                wxRect* r = new wxRect(rect);
 
3306
                PyObject* val = wxPyConstructObject((void*)r, wxT("wxRect"), true);
 
3307
                wxPyEndBlockThreads(blocked);
 
3308
                return val;
 
3309
            }
 
3310
            else
 
3311
                RETURN_NONE();
 
3312
        }
 
3313
 static const wxString wxPyDirDialogDefaultFolderStr(wxDirDialogDefaultFolderStr); 
 
3314
SWIGINTERN wxArrayString wxGenericDirCtrl_GetPaths(wxGenericDirCtrl *self){
 
3315
            wxArrayString paths;
 
3316
            self->GetPaths(paths);
 
3317
            return paths;
 
3318
        }
 
3319
SWIGINTERN wxArrayString wxGenericDirCtrl_GetFilePaths(wxGenericDirCtrl *self){
 
3320
            wxArrayString paths;
 
3321
            self->GetFilePaths(paths);
 
3322
            return paths;
 
3323
        }
 
3324
SWIGINTERN wxDirItemData *wxGenericDirCtrl_GetDirItemData(wxGenericDirCtrl const *self,wxTreeItemId const &id){
 
3325
            return (wxDirItemData*)self->GetTreeCtrl()->GetItemData(id);
 
3326
        }
 
3327
 
 
3328
SWIGINTERNINLINE PyObject*
 
3329
  SWIG_From_bool  (bool value)
 
3330
{
 
3331
  return PyBool_FromLong(value ? 1 : 0);
 
3332
}
 
3333
 
 
3334
 
 
3335
#ifdef __WXMSW__
 
3336
#include <wx/msw/dc.h>
 
3337
#endif
 
3338
 
 
3339
 // C++ version of Python aware wxControl
 
3340
class wxPyControl : public wxControl
 
3341
{
 
3342
    DECLARE_DYNAMIC_CLASS(wxPyControl)
 
3343
public:
 
3344
    wxPyControl() : wxControl() {}
 
3345
    wxPyControl(wxWindow* parent, const wxWindowID id,
 
3346
                const wxPoint& pos = wxDefaultPosition,
 
3347
                const wxSize& size = wxDefaultSize,
 
3348
                long style = 0,
 
3349
                const wxValidator& validator=wxDefaultValidator,
 
3350
                const wxString& name = wxPyControlNameStr)
 
3351
        : wxControl(parent, id, pos, size, style, validator, name) {}
 
3352
 
 
3353
 
 
3354
    bool DoEraseBackground(wxDC* dc) {
 
3355
#ifdef __WXMSW__
 
3356
        return wxWindow::DoEraseBackground(((wxMSWDCImpl*)dc->GetImpl())->GetHDC());
 
3357
#else
 
3358
        dc->SetBackground(wxBrush(GetBackgroundColour()));
 
3359
        dc->Clear();
 
3360
        return true;
 
3361
#endif
 
3362
    }
 
3363
 
 
3364
    DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
 
3365
    DEC_PYCALLBACK_VOID_INT5(DoSetSize);
 
3366
    DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
 
3367
    DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
 
3368
 
 
3369
    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
 
3370
    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
 
3371
    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
 
3372
    DEC_PYCALLBACK_POINT_const(GetClientAreaOrigin);
 
3373
 
 
3374
    DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
 
3375
    DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
 
3376
 
 
3377
    DEC_PYCALLBACK__(InitDialog);
 
3378
    DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
 
3379
    DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
 
3380
    DEC_PYCALLBACK_BOOL_(Validate);
 
3381
 
 
3382
    DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
 
3383
    DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
 
3384
    DEC_PYCALLBACK_SIZE_const(GetMaxSize);
 
3385
 
 
3386
    DEC_PYCALLBACK_BOOL_BOOL(Enable);
 
3387
 
 
3388
    DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
 
3389
    DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
 
3390
 
 
3391
    DEC_PYCALLBACK_BOOL_const(ShouldInheritColours);
 
3392
    DEC_PYCALLBACK_VIZATTR_(GetDefaultAttributes);
 
3393
    
 
3394
    DEC_PYCALLBACK_BOOL_(HasTransparentBackground);
 
3395
 
 
3396
    DEC_PYCALLBACK_VOID_(OnInternalIdle);
 
3397
 
 
3398
    PYPRIVATE;
 
3399
};
 
3400
 
 
3401
IMPLEMENT_DYNAMIC_CLASS(wxPyControl, wxControl);
 
3402
 
 
3403
IMP_PYCALLBACK_VOID_INT4(wxPyControl, wxControl, DoMoveWindow);
 
3404
IMP_PYCALLBACK_VOID_INT5(wxPyControl, wxControl, DoSetSize);
 
3405
IMP_PYCALLBACK_VOID_INTINT(wxPyControl, wxControl, DoSetClientSize);
 
3406
IMP_PYCALLBACK_VOID_INTINT(wxPyControl, wxControl, DoSetVirtualSize);
 
3407
 
 
3408
IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetSize);
 
3409
IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetClientSize);
 
3410
IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyControl, wxControl, DoGetPosition);
 
3411
IMP_PYCALLBACK_POINT_const(wxPyControl, wxControl, GetClientAreaOrigin);
 
3412
 
 
3413
IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, DoGetVirtualSize);
 
3414
IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, DoGetBestSize);
 
3415
 
 
3416
IMP_PYCALLBACK__(wxPyControl, wxControl, InitDialog);
 
3417
IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, TransferDataFromWindow);
 
3418
IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, TransferDataToWindow);
 
3419
IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, Validate);
 
3420
 
 
3421
IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, AcceptsFocus);
 
3422
IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, AcceptsFocusFromKeyboard);
 
3423
IMP_PYCALLBACK_SIZE_const(wxPyControl, wxControl, GetMaxSize);
 
3424
 
 
3425
IMP_PYCALLBACK_BOOL_BOOL(wxPyControl, wxControl, Enable);
 
3426
 
 
3427
IMP_PYCALLBACK_VOID_WXWINBASE(wxPyControl, wxControl, AddChild);
 
3428
IMP_PYCALLBACK_VOID_WXWINBASE(wxPyControl, wxControl, RemoveChild);
 
3429
 
 
3430
IMP_PYCALLBACK_BOOL_const(wxPyControl, wxControl, ShouldInheritColours);
 
3431
IMP_PYCALLBACK_VIZATTR_(wxPyControl, wxControl, GetDefaultAttributes);
 
3432
 
 
3433
IMP_PYCALLBACK_BOOL_(wxPyControl, wxControl, HasTransparentBackground);
 
3434
 
 
3435
IMP_PYCALLBACK_VOID_(wxPyControl, wxControl, OnInternalIdle);
 
3436
 
 
3437
 
 
3438
 
 
3439
 
 
3440
SWIGINTERN void wxHelpProvider_Destroy(wxHelpProvider *self){ delete self; }
 
3441
 
 
3442
#include <wx/generic/dragimgg.h>
 
3443
 
 
3444
 static const wxString wxPyDatePickerCtrlNameStr(wxDatePickerCtrlNameStr); 
 
3445
SWIGINTERN wxDateTime wxDatePickerCtrlBase_GetLowerLimit(wxDatePickerCtrlBase *self){
 
3446
            wxDateTime rv;
 
3447
            self->GetRange(&rv, NULL);
 
3448
            return rv;
 
3449
        }
 
3450
SWIGINTERN wxDateTime wxDatePickerCtrlBase_GetUpperLimit(wxDatePickerCtrlBase *self){
 
3451
            wxDateTime rv;
 
3452
            self->GetRange(NULL, &rv);
 
3453
            return rv;
 
3454
        }
 
3455
 static const wxString wxPyHyperlinkCtrlNameStr(wxHyperlinkCtrlNameStr); 
 
3456
 
 
3457
// C++ implementation with Python plumbing    
 
3458
class wxPyPickerBase : public wxPickerBase {
 
3459
public: 
 
3460
    wxPyPickerBase() {}
 
3461
    wxPyPickerBase(wxWindow *parent,
 
3462
                   wxWindowID id = -1,
 
3463
                   const wxString& text = wxEmptyString,
 
3464
                   const wxPoint& pos = wxDefaultPosition,
 
3465
                   const wxSize& size = wxDefaultSize,
 
3466
                   long style = 0,
 
3467
                   const wxValidator& validator = wxDefaultValidator,
 
3468
                   const wxString& name = wxButtonNameStr)
 
3469
    {
 
3470
        CreateBase(parent, id, text, pos, size, style, validator, name);
 
3471
    }
 
3472
 
 
3473
    void SetTextCtrl(wxTextCtrl* text) { m_text = text; }
 
3474
    void SetPickerCtrl(wxControl* picker) { m_picker = picker; }
 
3475
 
 
3476
    void PostCreation() { wxPickerBase::PostCreation(); }
 
3477
 
 
3478
    DEC_PYCALLBACK_VOID_pure(UpdatePickerFromTextCtrl);
 
3479
    DEC_PYCALLBACK_VOID_pure(UpdateTextCtrlFromPicker);
 
3480
 
 
3481
    DEC_PYCALLBACK_LONG_LONG_const(GetTextCtrlStyle);
 
3482
    DEC_PYCALLBACK_LONG_LONG_const(GetPickerStyle);
 
3483
    
 
3484
    PYPRIVATE;
 
3485
};
 
3486
 
 
3487
IMP_PYCALLBACK_VOID_pure(wxPyPickerBase, wxPickerBase, UpdatePickerFromTextCtrl);
 
3488
IMP_PYCALLBACK_VOID_pure(wxPyPickerBase, wxPickerBase, UpdateTextCtrlFromPicker);
 
3489
IMP_PYCALLBACK_LONG_LONG_const(wxPyPickerBase, wxPickerBase, GetTextCtrlStyle);
 
3490
IMP_PYCALLBACK_LONG_LONG_const(wxPyPickerBase, wxPickerBase, GetPickerStyle);
 
3491
 
 
3492
 static const wxString wxPyColourPickerCtrlNameStr(wxColourPickerCtrlNameStr); 
 
3493
 static const wxString wxPyFilePickerCtrlNameStr(wxFilePickerCtrlNameStr); 
 
3494
 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr); 
 
3495
 static const wxString wxPyDirPickerCtrlNameStr(wxDirPickerCtrlNameStr); 
 
3496
 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr); 
 
3497
 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr); 
 
3498
 static const wxString wxPyFontPickerCtrlNameStr(wxFontPickerCtrlNameStr); 
 
3499
 static const wxString wxPyCollapsiblePaneNameStr(wxCollapsiblePaneNameStr); 
 
3500
 static const wxString wxPySearchCtrlNameStr(wxSearchCtrlNameStr); 
 
3501
 
 
3502
#if !defined(wxUSE_SEARCHCTRL) || !wxUSE_SEARCHCTRL
 
3503
// define a dummy class for builds that don't have wxSearchCtrl
 
3504
 
 
3505
enum {
 
3506
    wxEVT_COMMAND_SEARCHCTRL_CANCEL_BTN,
 
3507
    wxEVT_COMMAND_SEARCHCTRL_SEARCH_BTN
 
3508
};
 
3509
 
 
3510
class wxSearchCtrl : public wxTextCtrl
 
3511
{
 
3512
public:
 
3513
    wxSearchCtrl() { wxPyRaiseNotImplemented(); }
 
3514
    wxSearchCtrl(wxWindow*, wxWindowID,
 
3515
                 const wxString&,
 
3516
                 const wxPoint&,
 
3517
                 const wxSize&,
 
3518
                 long style,
 
3519
                 const wxValidator&,
 
3520
                 const wxString& name)
 
3521
    { wxPyRaiseNotImplemented(); }
 
3522
 
 
3523
    bool Create( wxWindow*, wxWindowID,
 
3524
                 const wxString&,
 
3525
                 const wxPoint&,
 
3526
                 const wxSize&,
 
3527
                 long style,
 
3528
                 const wxValidator&,
 
3529
                 const wxString& name) {}
 
3530
        
 
3531
    virtual void SetMenu( wxMenu* ) {}
 
3532
    virtual wxMenu* GetMenu() { return NULL; }
 
3533
    
 
3534
    // get/set search options
 
3535
    // ----------------------
 
3536
    virtual void ShowSearchButton( bool ) {}
 
3537
    virtual bool IsSearchButtonVisible() const { return false; }
 
3538
 
 
3539
    virtual void ShowCancelButton( bool ) {}
 
3540
    virtual bool IsCancelButtonVisible() const { return false; }
 
3541
 
 
3542
    virtual void SetDescriptiveText(const wxString& text);
 
3543
    virtual wxString GetDescriptiveText() const;
 
3544
};    
 
3545
#endif
 
3546
 
 
3547
 static const wxString wxPyFileCtrlNameStr(wxFileCtrlNameStr); 
 
3548
SWIGINTERN wxArrayString wxFileCtrl_GetPaths(wxFileCtrl *self){
 
3549
            wxArrayString rval;
 
3550
            self->GetPaths(rval);
 
3551
            return rval;
 
3552
        }
 
3553
SWIGINTERN wxArrayString wxFileCtrl_GetFilenames(wxFileCtrl *self){
 
3554
            wxArrayString rval;
 
3555
            self->GetFilenames(rval);
 
3556
            return rval;
 
3557
        }
 
3558
#ifdef __cplusplus
 
3559
extern "C" {
 
3560
#endif
 
3561
SWIGINTERN int ButtonNameStr_set(PyObject *) {
 
3562
  SWIG_Error(SWIG_AttributeError,"Variable ButtonNameStr is read-only.");
 
3563
  return 1;
 
3564
}
 
3565
 
 
3566
 
 
3567
SWIGINTERN PyObject *ButtonNameStr_get(void) {
 
3568
  PyObject *pyobj = 0;
 
3569
  
 
3570
  {
 
3571
#if wxUSE_UNICODE
 
3572
    pyobj = PyUnicode_FromWideChar((&wxPyButtonNameStr)->c_str(), (&wxPyButtonNameStr)->Len());
 
3573
#else
 
3574
    pyobj = PyString_FromStringAndSize((&wxPyButtonNameStr)->c_str(), (&wxPyButtonNameStr)->Len());
 
3575
#endif
 
3576
  }
 
3577
  return pyobj;
 
3578
}
 
3579
 
 
3580
 
 
3581
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3582
  PyObject *resultobj = 0;
 
3583
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3584
  wxBitmap *arg2 = 0 ;
 
3585
  wxDirection arg3 = (wxDirection) wxLEFT ;
 
3586
  void *argp1 = 0 ;
 
3587
  int res1 = 0 ;
 
3588
  void *argp2 = 0 ;
 
3589
  int res2 = 0 ;
 
3590
  int val3 ;
 
3591
  int ecode3 = 0 ;
 
3592
  PyObject * obj0 = 0 ;
 
3593
  PyObject * obj1 = 0 ;
 
3594
  PyObject * obj2 = 0 ;
 
3595
  char *  kwnames[] = {
 
3596
    (char *) "self",(char *) "bitmap",(char *) "dir", NULL 
 
3597
  };
 
3598
  
 
3599
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AnyButton_SetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
3600
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3601
  if (!SWIG_IsOK(res1)) {
 
3602
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmap" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
3603
  }
 
3604
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3605
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3606
  if (!SWIG_IsOK(res2)) {
 
3607
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyButton_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3608
  }
 
3609
  if (!argp2) {
 
3610
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyButton_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3611
  }
 
3612
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
3613
  if (obj2) {
 
3614
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
3615
    if (!SWIG_IsOK(ecode3)) {
 
3616
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnyButton_SetBitmap" "', expected argument " "3"" of type '" "wxDirection""'");
 
3617
    } 
 
3618
    arg3 = static_cast< wxDirection >(val3);
 
3619
  }
 
3620
  {
 
3621
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3622
    (arg1)->SetBitmap((wxBitmap const &)*arg2,arg3);
 
3623
    wxPyEndAllowThreads(__tstate);
 
3624
    if (PyErr_Occurred()) SWIG_fail;
 
3625
  }
 
3626
  resultobj = SWIG_Py_Void();
 
3627
  return resultobj;
 
3628
fail:
 
3629
  return NULL;
 
3630
}
 
3631
 
 
3632
 
 
3633
SWIGINTERN PyObject *_wrap_AnyButton_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3634
  PyObject *resultobj = 0;
 
3635
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3636
  wxBitmap result;
 
3637
  void *argp1 = 0 ;
 
3638
  int res1 = 0 ;
 
3639
  PyObject *swig_obj[1] ;
 
3640
  
 
3641
  if (!args) SWIG_fail;
 
3642
  swig_obj[0] = args;
 
3643
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3644
  if (!SWIG_IsOK(res1)) {
 
3645
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_GetBitmap" "', expected argument " "1"" of type '" "wxAnyButton const *""'"); 
 
3646
  }
 
3647
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3648
  {
 
3649
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3650
    result = ((wxAnyButton const *)arg1)->GetBitmap();
 
3651
    wxPyEndAllowThreads(__tstate);
 
3652
    if (PyErr_Occurred()) SWIG_fail;
 
3653
  }
 
3654
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
3655
  return resultobj;
 
3656
fail:
 
3657
  return NULL;
 
3658
}
 
3659
 
 
3660
 
 
3661
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3662
  PyObject *resultobj = 0;
 
3663
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3664
  wxBitmap *arg2 = 0 ;
 
3665
  void *argp1 = 0 ;
 
3666
  int res1 = 0 ;
 
3667
  void *argp2 = 0 ;
 
3668
  int res2 = 0 ;
 
3669
  PyObject * obj0 = 0 ;
 
3670
  PyObject * obj1 = 0 ;
 
3671
  char *  kwnames[] = {
 
3672
    (char *) "self",(char *) "bitmap", NULL 
 
3673
  };
 
3674
  
 
3675
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnyButton_SetBitmapLabel",kwnames,&obj0,&obj1)) SWIG_fail;
 
3676
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3677
  if (!SWIG_IsOK(res1)) {
 
3678
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmapLabel" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
3679
  }
 
3680
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3681
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3682
  if (!SWIG_IsOK(res2)) {
 
3683
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyButton_SetBitmapLabel" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3684
  }
 
3685
  if (!argp2) {
 
3686
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyButton_SetBitmapLabel" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3687
  }
 
3688
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
3689
  {
 
3690
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3691
    (arg1)->SetBitmapLabel((wxBitmap const &)*arg2);
 
3692
    wxPyEndAllowThreads(__tstate);
 
3693
    if (PyErr_Occurred()) SWIG_fail;
 
3694
  }
 
3695
  resultobj = SWIG_Py_Void();
 
3696
  return resultobj;
 
3697
fail:
 
3698
  return NULL;
 
3699
}
 
3700
 
 
3701
 
 
3702
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapPressed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3703
  PyObject *resultobj = 0;
 
3704
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3705
  wxBitmap *arg2 = 0 ;
 
3706
  void *argp1 = 0 ;
 
3707
  int res1 = 0 ;
 
3708
  void *argp2 = 0 ;
 
3709
  int res2 = 0 ;
 
3710
  PyObject * obj0 = 0 ;
 
3711
  PyObject * obj1 = 0 ;
 
3712
  char *  kwnames[] = {
 
3713
    (char *) "self",(char *) "bitmap", NULL 
 
3714
  };
 
3715
  
 
3716
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnyButton_SetBitmapPressed",kwnames,&obj0,&obj1)) SWIG_fail;
 
3717
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3718
  if (!SWIG_IsOK(res1)) {
 
3719
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmapPressed" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
3720
  }
 
3721
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3722
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3723
  if (!SWIG_IsOK(res2)) {
 
3724
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyButton_SetBitmapPressed" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3725
  }
 
3726
  if (!argp2) {
 
3727
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyButton_SetBitmapPressed" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3728
  }
 
3729
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
3730
  {
 
3731
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3732
    (arg1)->SetBitmapPressed((wxBitmap const &)*arg2);
 
3733
    wxPyEndAllowThreads(__tstate);
 
3734
    if (PyErr_Occurred()) SWIG_fail;
 
3735
  }
 
3736
  resultobj = SWIG_Py_Void();
 
3737
  return resultobj;
 
3738
fail:
 
3739
  return NULL;
 
3740
}
 
3741
 
 
3742
 
 
3743
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapDisabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3744
  PyObject *resultobj = 0;
 
3745
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3746
  wxBitmap *arg2 = 0 ;
 
3747
  void *argp1 = 0 ;
 
3748
  int res1 = 0 ;
 
3749
  void *argp2 = 0 ;
 
3750
  int res2 = 0 ;
 
3751
  PyObject * obj0 = 0 ;
 
3752
  PyObject * obj1 = 0 ;
 
3753
  char *  kwnames[] = {
 
3754
    (char *) "self",(char *) "bitmap", NULL 
 
3755
  };
 
3756
  
 
3757
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnyButton_SetBitmapDisabled",kwnames,&obj0,&obj1)) SWIG_fail;
 
3758
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3759
  if (!SWIG_IsOK(res1)) {
 
3760
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmapDisabled" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
3761
  }
 
3762
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3763
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3764
  if (!SWIG_IsOK(res2)) {
 
3765
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyButton_SetBitmapDisabled" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3766
  }
 
3767
  if (!argp2) {
 
3768
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyButton_SetBitmapDisabled" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3769
  }
 
3770
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
3771
  {
 
3772
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3773
    (arg1)->SetBitmapDisabled((wxBitmap const &)*arg2);
 
3774
    wxPyEndAllowThreads(__tstate);
 
3775
    if (PyErr_Occurred()) SWIG_fail;
 
3776
  }
 
3777
  resultobj = SWIG_Py_Void();
 
3778
  return resultobj;
 
3779
fail:
 
3780
  return NULL;
 
3781
}
 
3782
 
 
3783
 
 
3784
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3785
  PyObject *resultobj = 0;
 
3786
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3787
  wxBitmap *arg2 = 0 ;
 
3788
  void *argp1 = 0 ;
 
3789
  int res1 = 0 ;
 
3790
  void *argp2 = 0 ;
 
3791
  int res2 = 0 ;
 
3792
  PyObject * obj0 = 0 ;
 
3793
  PyObject * obj1 = 0 ;
 
3794
  char *  kwnames[] = {
 
3795
    (char *) "self",(char *) "bitmap", NULL 
 
3796
  };
 
3797
  
 
3798
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnyButton_SetBitmapCurrent",kwnames,&obj0,&obj1)) SWIG_fail;
 
3799
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3800
  if (!SWIG_IsOK(res1)) {
 
3801
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmapCurrent" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
3802
  }
 
3803
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3804
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3805
  if (!SWIG_IsOK(res2)) {
 
3806
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyButton_SetBitmapCurrent" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3807
  }
 
3808
  if (!argp2) {
 
3809
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyButton_SetBitmapCurrent" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3810
  }
 
3811
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
3812
  {
 
3813
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3814
    (arg1)->SetBitmapCurrent((wxBitmap const &)*arg2);
 
3815
    wxPyEndAllowThreads(__tstate);
 
3816
    if (PyErr_Occurred()) SWIG_fail;
 
3817
  }
 
3818
  resultobj = SWIG_Py_Void();
 
3819
  return resultobj;
 
3820
fail:
 
3821
  return NULL;
 
3822
}
 
3823
 
 
3824
 
 
3825
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
3826
  PyObject *resultobj = 0;
 
3827
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3828
  wxBitmap *arg2 = 0 ;
 
3829
  void *argp1 = 0 ;
 
3830
  int res1 = 0 ;
 
3831
  void *argp2 = 0 ;
 
3832
  int res2 = 0 ;
 
3833
  PyObject * obj0 = 0 ;
 
3834
  PyObject * obj1 = 0 ;
 
3835
  char *  kwnames[] = {
 
3836
    (char *) "self",(char *) "bitmap", NULL 
 
3837
  };
 
3838
  
 
3839
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnyButton_SetBitmapFocus",kwnames,&obj0,&obj1)) SWIG_fail;
 
3840
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3841
  if (!SWIG_IsOK(res1)) {
 
3842
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmapFocus" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
3843
  }
 
3844
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3845
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
3846
  if (!SWIG_IsOK(res2)) {
 
3847
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyButton_SetBitmapFocus" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3848
  }
 
3849
  if (!argp2) {
 
3850
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyButton_SetBitmapFocus" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
3851
  }
 
3852
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
3853
  {
 
3854
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3855
    (arg1)->SetBitmapFocus((wxBitmap const &)*arg2);
 
3856
    wxPyEndAllowThreads(__tstate);
 
3857
    if (PyErr_Occurred()) SWIG_fail;
 
3858
  }
 
3859
  resultobj = SWIG_Py_Void();
 
3860
  return resultobj;
 
3861
fail:
 
3862
  return NULL;
 
3863
}
 
3864
 
 
3865
 
 
3866
SWIGINTERN PyObject *_wrap_AnyButton_GetBitmapLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3867
  PyObject *resultobj = 0;
 
3868
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3869
  wxBitmap result;
 
3870
  void *argp1 = 0 ;
 
3871
  int res1 = 0 ;
 
3872
  PyObject *swig_obj[1] ;
 
3873
  
 
3874
  if (!args) SWIG_fail;
 
3875
  swig_obj[0] = args;
 
3876
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3877
  if (!SWIG_IsOK(res1)) {
 
3878
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_GetBitmapLabel" "', expected argument " "1"" of type '" "wxAnyButton const *""'"); 
 
3879
  }
 
3880
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3881
  {
 
3882
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3883
    result = ((wxAnyButton const *)arg1)->GetBitmapLabel();
 
3884
    wxPyEndAllowThreads(__tstate);
 
3885
    if (PyErr_Occurred()) SWIG_fail;
 
3886
  }
 
3887
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
3888
  return resultobj;
 
3889
fail:
 
3890
  return NULL;
 
3891
}
 
3892
 
 
3893
 
 
3894
SWIGINTERN PyObject *_wrap_AnyButton_GetBitmapPressed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3895
  PyObject *resultobj = 0;
 
3896
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3897
  wxBitmap result;
 
3898
  void *argp1 = 0 ;
 
3899
  int res1 = 0 ;
 
3900
  PyObject *swig_obj[1] ;
 
3901
  
 
3902
  if (!args) SWIG_fail;
 
3903
  swig_obj[0] = args;
 
3904
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3905
  if (!SWIG_IsOK(res1)) {
 
3906
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_GetBitmapPressed" "', expected argument " "1"" of type '" "wxAnyButton const *""'"); 
 
3907
  }
 
3908
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3909
  {
 
3910
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3911
    result = ((wxAnyButton const *)arg1)->GetBitmapPressed();
 
3912
    wxPyEndAllowThreads(__tstate);
 
3913
    if (PyErr_Occurred()) SWIG_fail;
 
3914
  }
 
3915
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
3916
  return resultobj;
 
3917
fail:
 
3918
  return NULL;
 
3919
}
 
3920
 
 
3921
 
 
3922
SWIGINTERN PyObject *_wrap_AnyButton_GetBitmapDisabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3923
  PyObject *resultobj = 0;
 
3924
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3925
  wxBitmap result;
 
3926
  void *argp1 = 0 ;
 
3927
  int res1 = 0 ;
 
3928
  PyObject *swig_obj[1] ;
 
3929
  
 
3930
  if (!args) SWIG_fail;
 
3931
  swig_obj[0] = args;
 
3932
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3933
  if (!SWIG_IsOK(res1)) {
 
3934
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_GetBitmapDisabled" "', expected argument " "1"" of type '" "wxAnyButton const *""'"); 
 
3935
  }
 
3936
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3937
  {
 
3938
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3939
    result = ((wxAnyButton const *)arg1)->GetBitmapDisabled();
 
3940
    wxPyEndAllowThreads(__tstate);
 
3941
    if (PyErr_Occurred()) SWIG_fail;
 
3942
  }
 
3943
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
3944
  return resultobj;
 
3945
fail:
 
3946
  return NULL;
 
3947
}
 
3948
 
 
3949
 
 
3950
SWIGINTERN PyObject *_wrap_AnyButton_GetBitmapCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3951
  PyObject *resultobj = 0;
 
3952
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3953
  wxBitmap result;
 
3954
  void *argp1 = 0 ;
 
3955
  int res1 = 0 ;
 
3956
  PyObject *swig_obj[1] ;
 
3957
  
 
3958
  if (!args) SWIG_fail;
 
3959
  swig_obj[0] = args;
 
3960
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3961
  if (!SWIG_IsOK(res1)) {
 
3962
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_GetBitmapCurrent" "', expected argument " "1"" of type '" "wxAnyButton const *""'"); 
 
3963
  }
 
3964
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3965
  {
 
3966
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3967
    result = ((wxAnyButton const *)arg1)->GetBitmapCurrent();
 
3968
    wxPyEndAllowThreads(__tstate);
 
3969
    if (PyErr_Occurred()) SWIG_fail;
 
3970
  }
 
3971
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
3972
  return resultobj;
 
3973
fail:
 
3974
  return NULL;
 
3975
}
 
3976
 
 
3977
 
 
3978
SWIGINTERN PyObject *_wrap_AnyButton_GetBitmapFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
3979
  PyObject *resultobj = 0;
 
3980
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
3981
  wxBitmap result;
 
3982
  void *argp1 = 0 ;
 
3983
  int res1 = 0 ;
 
3984
  PyObject *swig_obj[1] ;
 
3985
  
 
3986
  if (!args) SWIG_fail;
 
3987
  swig_obj[0] = args;
 
3988
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
3989
  if (!SWIG_IsOK(res1)) {
 
3990
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_GetBitmapFocus" "', expected argument " "1"" of type '" "wxAnyButton const *""'"); 
 
3991
  }
 
3992
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
3993
  {
 
3994
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
3995
    result = ((wxAnyButton const *)arg1)->GetBitmapFocus();
 
3996
    wxPyEndAllowThreads(__tstate);
 
3997
    if (PyErr_Occurred()) SWIG_fail;
 
3998
  }
 
3999
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
4000
  return resultobj;
 
4001
fail:
 
4002
  return NULL;
 
4003
}
 
4004
 
 
4005
 
 
4006
SWIGINTERN PyObject *_wrap_AnyButton_GetBitmapSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4007
  PyObject *resultobj = 0;
 
4008
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
4009
  wxBitmap result;
 
4010
  void *argp1 = 0 ;
 
4011
  int res1 = 0 ;
 
4012
  PyObject *swig_obj[1] ;
 
4013
  
 
4014
  if (!args) SWIG_fail;
 
4015
  swig_obj[0] = args;
 
4016
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
4017
  if (!SWIG_IsOK(res1)) {
 
4018
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_GetBitmapSelected" "', expected argument " "1"" of type '" "wxAnyButton const *""'"); 
 
4019
  }
 
4020
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
4021
  {
 
4022
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4023
    result = ((wxAnyButton const *)arg1)->GetBitmapSelected();
 
4024
    wxPyEndAllowThreads(__tstate);
 
4025
    if (PyErr_Occurred()) SWIG_fail;
 
4026
  }
 
4027
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
4028
  return resultobj;
 
4029
fail:
 
4030
  return NULL;
 
4031
}
 
4032
 
 
4033
 
 
4034
SWIGINTERN PyObject *_wrap_AnyButton_GetBitmapHover(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4035
  PyObject *resultobj = 0;
 
4036
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
4037
  wxBitmap result;
 
4038
  void *argp1 = 0 ;
 
4039
  int res1 = 0 ;
 
4040
  PyObject *swig_obj[1] ;
 
4041
  
 
4042
  if (!args) SWIG_fail;
 
4043
  swig_obj[0] = args;
 
4044
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
4045
  if (!SWIG_IsOK(res1)) {
 
4046
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_GetBitmapHover" "', expected argument " "1"" of type '" "wxAnyButton const *""'"); 
 
4047
  }
 
4048
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
4049
  {
 
4050
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4051
    result = ((wxAnyButton const *)arg1)->GetBitmapHover();
 
4052
    wxPyEndAllowThreads(__tstate);
 
4053
    if (PyErr_Occurred()) SWIG_fail;
 
4054
  }
 
4055
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
4056
  return resultobj;
 
4057
fail:
 
4058
  return NULL;
 
4059
}
 
4060
 
 
4061
 
 
4062
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4063
  PyObject *resultobj = 0;
 
4064
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
4065
  wxBitmap *arg2 = 0 ;
 
4066
  void *argp1 = 0 ;
 
4067
  int res1 = 0 ;
 
4068
  void *argp2 = 0 ;
 
4069
  int res2 = 0 ;
 
4070
  PyObject * obj0 = 0 ;
 
4071
  PyObject * obj1 = 0 ;
 
4072
  char *  kwnames[] = {
 
4073
    (char *) "self",(char *) "bitmap", NULL 
 
4074
  };
 
4075
  
 
4076
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnyButton_SetBitmapSelected",kwnames,&obj0,&obj1)) SWIG_fail;
 
4077
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
4078
  if (!SWIG_IsOK(res1)) {
 
4079
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmapSelected" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
4080
  }
 
4081
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
4082
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
4083
  if (!SWIG_IsOK(res2)) {
 
4084
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyButton_SetBitmapSelected" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
4085
  }
 
4086
  if (!argp2) {
 
4087
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyButton_SetBitmapSelected" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
4088
  }
 
4089
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
4090
  {
 
4091
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4092
    (arg1)->SetBitmapSelected((wxBitmap const &)*arg2);
 
4093
    wxPyEndAllowThreads(__tstate);
 
4094
    if (PyErr_Occurred()) SWIG_fail;
 
4095
  }
 
4096
  resultobj = SWIG_Py_Void();
 
4097
  return resultobj;
 
4098
fail:
 
4099
  return NULL;
 
4100
}
 
4101
 
 
4102
 
 
4103
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapHover(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4104
  PyObject *resultobj = 0;
 
4105
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
4106
  wxBitmap *arg2 = 0 ;
 
4107
  void *argp1 = 0 ;
 
4108
  int res1 = 0 ;
 
4109
  void *argp2 = 0 ;
 
4110
  int res2 = 0 ;
 
4111
  PyObject * obj0 = 0 ;
 
4112
  PyObject * obj1 = 0 ;
 
4113
  char *  kwnames[] = {
 
4114
    (char *) "self",(char *) "bitmap", NULL 
 
4115
  };
 
4116
  
 
4117
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnyButton_SetBitmapHover",kwnames,&obj0,&obj1)) SWIG_fail;
 
4118
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
4119
  if (!SWIG_IsOK(res1)) {
 
4120
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmapHover" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
4121
  }
 
4122
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
4123
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
4124
  if (!SWIG_IsOK(res2)) {
 
4125
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyButton_SetBitmapHover" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
4126
  }
 
4127
  if (!argp2) {
 
4128
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyButton_SetBitmapHover" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
4129
  }
 
4130
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
4131
  {
 
4132
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4133
    (arg1)->SetBitmapHover((wxBitmap const &)*arg2);
 
4134
    wxPyEndAllowThreads(__tstate);
 
4135
    if (PyErr_Occurred()) SWIG_fail;
 
4136
  }
 
4137
  resultobj = SWIG_Py_Void();
 
4138
  return resultobj;
 
4139
fail:
 
4140
  return NULL;
 
4141
}
 
4142
 
 
4143
 
 
4144
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapMargins__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
 
4145
  PyObject *resultobj = 0;
 
4146
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
4147
  int arg2 ;
 
4148
  int arg3 ;
 
4149
  void *argp1 = 0 ;
 
4150
  int res1 = 0 ;
 
4151
  int val2 ;
 
4152
  int ecode2 = 0 ;
 
4153
  int val3 ;
 
4154
  int ecode3 = 0 ;
 
4155
  
 
4156
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
 
4157
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
4158
  if (!SWIG_IsOK(res1)) {
 
4159
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmapMargins" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
4160
  }
 
4161
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
4162
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
 
4163
  if (!SWIG_IsOK(ecode2)) {
 
4164
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnyButton_SetBitmapMargins" "', expected argument " "2"" of type '" "int""'");
 
4165
  } 
 
4166
  arg2 = static_cast< int >(val2);
 
4167
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
 
4168
  if (!SWIG_IsOK(ecode3)) {
 
4169
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnyButton_SetBitmapMargins" "', expected argument " "3"" of type '" "int""'");
 
4170
  } 
 
4171
  arg3 = static_cast< int >(val3);
 
4172
  {
 
4173
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4174
    (arg1)->SetBitmapMargins(arg2,arg3);
 
4175
    wxPyEndAllowThreads(__tstate);
 
4176
    if (PyErr_Occurred()) SWIG_fail;
 
4177
  }
 
4178
  resultobj = SWIG_Py_Void();
 
4179
  return resultobj;
 
4180
fail:
 
4181
  return NULL;
 
4182
}
 
4183
 
 
4184
 
 
4185
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapMargins__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
 
4186
  PyObject *resultobj = 0;
 
4187
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
4188
  wxSize *arg2 = 0 ;
 
4189
  void *argp1 = 0 ;
 
4190
  int res1 = 0 ;
 
4191
  wxSize temp2 ;
 
4192
  
 
4193
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
 
4194
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
4195
  if (!SWIG_IsOK(res1)) {
 
4196
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmapMargins" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
4197
  }
 
4198
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
4199
  {
 
4200
    arg2 = &temp2;
 
4201
    if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
 
4202
  }
 
4203
  {
 
4204
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4205
    (arg1)->SetBitmapMargins((wxSize const &)*arg2);
 
4206
    wxPyEndAllowThreads(__tstate);
 
4207
    if (PyErr_Occurred()) SWIG_fail;
 
4208
  }
 
4209
  resultobj = SWIG_Py_Void();
 
4210
  return resultobj;
 
4211
fail:
 
4212
  return NULL;
 
4213
}
 
4214
 
 
4215
 
 
4216
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapMargins(PyObject *self, PyObject *args) {
 
4217
  int argc;
 
4218
  PyObject *argv[4];
 
4219
  
 
4220
  if (!(argc = SWIG_Python_UnpackTuple(args,"AnyButton_SetBitmapMargins",0,3,argv))) SWIG_fail;
 
4221
  --argc;
 
4222
  if (argc == 2) {
 
4223
    return _wrap_AnyButton_SetBitmapMargins__SWIG_1(self, argc, argv);
 
4224
  }
 
4225
  if (argc == 3) {
 
4226
    return _wrap_AnyButton_SetBitmapMargins__SWIG_0(self, argc, argv);
 
4227
  }
 
4228
  
 
4229
fail:
 
4230
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'AnyButton_SetBitmapMargins'");
 
4231
  return NULL;
 
4232
}
 
4233
 
 
4234
 
 
4235
SWIGINTERN PyObject *_wrap_AnyButton_GetBitmapMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4236
  PyObject *resultobj = 0;
 
4237
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
4238
  wxSize result;
 
4239
  void *argp1 = 0 ;
 
4240
  int res1 = 0 ;
 
4241
  PyObject *swig_obj[1] ;
 
4242
  
 
4243
  if (!args) SWIG_fail;
 
4244
  swig_obj[0] = args;
 
4245
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
4246
  if (!SWIG_IsOK(res1)) {
 
4247
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_GetBitmapMargins" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
4248
  }
 
4249
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
4250
  {
 
4251
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4252
    result = (arg1)->GetBitmapMargins();
 
4253
    wxPyEndAllowThreads(__tstate);
 
4254
    if (PyErr_Occurred()) SWIG_fail;
 
4255
  }
 
4256
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
4257
  return resultobj;
 
4258
fail:
 
4259
  return NULL;
 
4260
}
 
4261
 
 
4262
 
 
4263
SWIGINTERN PyObject *_wrap_AnyButton_SetBitmapPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4264
  PyObject *resultobj = 0;
 
4265
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
4266
  wxDirection arg2 ;
 
4267
  void *argp1 = 0 ;
 
4268
  int res1 = 0 ;
 
4269
  int val2 ;
 
4270
  int ecode2 = 0 ;
 
4271
  PyObject * obj0 = 0 ;
 
4272
  PyObject * obj1 = 0 ;
 
4273
  char *  kwnames[] = {
 
4274
    (char *) "self",(char *) "dir", NULL 
 
4275
  };
 
4276
  
 
4277
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnyButton_SetBitmapPosition",kwnames,&obj0,&obj1)) SWIG_fail;
 
4278
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
4279
  if (!SWIG_IsOK(res1)) {
 
4280
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_SetBitmapPosition" "', expected argument " "1"" of type '" "wxAnyButton *""'"); 
 
4281
  }
 
4282
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
4283
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
4284
  if (!SWIG_IsOK(ecode2)) {
 
4285
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnyButton_SetBitmapPosition" "', expected argument " "2"" of type '" "wxDirection""'");
 
4286
  } 
 
4287
  arg2 = static_cast< wxDirection >(val2);
 
4288
  {
 
4289
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4290
    (arg1)->SetBitmapPosition(arg2);
 
4291
    wxPyEndAllowThreads(__tstate);
 
4292
    if (PyErr_Occurred()) SWIG_fail;
 
4293
  }
 
4294
  resultobj = SWIG_Py_Void();
 
4295
  return resultobj;
 
4296
fail:
 
4297
  return NULL;
 
4298
}
 
4299
 
 
4300
 
 
4301
SWIGINTERN PyObject *_wrap_AnyButton_DontShowLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4302
  PyObject *resultobj = 0;
 
4303
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
4304
  bool result;
 
4305
  void *argp1 = 0 ;
 
4306
  int res1 = 0 ;
 
4307
  PyObject *swig_obj[1] ;
 
4308
  
 
4309
  if (!args) SWIG_fail;
 
4310
  swig_obj[0] = args;
 
4311
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
4312
  if (!SWIG_IsOK(res1)) {
 
4313
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_DontShowLabel" "', expected argument " "1"" of type '" "wxAnyButton const *""'"); 
 
4314
  }
 
4315
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
4316
  {
 
4317
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4318
    result = (bool)((wxAnyButton const *)arg1)->DontShowLabel();
 
4319
    wxPyEndAllowThreads(__tstate);
 
4320
    if (PyErr_Occurred()) SWIG_fail;
 
4321
  }
 
4322
  {
 
4323
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
4324
  }
 
4325
  return resultobj;
 
4326
fail:
 
4327
  return NULL;
 
4328
}
 
4329
 
 
4330
 
 
4331
SWIGINTERN PyObject *_wrap_AnyButton_ShowsLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4332
  PyObject *resultobj = 0;
 
4333
  wxAnyButton *arg1 = (wxAnyButton *) 0 ;
 
4334
  bool result;
 
4335
  void *argp1 = 0 ;
 
4336
  int res1 = 0 ;
 
4337
  PyObject *swig_obj[1] ;
 
4338
  
 
4339
  if (!args) SWIG_fail;
 
4340
  swig_obj[0] = args;
 
4341
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAnyButton, 0 |  0 );
 
4342
  if (!SWIG_IsOK(res1)) {
 
4343
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyButton_ShowsLabel" "', expected argument " "1"" of type '" "wxAnyButton const *""'"); 
 
4344
  }
 
4345
  arg1 = reinterpret_cast< wxAnyButton * >(argp1);
 
4346
  {
 
4347
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4348
    result = (bool)((wxAnyButton const *)arg1)->ShowsLabel();
 
4349
    wxPyEndAllowThreads(__tstate);
 
4350
    if (PyErr_Occurred()) SWIG_fail;
 
4351
  }
 
4352
  {
 
4353
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
4354
  }
 
4355
  return resultobj;
 
4356
fail:
 
4357
  return NULL;
 
4358
}
 
4359
 
 
4360
 
 
4361
SWIGINTERN PyObject *AnyButton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4362
  PyObject *obj;
 
4363
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
4364
  SWIG_TypeNewClientData(SWIGTYPE_p_wxAnyButton, SWIG_NewClientData(obj));
 
4365
  return SWIG_Py_Void();
 
4366
}
 
4367
 
 
4368
SWIGINTERN PyObject *_wrap_new_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4369
  PyObject *resultobj = 0;
 
4370
  wxWindow *arg1 = (wxWindow *) 0 ;
 
4371
  int arg2 = (int) -1 ;
 
4372
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
4373
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
4374
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
4375
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
4376
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
4377
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
4378
  long arg6 = (long) 0 ;
 
4379
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
4380
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
4381
  wxString const &arg8_defvalue = wxPyButtonNameStr ;
 
4382
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
4383
  wxButton *result = 0 ;
 
4384
  void *argp1 = 0 ;
 
4385
  int res1 = 0 ;
 
4386
  int val2 ;
 
4387
  int ecode2 = 0 ;
 
4388
  bool temp3 = false ;
 
4389
  wxPoint temp4 ;
 
4390
  wxSize temp5 ;
 
4391
  long val6 ;
 
4392
  int ecode6 = 0 ;
 
4393
  void *argp7 = 0 ;
 
4394
  int res7 = 0 ;
 
4395
  bool temp8 = false ;
 
4396
  PyObject * obj0 = 0 ;
 
4397
  PyObject * obj1 = 0 ;
 
4398
  PyObject * obj2 = 0 ;
 
4399
  PyObject * obj3 = 0 ;
 
4400
  PyObject * obj4 = 0 ;
 
4401
  PyObject * obj5 = 0 ;
 
4402
  PyObject * obj6 = 0 ;
 
4403
  PyObject * obj7 = 0 ;
 
4404
  char *  kwnames[] = {
 
4405
    (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
4406
  };
 
4407
  
 
4408
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_Button",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
4409
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
4410
  if (!SWIG_IsOK(res1)) {
 
4411
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Button" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
4412
  }
 
4413
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
4414
  if (obj1) {
 
4415
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
4416
    if (!SWIG_IsOK(ecode2)) {
 
4417
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Button" "', expected argument " "2"" of type '" "int""'");
 
4418
    } 
 
4419
    arg2 = static_cast< int >(val2);
 
4420
  }
 
4421
  if (obj2) {
 
4422
    {
 
4423
      arg3 = wxString_in_helper(obj2);
 
4424
      if (arg3 == NULL) SWIG_fail;
 
4425
      temp3 = true;
 
4426
    }
 
4427
  }
 
4428
  if (obj3) {
 
4429
    {
 
4430
      arg4 = &temp4;
 
4431
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
4432
    }
 
4433
  }
 
4434
  if (obj4) {
 
4435
    {
 
4436
      arg5 = &temp5;
 
4437
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
4438
    }
 
4439
  }
 
4440
  if (obj5) {
 
4441
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
4442
    if (!SWIG_IsOK(ecode6)) {
 
4443
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Button" "', expected argument " "6"" of type '" "long""'");
 
4444
    } 
 
4445
    arg6 = static_cast< long >(val6);
 
4446
  }
 
4447
  if (obj6) {
 
4448
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
4449
    if (!SWIG_IsOK(res7)) {
 
4450
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Button" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
4451
    }
 
4452
    if (!argp7) {
 
4453
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Button" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
4454
    }
 
4455
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
4456
  }
 
4457
  if (obj7) {
 
4458
    {
 
4459
      arg8 = wxString_in_helper(obj7);
 
4460
      if (arg8 == NULL) SWIG_fail;
 
4461
      temp8 = true;
 
4462
    }
 
4463
  }
 
4464
  {
 
4465
    if (!wxPyCheckForApp()) SWIG_fail;
 
4466
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4467
    result = (wxButton *)new wxButton(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
4468
    wxPyEndAllowThreads(__tstate);
 
4469
    if (PyErr_Occurred()) SWIG_fail;
 
4470
  }
 
4471
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxButton, SWIG_POINTER_NEW |  0 );
 
4472
  {
 
4473
    if (temp3)
 
4474
    delete arg3;
 
4475
  }
 
4476
  {
 
4477
    if (temp8)
 
4478
    delete arg8;
 
4479
  }
 
4480
  return resultobj;
 
4481
fail:
 
4482
  {
 
4483
    if (temp3)
 
4484
    delete arg3;
 
4485
  }
 
4486
  {
 
4487
    if (temp8)
 
4488
    delete arg8;
 
4489
  }
 
4490
  return NULL;
 
4491
}
 
4492
 
 
4493
 
 
4494
SWIGINTERN PyObject *_wrap_new_PreButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4495
  PyObject *resultobj = 0;
 
4496
  wxButton *result = 0 ;
 
4497
  
 
4498
  if (!SWIG_Python_UnpackTuple(args,"new_PreButton",0,0,0)) SWIG_fail;
 
4499
  {
 
4500
    if (!wxPyCheckForApp()) SWIG_fail;
 
4501
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4502
    result = (wxButton *)new wxButton();
 
4503
    wxPyEndAllowThreads(__tstate);
 
4504
    if (PyErr_Occurred()) SWIG_fail;
 
4505
  }
 
4506
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxButton, SWIG_POINTER_OWN |  0 );
 
4507
  return resultobj;
 
4508
fail:
 
4509
  return NULL;
 
4510
}
 
4511
 
 
4512
 
 
4513
SWIGINTERN PyObject *_wrap_Button_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4514
  PyObject *resultobj = 0;
 
4515
  wxButton *arg1 = (wxButton *) 0 ;
 
4516
  wxWindow *arg2 = (wxWindow *) 0 ;
 
4517
  int arg3 = (int) -1 ;
 
4518
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
4519
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
4520
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
4521
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
4522
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
4523
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
4524
  long arg7 = (long) 0 ;
 
4525
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
4526
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
4527
  wxString const &arg9_defvalue = wxPyButtonNameStr ;
 
4528
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
4529
  bool result;
 
4530
  void *argp1 = 0 ;
 
4531
  int res1 = 0 ;
 
4532
  void *argp2 = 0 ;
 
4533
  int res2 = 0 ;
 
4534
  int val3 ;
 
4535
  int ecode3 = 0 ;
 
4536
  bool temp4 = false ;
 
4537
  wxPoint temp5 ;
 
4538
  wxSize temp6 ;
 
4539
  long val7 ;
 
4540
  int ecode7 = 0 ;
 
4541
  void *argp8 = 0 ;
 
4542
  int res8 = 0 ;
 
4543
  bool temp9 = false ;
 
4544
  PyObject * obj0 = 0 ;
 
4545
  PyObject * obj1 = 0 ;
 
4546
  PyObject * obj2 = 0 ;
 
4547
  PyObject * obj3 = 0 ;
 
4548
  PyObject * obj4 = 0 ;
 
4549
  PyObject * obj5 = 0 ;
 
4550
  PyObject * obj6 = 0 ;
 
4551
  PyObject * obj7 = 0 ;
 
4552
  PyObject * obj8 = 0 ;
 
4553
  char *  kwnames[] = {
 
4554
    (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
4555
  };
 
4556
  
 
4557
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:Button_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
4558
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxButton, 0 |  0 );
 
4559
  if (!SWIG_IsOK(res1)) {
 
4560
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Button_Create" "', expected argument " "1"" of type '" "wxButton *""'"); 
 
4561
  }
 
4562
  arg1 = reinterpret_cast< wxButton * >(argp1);
 
4563
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
4564
  if (!SWIG_IsOK(res2)) {
 
4565
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Button_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
4566
  }
 
4567
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
4568
  if (obj2) {
 
4569
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
4570
    if (!SWIG_IsOK(ecode3)) {
 
4571
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Button_Create" "', expected argument " "3"" of type '" "int""'");
 
4572
    } 
 
4573
    arg3 = static_cast< int >(val3);
 
4574
  }
 
4575
  if (obj3) {
 
4576
    {
 
4577
      arg4 = wxString_in_helper(obj3);
 
4578
      if (arg4 == NULL) SWIG_fail;
 
4579
      temp4 = true;
 
4580
    }
 
4581
  }
 
4582
  if (obj4) {
 
4583
    {
 
4584
      arg5 = &temp5;
 
4585
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
4586
    }
 
4587
  }
 
4588
  if (obj5) {
 
4589
    {
 
4590
      arg6 = &temp6;
 
4591
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
4592
    }
 
4593
  }
 
4594
  if (obj6) {
 
4595
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
4596
    if (!SWIG_IsOK(ecode7)) {
 
4597
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Button_Create" "', expected argument " "7"" of type '" "long""'");
 
4598
    } 
 
4599
    arg7 = static_cast< long >(val7);
 
4600
  }
 
4601
  if (obj7) {
 
4602
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
4603
    if (!SWIG_IsOK(res8)) {
 
4604
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Button_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
4605
    }
 
4606
    if (!argp8) {
 
4607
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Button_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
4608
    }
 
4609
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
4610
  }
 
4611
  if (obj8) {
 
4612
    {
 
4613
      arg9 = wxString_in_helper(obj8);
 
4614
      if (arg9 == NULL) SWIG_fail;
 
4615
      temp9 = true;
 
4616
    }
 
4617
  }
 
4618
  {
 
4619
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4620
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
4621
    wxPyEndAllowThreads(__tstate);
 
4622
    if (PyErr_Occurred()) SWIG_fail;
 
4623
  }
 
4624
  {
 
4625
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
4626
  }
 
4627
  {
 
4628
    if (temp4)
 
4629
    delete arg4;
 
4630
  }
 
4631
  {
 
4632
    if (temp9)
 
4633
    delete arg9;
 
4634
  }
 
4635
  return resultobj;
 
4636
fail:
 
4637
  {
 
4638
    if (temp4)
 
4639
    delete arg4;
 
4640
  }
 
4641
  {
 
4642
    if (temp9)
 
4643
    delete arg9;
 
4644
  }
 
4645
  return NULL;
 
4646
}
 
4647
 
 
4648
 
 
4649
SWIGINTERN PyObject *_wrap_Button_SetAuthNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4650
  PyObject *resultobj = 0;
 
4651
  wxButton *arg1 = (wxButton *) 0 ;
 
4652
  bool arg2 = (bool) true ;
 
4653
  void *argp1 = 0 ;
 
4654
  int res1 = 0 ;
 
4655
  bool val2 ;
 
4656
  int ecode2 = 0 ;
 
4657
  PyObject * obj0 = 0 ;
 
4658
  PyObject * obj1 = 0 ;
 
4659
  char *  kwnames[] = {
 
4660
    (char *) "self",(char *) "show", NULL 
 
4661
  };
 
4662
  
 
4663
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Button_SetAuthNeeded",kwnames,&obj0,&obj1)) SWIG_fail;
 
4664
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxButton, 0 |  0 );
 
4665
  if (!SWIG_IsOK(res1)) {
 
4666
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Button_SetAuthNeeded" "', expected argument " "1"" of type '" "wxButton *""'"); 
 
4667
  }
 
4668
  arg1 = reinterpret_cast< wxButton * >(argp1);
 
4669
  if (obj1) {
 
4670
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
4671
    if (!SWIG_IsOK(ecode2)) {
 
4672
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Button_SetAuthNeeded" "', expected argument " "2"" of type '" "bool""'");
 
4673
    } 
 
4674
    arg2 = static_cast< bool >(val2);
 
4675
  }
 
4676
  {
 
4677
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4678
    (arg1)->SetAuthNeeded(arg2);
 
4679
    wxPyEndAllowThreads(__tstate);
 
4680
    if (PyErr_Occurred()) SWIG_fail;
 
4681
  }
 
4682
  resultobj = SWIG_Py_Void();
 
4683
  return resultobj;
 
4684
fail:
 
4685
  return NULL;
 
4686
}
 
4687
 
 
4688
 
 
4689
SWIGINTERN PyObject *_wrap_Button_GetAuthNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4690
  PyObject *resultobj = 0;
 
4691
  wxButton *arg1 = (wxButton *) 0 ;
 
4692
  bool result;
 
4693
  void *argp1 = 0 ;
 
4694
  int res1 = 0 ;
 
4695
  PyObject *swig_obj[1] ;
 
4696
  
 
4697
  if (!args) SWIG_fail;
 
4698
  swig_obj[0] = args;
 
4699
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxButton, 0 |  0 );
 
4700
  if (!SWIG_IsOK(res1)) {
 
4701
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Button_GetAuthNeeded" "', expected argument " "1"" of type '" "wxButton const *""'"); 
 
4702
  }
 
4703
  arg1 = reinterpret_cast< wxButton * >(argp1);
 
4704
  {
 
4705
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4706
    result = (bool)((wxButton const *)arg1)->GetAuthNeeded();
 
4707
    wxPyEndAllowThreads(__tstate);
 
4708
    if (PyErr_Occurred()) SWIG_fail;
 
4709
  }
 
4710
  {
 
4711
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
4712
  }
 
4713
  return resultobj;
 
4714
fail:
 
4715
  return NULL;
 
4716
}
 
4717
 
 
4718
 
 
4719
SWIGINTERN PyObject *_wrap_Button_SetDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4720
  PyObject *resultobj = 0;
 
4721
  wxButton *arg1 = (wxButton *) 0 ;
 
4722
  wxWindow *result = 0 ;
 
4723
  void *argp1 = 0 ;
 
4724
  int res1 = 0 ;
 
4725
  PyObject *swig_obj[1] ;
 
4726
  
 
4727
  if (!args) SWIG_fail;
 
4728
  swig_obj[0] = args;
 
4729
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxButton, 0 |  0 );
 
4730
  if (!SWIG_IsOK(res1)) {
 
4731
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Button_SetDefault" "', expected argument " "1"" of type '" "wxButton *""'"); 
 
4732
  }
 
4733
  arg1 = reinterpret_cast< wxButton * >(argp1);
 
4734
  {
 
4735
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4736
    result = (wxWindow *)(arg1)->SetDefault();
 
4737
    wxPyEndAllowThreads(__tstate);
 
4738
    if (PyErr_Occurred()) SWIG_fail;
 
4739
  }
 
4740
  {
 
4741
    resultobj = wxPyMake_wxObject(result, 0); 
 
4742
  }
 
4743
  return resultobj;
 
4744
fail:
 
4745
  return NULL;
 
4746
}
 
4747
 
 
4748
 
 
4749
SWIGINTERN PyObject *_wrap_Button_GetDefaultSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4750
  PyObject *resultobj = 0;
 
4751
  wxSize result;
 
4752
  
 
4753
  if (!SWIG_Python_UnpackTuple(args,"Button_GetDefaultSize",0,0,0)) SWIG_fail;
 
4754
  {
 
4755
    if (!wxPyCheckForApp()) SWIG_fail;
 
4756
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4757
    result = wxButton::GetDefaultSize();
 
4758
    wxPyEndAllowThreads(__tstate);
 
4759
    if (PyErr_Occurred()) SWIG_fail;
 
4760
  }
 
4761
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
4762
  return resultobj;
 
4763
fail:
 
4764
  return NULL;
 
4765
}
 
4766
 
 
4767
 
 
4768
SWIGINTERN PyObject *_wrap_Button_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4769
  PyObject *resultobj = 0;
 
4770
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
4771
  SwigValueWrapper<wxVisualAttributes > result;
 
4772
  int val1 ;
 
4773
  int ecode1 = 0 ;
 
4774
  PyObject * obj0 = 0 ;
 
4775
  char *  kwnames[] = {
 
4776
    (char *) "variant", NULL 
 
4777
  };
 
4778
  
 
4779
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Button_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
4780
  if (obj0) {
 
4781
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
4782
    if (!SWIG_IsOK(ecode1)) {
 
4783
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Button_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
4784
    } 
 
4785
    arg1 = static_cast< wxWindowVariant >(val1);
 
4786
  }
 
4787
  {
 
4788
    if (!wxPyCheckForApp()) SWIG_fail;
 
4789
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4790
    result = wxButton::GetClassDefaultAttributes(arg1);
 
4791
    wxPyEndAllowThreads(__tstate);
 
4792
    if (PyErr_Occurred()) SWIG_fail;
 
4793
  }
 
4794
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
4795
  return resultobj;
 
4796
fail:
 
4797
  return NULL;
 
4798
}
 
4799
 
 
4800
 
 
4801
SWIGINTERN PyObject *Button_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4802
  PyObject *obj;
 
4803
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
4804
  SWIG_TypeNewClientData(SWIGTYPE_p_wxButton, SWIG_NewClientData(obj));
 
4805
  return SWIG_Py_Void();
 
4806
}
 
4807
 
 
4808
SWIGINTERN PyObject *Button_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4809
  return SWIG_Python_InitShadowInstance(args);
 
4810
}
 
4811
 
 
4812
SWIGINTERN PyObject *_wrap_new_BitmapButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4813
  PyObject *resultobj = 0;
 
4814
  wxWindow *arg1 = (wxWindow *) 0 ;
 
4815
  int arg2 = (int) -1 ;
 
4816
  wxBitmap const &arg3_defvalue = wxNullBitmap ;
 
4817
  wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
 
4818
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
4819
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
4820
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
4821
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
4822
  long arg6 = (long) wxBU_AUTODRAW ;
 
4823
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
4824
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
4825
  wxString const &arg8_defvalue = wxPyButtonNameStr ;
 
4826
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
4827
  wxBitmapButton *result = 0 ;
 
4828
  void *argp1 = 0 ;
 
4829
  int res1 = 0 ;
 
4830
  int val2 ;
 
4831
  int ecode2 = 0 ;
 
4832
  void *argp3 = 0 ;
 
4833
  int res3 = 0 ;
 
4834
  wxPoint temp4 ;
 
4835
  wxSize temp5 ;
 
4836
  long val6 ;
 
4837
  int ecode6 = 0 ;
 
4838
  void *argp7 = 0 ;
 
4839
  int res7 = 0 ;
 
4840
  bool temp8 = false ;
 
4841
  PyObject * obj0 = 0 ;
 
4842
  PyObject * obj1 = 0 ;
 
4843
  PyObject * obj2 = 0 ;
 
4844
  PyObject * obj3 = 0 ;
 
4845
  PyObject * obj4 = 0 ;
 
4846
  PyObject * obj5 = 0 ;
 
4847
  PyObject * obj6 = 0 ;
 
4848
  PyObject * obj7 = 0 ;
 
4849
  char *  kwnames[] = {
 
4850
    (char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
4851
  };
 
4852
  
 
4853
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_BitmapButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
4854
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
4855
  if (!SWIG_IsOK(res1)) {
 
4856
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapButton" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
4857
  }
 
4858
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
4859
  if (obj1) {
 
4860
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
4861
    if (!SWIG_IsOK(ecode2)) {
 
4862
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapButton" "', expected argument " "2"" of type '" "int""'");
 
4863
    } 
 
4864
    arg2 = static_cast< int >(val2);
 
4865
  }
 
4866
  if (obj2) {
 
4867
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap,  0  | 0);
 
4868
    if (!SWIG_IsOK(res3)) {
 
4869
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BitmapButton" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
4870
    }
 
4871
    if (!argp3) {
 
4872
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapButton" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
4873
    }
 
4874
    arg3 = reinterpret_cast< wxBitmap * >(argp3);
 
4875
  }
 
4876
  if (obj3) {
 
4877
    {
 
4878
      arg4 = &temp4;
 
4879
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
4880
    }
 
4881
  }
 
4882
  if (obj4) {
 
4883
    {
 
4884
      arg5 = &temp5;
 
4885
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
4886
    }
 
4887
  }
 
4888
  if (obj5) {
 
4889
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
4890
    if (!SWIG_IsOK(ecode6)) {
 
4891
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_BitmapButton" "', expected argument " "6"" of type '" "long""'");
 
4892
    } 
 
4893
    arg6 = static_cast< long >(val6);
 
4894
  }
 
4895
  if (obj6) {
 
4896
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
4897
    if (!SWIG_IsOK(res7)) {
 
4898
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_BitmapButton" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
4899
    }
 
4900
    if (!argp7) {
 
4901
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapButton" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
4902
    }
 
4903
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
4904
  }
 
4905
  if (obj7) {
 
4906
    {
 
4907
      arg8 = wxString_in_helper(obj7);
 
4908
      if (arg8 == NULL) SWIG_fail;
 
4909
      temp8 = true;
 
4910
    }
 
4911
  }
 
4912
  {
 
4913
    if (!wxPyCheckForApp()) SWIG_fail;
 
4914
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4915
    result = (wxBitmapButton *)new wxBitmapButton(arg1,arg2,(wxBitmap const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
4916
    wxPyEndAllowThreads(__tstate);
 
4917
    if (PyErr_Occurred()) SWIG_fail;
 
4918
  }
 
4919
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_NEW |  0 );
 
4920
  {
 
4921
    if (temp8)
 
4922
    delete arg8;
 
4923
  }
 
4924
  return resultobj;
 
4925
fail:
 
4926
  {
 
4927
    if (temp8)
 
4928
    delete arg8;
 
4929
  }
 
4930
  return NULL;
 
4931
}
 
4932
 
 
4933
 
 
4934
SWIGINTERN PyObject *_wrap_new_PreBitmapButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
4935
  PyObject *resultobj = 0;
 
4936
  wxBitmapButton *result = 0 ;
 
4937
  
 
4938
  if (!SWIG_Python_UnpackTuple(args,"new_PreBitmapButton",0,0,0)) SWIG_fail;
 
4939
  {
 
4940
    if (!wxPyCheckForApp()) SWIG_fail;
 
4941
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
4942
    result = (wxBitmapButton *)new wxBitmapButton();
 
4943
    wxPyEndAllowThreads(__tstate);
 
4944
    if (PyErr_Occurred()) SWIG_fail;
 
4945
  }
 
4946
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapButton, SWIG_POINTER_OWN |  0 );
 
4947
  return resultobj;
 
4948
fail:
 
4949
  return NULL;
 
4950
}
 
4951
 
 
4952
 
 
4953
SWIGINTERN PyObject *_wrap_BitmapButton_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
4954
  PyObject *resultobj = 0;
 
4955
  wxBitmapButton *arg1 = (wxBitmapButton *) 0 ;
 
4956
  wxWindow *arg2 = (wxWindow *) 0 ;
 
4957
  int arg3 = (int) -1 ;
 
4958
  wxBitmap const &arg4_defvalue = wxNullBitmap ;
 
4959
  wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
 
4960
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
4961
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
4962
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
4963
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
4964
  long arg7 = (long) wxBU_AUTODRAW ;
 
4965
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
4966
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
4967
  wxString const &arg9_defvalue = wxPyButtonNameStr ;
 
4968
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
4969
  bool result;
 
4970
  void *argp1 = 0 ;
 
4971
  int res1 = 0 ;
 
4972
  void *argp2 = 0 ;
 
4973
  int res2 = 0 ;
 
4974
  int val3 ;
 
4975
  int ecode3 = 0 ;
 
4976
  void *argp4 = 0 ;
 
4977
  int res4 = 0 ;
 
4978
  wxPoint temp5 ;
 
4979
  wxSize temp6 ;
 
4980
  long val7 ;
 
4981
  int ecode7 = 0 ;
 
4982
  void *argp8 = 0 ;
 
4983
  int res8 = 0 ;
 
4984
  bool temp9 = false ;
 
4985
  PyObject * obj0 = 0 ;
 
4986
  PyObject * obj1 = 0 ;
 
4987
  PyObject * obj2 = 0 ;
 
4988
  PyObject * obj3 = 0 ;
 
4989
  PyObject * obj4 = 0 ;
 
4990
  PyObject * obj5 = 0 ;
 
4991
  PyObject * obj6 = 0 ;
 
4992
  PyObject * obj7 = 0 ;
 
4993
  PyObject * obj8 = 0 ;
 
4994
  char *  kwnames[] = {
 
4995
    (char *) "self",(char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
4996
  };
 
4997
  
 
4998
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:BitmapButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
4999
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapButton, 0 |  0 );
 
5000
  if (!SWIG_IsOK(res1)) {
 
5001
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapButton_Create" "', expected argument " "1"" of type '" "wxBitmapButton *""'"); 
 
5002
  }
 
5003
  arg1 = reinterpret_cast< wxBitmapButton * >(argp1);
 
5004
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
5005
  if (!SWIG_IsOK(res2)) {
 
5006
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapButton_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
5007
  }
 
5008
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
5009
  if (obj2) {
 
5010
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
5011
    if (!SWIG_IsOK(ecode3)) {
 
5012
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BitmapButton_Create" "', expected argument " "3"" of type '" "int""'");
 
5013
    } 
 
5014
    arg3 = static_cast< int >(val3);
 
5015
  }
 
5016
  if (obj3) {
 
5017
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap,  0  | 0);
 
5018
    if (!SWIG_IsOK(res4)) {
 
5019
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BitmapButton_Create" "', expected argument " "4"" of type '" "wxBitmap const &""'"); 
 
5020
    }
 
5021
    if (!argp4) {
 
5022
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapButton_Create" "', expected argument " "4"" of type '" "wxBitmap const &""'"); 
 
5023
    }
 
5024
    arg4 = reinterpret_cast< wxBitmap * >(argp4);
 
5025
  }
 
5026
  if (obj4) {
 
5027
    {
 
5028
      arg5 = &temp5;
 
5029
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
5030
    }
 
5031
  }
 
5032
  if (obj5) {
 
5033
    {
 
5034
      arg6 = &temp6;
 
5035
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
5036
    }
 
5037
  }
 
5038
  if (obj6) {
 
5039
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
5040
    if (!SWIG_IsOK(ecode7)) {
 
5041
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BitmapButton_Create" "', expected argument " "7"" of type '" "long""'");
 
5042
    } 
 
5043
    arg7 = static_cast< long >(val7);
 
5044
  }
 
5045
  if (obj7) {
 
5046
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
5047
    if (!SWIG_IsOK(res8)) {
 
5048
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "BitmapButton_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
5049
    }
 
5050
    if (!argp8) {
 
5051
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapButton_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
5052
    }
 
5053
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
5054
  }
 
5055
  if (obj8) {
 
5056
    {
 
5057
      arg9 = wxString_in_helper(obj8);
 
5058
      if (arg9 == NULL) SWIG_fail;
 
5059
      temp9 = true;
 
5060
    }
 
5061
  }
 
5062
  {
 
5063
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5064
    result = (bool)(arg1)->Create(arg2,arg3,(wxBitmap const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
5065
    wxPyEndAllowThreads(__tstate);
 
5066
    if (PyErr_Occurred()) SWIG_fail;
 
5067
  }
 
5068
  {
 
5069
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
5070
  }
 
5071
  {
 
5072
    if (temp9)
 
5073
    delete arg9;
 
5074
  }
 
5075
  return resultobj;
 
5076
fail:
 
5077
  {
 
5078
    if (temp9)
 
5079
    delete arg9;
 
5080
  }
 
5081
  return NULL;
 
5082
}
 
5083
 
 
5084
 
 
5085
SWIGINTERN PyObject *BitmapButton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5086
  PyObject *obj;
 
5087
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
5088
  SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapButton, SWIG_NewClientData(obj));
 
5089
  return SWIG_Py_Void();
 
5090
}
 
5091
 
 
5092
SWIGINTERN PyObject *BitmapButton_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5093
  return SWIG_Python_InitShadowInstance(args);
 
5094
}
 
5095
 
 
5096
SWIGINTERN int CheckBoxNameStr_set(PyObject *) {
 
5097
  SWIG_Error(SWIG_AttributeError,"Variable CheckBoxNameStr is read-only.");
 
5098
  return 1;
 
5099
}
 
5100
 
 
5101
 
 
5102
SWIGINTERN PyObject *CheckBoxNameStr_get(void) {
 
5103
  PyObject *pyobj = 0;
 
5104
  
 
5105
  {
 
5106
#if wxUSE_UNICODE
 
5107
    pyobj = PyUnicode_FromWideChar((&wxPyCheckBoxNameStr)->c_str(), (&wxPyCheckBoxNameStr)->Len());
 
5108
#else
 
5109
    pyobj = PyString_FromStringAndSize((&wxPyCheckBoxNameStr)->c_str(), (&wxPyCheckBoxNameStr)->Len());
 
5110
#endif
 
5111
  }
 
5112
  return pyobj;
 
5113
}
 
5114
 
 
5115
 
 
5116
SWIGINTERN PyObject *_wrap_new_CheckBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
5117
  PyObject *resultobj = 0;
 
5118
  wxWindow *arg1 = (wxWindow *) 0 ;
 
5119
  int arg2 = (int) -1 ;
 
5120
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
5121
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
5122
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
5123
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
5124
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
5125
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
5126
  long arg6 = (long) 0 ;
 
5127
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
5128
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
5129
  wxString const &arg8_defvalue = wxPyCheckBoxNameStr ;
 
5130
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
5131
  wxCheckBox *result = 0 ;
 
5132
  void *argp1 = 0 ;
 
5133
  int res1 = 0 ;
 
5134
  int val2 ;
 
5135
  int ecode2 = 0 ;
 
5136
  bool temp3 = false ;
 
5137
  wxPoint temp4 ;
 
5138
  wxSize temp5 ;
 
5139
  long val6 ;
 
5140
  int ecode6 = 0 ;
 
5141
  void *argp7 = 0 ;
 
5142
  int res7 = 0 ;
 
5143
  bool temp8 = false ;
 
5144
  PyObject * obj0 = 0 ;
 
5145
  PyObject * obj1 = 0 ;
 
5146
  PyObject * obj2 = 0 ;
 
5147
  PyObject * obj3 = 0 ;
 
5148
  PyObject * obj4 = 0 ;
 
5149
  PyObject * obj5 = 0 ;
 
5150
  PyObject * obj6 = 0 ;
 
5151
  PyObject * obj7 = 0 ;
 
5152
  char *  kwnames[] = {
 
5153
    (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
5154
  };
 
5155
  
 
5156
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_CheckBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
5157
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
5158
  if (!SWIG_IsOK(res1)) {
 
5159
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CheckBox" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
5160
  }
 
5161
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
5162
  if (obj1) {
 
5163
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
5164
    if (!SWIG_IsOK(ecode2)) {
 
5165
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CheckBox" "', expected argument " "2"" of type '" "int""'");
 
5166
    } 
 
5167
    arg2 = static_cast< int >(val2);
 
5168
  }
 
5169
  if (obj2) {
 
5170
    {
 
5171
      arg3 = wxString_in_helper(obj2);
 
5172
      if (arg3 == NULL) SWIG_fail;
 
5173
      temp3 = true;
 
5174
    }
 
5175
  }
 
5176
  if (obj3) {
 
5177
    {
 
5178
      arg4 = &temp4;
 
5179
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
5180
    }
 
5181
  }
 
5182
  if (obj4) {
 
5183
    {
 
5184
      arg5 = &temp5;
 
5185
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
5186
    }
 
5187
  }
 
5188
  if (obj5) {
 
5189
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
5190
    if (!SWIG_IsOK(ecode6)) {
 
5191
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CheckBox" "', expected argument " "6"" of type '" "long""'");
 
5192
    } 
 
5193
    arg6 = static_cast< long >(val6);
 
5194
  }
 
5195
  if (obj6) {
 
5196
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
5197
    if (!SWIG_IsOK(res7)) {
 
5198
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CheckBox" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
5199
    }
 
5200
    if (!argp7) {
 
5201
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CheckBox" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
5202
    }
 
5203
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
5204
  }
 
5205
  if (obj7) {
 
5206
    {
 
5207
      arg8 = wxString_in_helper(obj7);
 
5208
      if (arg8 == NULL) SWIG_fail;
 
5209
      temp8 = true;
 
5210
    }
 
5211
  }
 
5212
  {
 
5213
    if (!wxPyCheckForApp()) SWIG_fail;
 
5214
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5215
    result = (wxCheckBox *)new wxCheckBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
5216
    wxPyEndAllowThreads(__tstate);
 
5217
    if (PyErr_Occurred()) SWIG_fail;
 
5218
  }
 
5219
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCheckBox, SWIG_POINTER_NEW |  0 );
 
5220
  {
 
5221
    if (temp3)
 
5222
    delete arg3;
 
5223
  }
 
5224
  {
 
5225
    if (temp8)
 
5226
    delete arg8;
 
5227
  }
 
5228
  return resultobj;
 
5229
fail:
 
5230
  {
 
5231
    if (temp3)
 
5232
    delete arg3;
 
5233
  }
 
5234
  {
 
5235
    if (temp8)
 
5236
    delete arg8;
 
5237
  }
 
5238
  return NULL;
 
5239
}
 
5240
 
 
5241
 
 
5242
SWIGINTERN PyObject *_wrap_new_PreCheckBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5243
  PyObject *resultobj = 0;
 
5244
  wxCheckBox *result = 0 ;
 
5245
  
 
5246
  if (!SWIG_Python_UnpackTuple(args,"new_PreCheckBox",0,0,0)) SWIG_fail;
 
5247
  {
 
5248
    if (!wxPyCheckForApp()) SWIG_fail;
 
5249
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5250
    result = (wxCheckBox *)new wxCheckBox();
 
5251
    wxPyEndAllowThreads(__tstate);
 
5252
    if (PyErr_Occurred()) SWIG_fail;
 
5253
  }
 
5254
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCheckBox, SWIG_POINTER_OWN |  0 );
 
5255
  return resultobj;
 
5256
fail:
 
5257
  return NULL;
 
5258
}
 
5259
 
 
5260
 
 
5261
SWIGINTERN PyObject *_wrap_CheckBox_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
5262
  PyObject *resultobj = 0;
 
5263
  wxCheckBox *arg1 = (wxCheckBox *) 0 ;
 
5264
  wxWindow *arg2 = (wxWindow *) 0 ;
 
5265
  int arg3 = (int) -1 ;
 
5266
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
5267
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
5268
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
5269
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
5270
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
5271
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
5272
  long arg7 = (long) 0 ;
 
5273
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
5274
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
5275
  wxString const &arg9_defvalue = wxPyCheckBoxNameStr ;
 
5276
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
5277
  bool result;
 
5278
  void *argp1 = 0 ;
 
5279
  int res1 = 0 ;
 
5280
  void *argp2 = 0 ;
 
5281
  int res2 = 0 ;
 
5282
  int val3 ;
 
5283
  int ecode3 = 0 ;
 
5284
  bool temp4 = false ;
 
5285
  wxPoint temp5 ;
 
5286
  wxSize temp6 ;
 
5287
  long val7 ;
 
5288
  int ecode7 = 0 ;
 
5289
  void *argp8 = 0 ;
 
5290
  int res8 = 0 ;
 
5291
  bool temp9 = false ;
 
5292
  PyObject * obj0 = 0 ;
 
5293
  PyObject * obj1 = 0 ;
 
5294
  PyObject * obj2 = 0 ;
 
5295
  PyObject * obj3 = 0 ;
 
5296
  PyObject * obj4 = 0 ;
 
5297
  PyObject * obj5 = 0 ;
 
5298
  PyObject * obj6 = 0 ;
 
5299
  PyObject * obj7 = 0 ;
 
5300
  PyObject * obj8 = 0 ;
 
5301
  char *  kwnames[] = {
 
5302
    (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
5303
  };
 
5304
  
 
5305
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:CheckBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
5306
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCheckBox, 0 |  0 );
 
5307
  if (!SWIG_IsOK(res1)) {
 
5308
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckBox_Create" "', expected argument " "1"" of type '" "wxCheckBox *""'"); 
 
5309
  }
 
5310
  arg1 = reinterpret_cast< wxCheckBox * >(argp1);
 
5311
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
5312
  if (!SWIG_IsOK(res2)) {
 
5313
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CheckBox_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
5314
  }
 
5315
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
5316
  if (obj2) {
 
5317
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
5318
    if (!SWIG_IsOK(ecode3)) {
 
5319
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CheckBox_Create" "', expected argument " "3"" of type '" "int""'");
 
5320
    } 
 
5321
    arg3 = static_cast< int >(val3);
 
5322
  }
 
5323
  if (obj3) {
 
5324
    {
 
5325
      arg4 = wxString_in_helper(obj3);
 
5326
      if (arg4 == NULL) SWIG_fail;
 
5327
      temp4 = true;
 
5328
    }
 
5329
  }
 
5330
  if (obj4) {
 
5331
    {
 
5332
      arg5 = &temp5;
 
5333
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
5334
    }
 
5335
  }
 
5336
  if (obj5) {
 
5337
    {
 
5338
      arg6 = &temp6;
 
5339
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
5340
    }
 
5341
  }
 
5342
  if (obj6) {
 
5343
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
5344
    if (!SWIG_IsOK(ecode7)) {
 
5345
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CheckBox_Create" "', expected argument " "7"" of type '" "long""'");
 
5346
    } 
 
5347
    arg7 = static_cast< long >(val7);
 
5348
  }
 
5349
  if (obj7) {
 
5350
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
5351
    if (!SWIG_IsOK(res8)) {
 
5352
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CheckBox_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
5353
    }
 
5354
    if (!argp8) {
 
5355
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CheckBox_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
5356
    }
 
5357
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
5358
  }
 
5359
  if (obj8) {
 
5360
    {
 
5361
      arg9 = wxString_in_helper(obj8);
 
5362
      if (arg9 == NULL) SWIG_fail;
 
5363
      temp9 = true;
 
5364
    }
 
5365
  }
 
5366
  {
 
5367
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5368
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
5369
    wxPyEndAllowThreads(__tstate);
 
5370
    if (PyErr_Occurred()) SWIG_fail;
 
5371
  }
 
5372
  {
 
5373
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
5374
  }
 
5375
  {
 
5376
    if (temp4)
 
5377
    delete arg4;
 
5378
  }
 
5379
  {
 
5380
    if (temp9)
 
5381
    delete arg9;
 
5382
  }
 
5383
  return resultobj;
 
5384
fail:
 
5385
  {
 
5386
    if (temp4)
 
5387
    delete arg4;
 
5388
  }
 
5389
  {
 
5390
    if (temp9)
 
5391
    delete arg9;
 
5392
  }
 
5393
  return NULL;
 
5394
}
 
5395
 
 
5396
 
 
5397
SWIGINTERN PyObject *_wrap_CheckBox_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5398
  PyObject *resultobj = 0;
 
5399
  wxCheckBox *arg1 = (wxCheckBox *) 0 ;
 
5400
  bool result;
 
5401
  void *argp1 = 0 ;
 
5402
  int res1 = 0 ;
 
5403
  PyObject *swig_obj[1] ;
 
5404
  
 
5405
  if (!args) SWIG_fail;
 
5406
  swig_obj[0] = args;
 
5407
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCheckBox, 0 |  0 );
 
5408
  if (!SWIG_IsOK(res1)) {
 
5409
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckBox_GetValue" "', expected argument " "1"" of type '" "wxCheckBox *""'"); 
 
5410
  }
 
5411
  arg1 = reinterpret_cast< wxCheckBox * >(argp1);
 
5412
  {
 
5413
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5414
    result = (bool)(arg1)->GetValue();
 
5415
    wxPyEndAllowThreads(__tstate);
 
5416
    if (PyErr_Occurred()) SWIG_fail;
 
5417
  }
 
5418
  {
 
5419
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
5420
  }
 
5421
  return resultobj;
 
5422
fail:
 
5423
  return NULL;
 
5424
}
 
5425
 
 
5426
 
 
5427
SWIGINTERN PyObject *_wrap_CheckBox_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5428
  PyObject *resultobj = 0;
 
5429
  wxCheckBox *arg1 = (wxCheckBox *) 0 ;
 
5430
  bool result;
 
5431
  void *argp1 = 0 ;
 
5432
  int res1 = 0 ;
 
5433
  PyObject *swig_obj[1] ;
 
5434
  
 
5435
  if (!args) SWIG_fail;
 
5436
  swig_obj[0] = args;
 
5437
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCheckBox, 0 |  0 );
 
5438
  if (!SWIG_IsOK(res1)) {
 
5439
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckBox_IsChecked" "', expected argument " "1"" of type '" "wxCheckBox *""'"); 
 
5440
  }
 
5441
  arg1 = reinterpret_cast< wxCheckBox * >(argp1);
 
5442
  {
 
5443
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5444
    result = (bool)(arg1)->IsChecked();
 
5445
    wxPyEndAllowThreads(__tstate);
 
5446
    if (PyErr_Occurred()) SWIG_fail;
 
5447
  }
 
5448
  {
 
5449
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
5450
  }
 
5451
  return resultobj;
 
5452
fail:
 
5453
  return NULL;
 
5454
}
 
5455
 
 
5456
 
 
5457
SWIGINTERN PyObject *_wrap_CheckBox_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
5458
  PyObject *resultobj = 0;
 
5459
  wxCheckBox *arg1 = (wxCheckBox *) 0 ;
 
5460
  bool arg2 ;
 
5461
  void *argp1 = 0 ;
 
5462
  int res1 = 0 ;
 
5463
  bool val2 ;
 
5464
  int ecode2 = 0 ;
 
5465
  PyObject * obj0 = 0 ;
 
5466
  PyObject * obj1 = 0 ;
 
5467
  char *  kwnames[] = {
 
5468
    (char *) "self",(char *) "state", NULL 
 
5469
  };
 
5470
  
 
5471
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckBox_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
5472
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCheckBox, 0 |  0 );
 
5473
  if (!SWIG_IsOK(res1)) {
 
5474
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckBox_SetValue" "', expected argument " "1"" of type '" "wxCheckBox *""'"); 
 
5475
  }
 
5476
  arg1 = reinterpret_cast< wxCheckBox * >(argp1);
 
5477
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
5478
  if (!SWIG_IsOK(ecode2)) {
 
5479
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CheckBox_SetValue" "', expected argument " "2"" of type '" "bool""'");
 
5480
  } 
 
5481
  arg2 = static_cast< bool >(val2);
 
5482
  {
 
5483
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5484
    (arg1)->SetValue(arg2);
 
5485
    wxPyEndAllowThreads(__tstate);
 
5486
    if (PyErr_Occurred()) SWIG_fail;
 
5487
  }
 
5488
  resultobj = SWIG_Py_Void();
 
5489
  return resultobj;
 
5490
fail:
 
5491
  return NULL;
 
5492
}
 
5493
 
 
5494
 
 
5495
SWIGINTERN PyObject *_wrap_CheckBox_Get3StateValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5496
  PyObject *resultobj = 0;
 
5497
  wxCheckBox *arg1 = (wxCheckBox *) 0 ;
 
5498
  wxCheckBoxState result;
 
5499
  void *argp1 = 0 ;
 
5500
  int res1 = 0 ;
 
5501
  PyObject *swig_obj[1] ;
 
5502
  
 
5503
  if (!args) SWIG_fail;
 
5504
  swig_obj[0] = args;
 
5505
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCheckBox, 0 |  0 );
 
5506
  if (!SWIG_IsOK(res1)) {
 
5507
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckBox_Get3StateValue" "', expected argument " "1"" of type '" "wxCheckBox const *""'"); 
 
5508
  }
 
5509
  arg1 = reinterpret_cast< wxCheckBox * >(argp1);
 
5510
  {
 
5511
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5512
    result = (wxCheckBoxState)((wxCheckBox const *)arg1)->Get3StateValue();
 
5513
    wxPyEndAllowThreads(__tstate);
 
5514
    if (PyErr_Occurred()) SWIG_fail;
 
5515
  }
 
5516
  resultobj = SWIG_From_int(static_cast< int >(result));
 
5517
  return resultobj;
 
5518
fail:
 
5519
  return NULL;
 
5520
}
 
5521
 
 
5522
 
 
5523
SWIGINTERN PyObject *_wrap_CheckBox_Set3StateValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
5524
  PyObject *resultobj = 0;
 
5525
  wxCheckBox *arg1 = (wxCheckBox *) 0 ;
 
5526
  wxCheckBoxState arg2 ;
 
5527
  void *argp1 = 0 ;
 
5528
  int res1 = 0 ;
 
5529
  int val2 ;
 
5530
  int ecode2 = 0 ;
 
5531
  PyObject * obj0 = 0 ;
 
5532
  PyObject * obj1 = 0 ;
 
5533
  char *  kwnames[] = {
 
5534
    (char *) "self",(char *) "state", NULL 
 
5535
  };
 
5536
  
 
5537
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckBox_Set3StateValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
5538
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCheckBox, 0 |  0 );
 
5539
  if (!SWIG_IsOK(res1)) {
 
5540
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckBox_Set3StateValue" "', expected argument " "1"" of type '" "wxCheckBox *""'"); 
 
5541
  }
 
5542
  arg1 = reinterpret_cast< wxCheckBox * >(argp1);
 
5543
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
5544
  if (!SWIG_IsOK(ecode2)) {
 
5545
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CheckBox_Set3StateValue" "', expected argument " "2"" of type '" "wxCheckBoxState""'");
 
5546
  } 
 
5547
  arg2 = static_cast< wxCheckBoxState >(val2);
 
5548
  {
 
5549
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5550
    (arg1)->Set3StateValue(arg2);
 
5551
    wxPyEndAllowThreads(__tstate);
 
5552
    if (PyErr_Occurred()) SWIG_fail;
 
5553
  }
 
5554
  resultobj = SWIG_Py_Void();
 
5555
  return resultobj;
 
5556
fail:
 
5557
  return NULL;
 
5558
}
 
5559
 
 
5560
 
 
5561
SWIGINTERN PyObject *_wrap_CheckBox_Is3State(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5562
  PyObject *resultobj = 0;
 
5563
  wxCheckBox *arg1 = (wxCheckBox *) 0 ;
 
5564
  bool result;
 
5565
  void *argp1 = 0 ;
 
5566
  int res1 = 0 ;
 
5567
  PyObject *swig_obj[1] ;
 
5568
  
 
5569
  if (!args) SWIG_fail;
 
5570
  swig_obj[0] = args;
 
5571
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCheckBox, 0 |  0 );
 
5572
  if (!SWIG_IsOK(res1)) {
 
5573
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckBox_Is3State" "', expected argument " "1"" of type '" "wxCheckBox const *""'"); 
 
5574
  }
 
5575
  arg1 = reinterpret_cast< wxCheckBox * >(argp1);
 
5576
  {
 
5577
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5578
    result = (bool)((wxCheckBox const *)arg1)->Is3State();
 
5579
    wxPyEndAllowThreads(__tstate);
 
5580
    if (PyErr_Occurred()) SWIG_fail;
 
5581
  }
 
5582
  {
 
5583
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
5584
  }
 
5585
  return resultobj;
 
5586
fail:
 
5587
  return NULL;
 
5588
}
 
5589
 
 
5590
 
 
5591
SWIGINTERN PyObject *_wrap_CheckBox_Is3rdStateAllowedForUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5592
  PyObject *resultobj = 0;
 
5593
  wxCheckBox *arg1 = (wxCheckBox *) 0 ;
 
5594
  bool result;
 
5595
  void *argp1 = 0 ;
 
5596
  int res1 = 0 ;
 
5597
  PyObject *swig_obj[1] ;
 
5598
  
 
5599
  if (!args) SWIG_fail;
 
5600
  swig_obj[0] = args;
 
5601
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCheckBox, 0 |  0 );
 
5602
  if (!SWIG_IsOK(res1)) {
 
5603
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckBox_Is3rdStateAllowedForUser" "', expected argument " "1"" of type '" "wxCheckBox const *""'"); 
 
5604
  }
 
5605
  arg1 = reinterpret_cast< wxCheckBox * >(argp1);
 
5606
  {
 
5607
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5608
    result = (bool)((wxCheckBox const *)arg1)->Is3rdStateAllowedForUser();
 
5609
    wxPyEndAllowThreads(__tstate);
 
5610
    if (PyErr_Occurred()) SWIG_fail;
 
5611
  }
 
5612
  {
 
5613
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
5614
  }
 
5615
  return resultobj;
 
5616
fail:
 
5617
  return NULL;
 
5618
}
 
5619
 
 
5620
 
 
5621
SWIGINTERN PyObject *_wrap_CheckBox_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
5622
  PyObject *resultobj = 0;
 
5623
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
5624
  SwigValueWrapper<wxVisualAttributes > result;
 
5625
  int val1 ;
 
5626
  int ecode1 = 0 ;
 
5627
  PyObject * obj0 = 0 ;
 
5628
  char *  kwnames[] = {
 
5629
    (char *) "variant", NULL 
 
5630
  };
 
5631
  
 
5632
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:CheckBox_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
5633
  if (obj0) {
 
5634
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
5635
    if (!SWIG_IsOK(ecode1)) {
 
5636
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CheckBox_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
5637
    } 
 
5638
    arg1 = static_cast< wxWindowVariant >(val1);
 
5639
  }
 
5640
  {
 
5641
    if (!wxPyCheckForApp()) SWIG_fail;
 
5642
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5643
    result = wxCheckBox::GetClassDefaultAttributes(arg1);
 
5644
    wxPyEndAllowThreads(__tstate);
 
5645
    if (PyErr_Occurred()) SWIG_fail;
 
5646
  }
 
5647
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
5648
  return resultobj;
 
5649
fail:
 
5650
  return NULL;
 
5651
}
 
5652
 
 
5653
 
 
5654
SWIGINTERN PyObject *CheckBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5655
  PyObject *obj;
 
5656
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
5657
  SWIG_TypeNewClientData(SWIGTYPE_p_wxCheckBox, SWIG_NewClientData(obj));
 
5658
  return SWIG_Py_Void();
 
5659
}
 
5660
 
 
5661
SWIGINTERN PyObject *CheckBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5662
  return SWIG_Python_InitShadowInstance(args);
 
5663
}
 
5664
 
 
5665
SWIGINTERN int ChoiceNameStr_set(PyObject *) {
 
5666
  SWIG_Error(SWIG_AttributeError,"Variable ChoiceNameStr is read-only.");
 
5667
  return 1;
 
5668
}
 
5669
 
 
5670
 
 
5671
SWIGINTERN PyObject *ChoiceNameStr_get(void) {
 
5672
  PyObject *pyobj = 0;
 
5673
  
 
5674
  {
 
5675
#if wxUSE_UNICODE
 
5676
    pyobj = PyUnicode_FromWideChar((&wxPyChoiceNameStr)->c_str(), (&wxPyChoiceNameStr)->Len());
 
5677
#else
 
5678
    pyobj = PyString_FromStringAndSize((&wxPyChoiceNameStr)->c_str(), (&wxPyChoiceNameStr)->Len());
 
5679
#endif
 
5680
  }
 
5681
  return pyobj;
 
5682
}
 
5683
 
 
5684
 
 
5685
SWIGINTERN PyObject *_wrap_new_Choice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
5686
  PyObject *resultobj = 0;
 
5687
  wxWindow *arg1 = (wxWindow *) 0 ;
 
5688
  int arg2 = (int) -1 ;
 
5689
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
5690
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
5691
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
5692
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
5693
  wxArrayString const &arg5_defvalue = wxPyEmptyStringArray ;
 
5694
  wxArrayString *arg5 = (wxArrayString *) &arg5_defvalue ;
 
5695
  long arg6 = (long) 0 ;
 
5696
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
5697
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
5698
  wxString const &arg8_defvalue = wxPyChoiceNameStr ;
 
5699
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
5700
  wxChoice *result = 0 ;
 
5701
  void *argp1 = 0 ;
 
5702
  int res1 = 0 ;
 
5703
  int val2 ;
 
5704
  int ecode2 = 0 ;
 
5705
  wxPoint temp3 ;
 
5706
  wxSize temp4 ;
 
5707
  bool temp5 = false ;
 
5708
  long val6 ;
 
5709
  int ecode6 = 0 ;
 
5710
  void *argp7 = 0 ;
 
5711
  int res7 = 0 ;
 
5712
  bool temp8 = false ;
 
5713
  PyObject * obj0 = 0 ;
 
5714
  PyObject * obj1 = 0 ;
 
5715
  PyObject * obj2 = 0 ;
 
5716
  PyObject * obj3 = 0 ;
 
5717
  PyObject * obj4 = 0 ;
 
5718
  PyObject * obj5 = 0 ;
 
5719
  PyObject * obj6 = 0 ;
 
5720
  PyObject * obj7 = 0 ;
 
5721
  char *  kwnames[] = {
 
5722
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
5723
  };
 
5724
  
 
5725
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_Choice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
5726
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
5727
  if (!SWIG_IsOK(res1)) {
 
5728
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Choice" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
5729
  }
 
5730
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
5731
  if (obj1) {
 
5732
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
5733
    if (!SWIG_IsOK(ecode2)) {
 
5734
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Choice" "', expected argument " "2"" of type '" "int""'");
 
5735
    } 
 
5736
    arg2 = static_cast< int >(val2);
 
5737
  }
 
5738
  if (obj2) {
 
5739
    {
 
5740
      arg3 = &temp3;
 
5741
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
5742
    }
 
5743
  }
 
5744
  if (obj3) {
 
5745
    {
 
5746
      arg4 = &temp4;
 
5747
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
5748
    }
 
5749
  }
 
5750
  if (obj4) {
 
5751
    {
 
5752
      if (! PySequence_Check(obj4)) {
 
5753
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
5754
        SWIG_fail;
 
5755
      }
 
5756
      arg5 = new wxArrayString;
 
5757
      temp5 = true;
 
5758
      int i, len=PySequence_Length(obj4);
 
5759
      for (i=0; i<len; i++) {
 
5760
        PyObject* item = PySequence_GetItem(obj4, i);
 
5761
        wxString* s = wxString_in_helper(item);
 
5762
        if (PyErr_Occurred())  SWIG_fail;
 
5763
        arg5->Add(*s);
 
5764
        delete s;
 
5765
        Py_DECREF(item);
 
5766
      }
 
5767
    }
 
5768
  }
 
5769
  if (obj5) {
 
5770
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
5771
    if (!SWIG_IsOK(ecode6)) {
 
5772
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Choice" "', expected argument " "6"" of type '" "long""'");
 
5773
    } 
 
5774
    arg6 = static_cast< long >(val6);
 
5775
  }
 
5776
  if (obj6) {
 
5777
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
5778
    if (!SWIG_IsOK(res7)) {
 
5779
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Choice" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
5780
    }
 
5781
    if (!argp7) {
 
5782
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Choice" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
5783
    }
 
5784
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
5785
  }
 
5786
  if (obj7) {
 
5787
    {
 
5788
      arg8 = wxString_in_helper(obj7);
 
5789
      if (arg8 == NULL) SWIG_fail;
 
5790
      temp8 = true;
 
5791
    }
 
5792
  }
 
5793
  {
 
5794
    if (!wxPyCheckForApp()) SWIG_fail;
 
5795
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5796
    result = (wxChoice *)new wxChoice(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,(wxArrayString const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
5797
    wxPyEndAllowThreads(__tstate);
 
5798
    if (PyErr_Occurred()) SWIG_fail;
 
5799
  }
 
5800
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChoice, SWIG_POINTER_NEW |  0 );
 
5801
  {
 
5802
    if (temp5) delete arg5;
 
5803
  }
 
5804
  {
 
5805
    if (temp8)
 
5806
    delete arg8;
 
5807
  }
 
5808
  return resultobj;
 
5809
fail:
 
5810
  {
 
5811
    if (temp5) delete arg5;
 
5812
  }
 
5813
  {
 
5814
    if (temp8)
 
5815
    delete arg8;
 
5816
  }
 
5817
  return NULL;
 
5818
}
 
5819
 
 
5820
 
 
5821
SWIGINTERN PyObject *_wrap_new_PreChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5822
  PyObject *resultobj = 0;
 
5823
  wxChoice *result = 0 ;
 
5824
  
 
5825
  if (!SWIG_Python_UnpackTuple(args,"new_PreChoice",0,0,0)) SWIG_fail;
 
5826
  {
 
5827
    if (!wxPyCheckForApp()) SWIG_fail;
 
5828
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5829
    result = (wxChoice *)new wxChoice();
 
5830
    wxPyEndAllowThreads(__tstate);
 
5831
    if (PyErr_Occurred()) SWIG_fail;
 
5832
  }
 
5833
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChoice, SWIG_POINTER_OWN |  0 );
 
5834
  return resultobj;
 
5835
fail:
 
5836
  return NULL;
 
5837
}
 
5838
 
 
5839
 
 
5840
SWIGINTERN PyObject *_wrap_Choice_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
5841
  PyObject *resultobj = 0;
 
5842
  wxChoice *arg1 = (wxChoice *) 0 ;
 
5843
  wxWindow *arg2 = (wxWindow *) 0 ;
 
5844
  int arg3 = (int) -1 ;
 
5845
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
5846
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
5847
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
5848
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
5849
  wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
 
5850
  wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
 
5851
  long arg7 = (long) 0 ;
 
5852
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
5853
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
5854
  wxString const &arg9_defvalue = wxPyChoiceNameStr ;
 
5855
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
5856
  bool result;
 
5857
  void *argp1 = 0 ;
 
5858
  int res1 = 0 ;
 
5859
  void *argp2 = 0 ;
 
5860
  int res2 = 0 ;
 
5861
  int val3 ;
 
5862
  int ecode3 = 0 ;
 
5863
  wxPoint temp4 ;
 
5864
  wxSize temp5 ;
 
5865
  bool temp6 = false ;
 
5866
  long val7 ;
 
5867
  int ecode7 = 0 ;
 
5868
  void *argp8 = 0 ;
 
5869
  int res8 = 0 ;
 
5870
  bool temp9 = false ;
 
5871
  PyObject * obj0 = 0 ;
 
5872
  PyObject * obj1 = 0 ;
 
5873
  PyObject * obj2 = 0 ;
 
5874
  PyObject * obj3 = 0 ;
 
5875
  PyObject * obj4 = 0 ;
 
5876
  PyObject * obj5 = 0 ;
 
5877
  PyObject * obj6 = 0 ;
 
5878
  PyObject * obj7 = 0 ;
 
5879
  PyObject * obj8 = 0 ;
 
5880
  char *  kwnames[] = {
 
5881
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
5882
  };
 
5883
  
 
5884
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:Choice_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
5885
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChoice, 0 |  0 );
 
5886
  if (!SWIG_IsOK(res1)) {
 
5887
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Choice_Create" "', expected argument " "1"" of type '" "wxChoice *""'"); 
 
5888
  }
 
5889
  arg1 = reinterpret_cast< wxChoice * >(argp1);
 
5890
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
5891
  if (!SWIG_IsOK(res2)) {
 
5892
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Choice_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
5893
  }
 
5894
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
5895
  if (obj2) {
 
5896
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
5897
    if (!SWIG_IsOK(ecode3)) {
 
5898
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Choice_Create" "', expected argument " "3"" of type '" "int""'");
 
5899
    } 
 
5900
    arg3 = static_cast< int >(val3);
 
5901
  }
 
5902
  if (obj3) {
 
5903
    {
 
5904
      arg4 = &temp4;
 
5905
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
5906
    }
 
5907
  }
 
5908
  if (obj4) {
 
5909
    {
 
5910
      arg5 = &temp5;
 
5911
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
5912
    }
 
5913
  }
 
5914
  if (obj5) {
 
5915
    {
 
5916
      if (! PySequence_Check(obj5)) {
 
5917
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
5918
        SWIG_fail;
 
5919
      }
 
5920
      arg6 = new wxArrayString;
 
5921
      temp6 = true;
 
5922
      int i, len=PySequence_Length(obj5);
 
5923
      for (i=0; i<len; i++) {
 
5924
        PyObject* item = PySequence_GetItem(obj5, i);
 
5925
        wxString* s = wxString_in_helper(item);
 
5926
        if (PyErr_Occurred())  SWIG_fail;
 
5927
        arg6->Add(*s);
 
5928
        delete s;
 
5929
        Py_DECREF(item);
 
5930
      }
 
5931
    }
 
5932
  }
 
5933
  if (obj6) {
 
5934
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
5935
    if (!SWIG_IsOK(ecode7)) {
 
5936
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Choice_Create" "', expected argument " "7"" of type '" "long""'");
 
5937
    } 
 
5938
    arg7 = static_cast< long >(val7);
 
5939
  }
 
5940
  if (obj7) {
 
5941
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
5942
    if (!SWIG_IsOK(res8)) {
 
5943
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Choice_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
5944
    }
 
5945
    if (!argp8) {
 
5946
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Choice_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
5947
    }
 
5948
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
5949
  }
 
5950
  if (obj8) {
 
5951
    {
 
5952
      arg9 = wxString_in_helper(obj8);
 
5953
      if (arg9 == NULL) SWIG_fail;
 
5954
      temp9 = true;
 
5955
    }
 
5956
  }
 
5957
  {
 
5958
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
5959
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
5960
    wxPyEndAllowThreads(__tstate);
 
5961
    if (PyErr_Occurred()) SWIG_fail;
 
5962
  }
 
5963
  {
 
5964
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
5965
  }
 
5966
  {
 
5967
    if (temp6) delete arg6;
 
5968
  }
 
5969
  {
 
5970
    if (temp9)
 
5971
    delete arg9;
 
5972
  }
 
5973
  return resultobj;
 
5974
fail:
 
5975
  {
 
5976
    if (temp6) delete arg6;
 
5977
  }
 
5978
  {
 
5979
    if (temp9)
 
5980
    delete arg9;
 
5981
  }
 
5982
  return NULL;
 
5983
}
 
5984
 
 
5985
 
 
5986
SWIGINTERN PyObject *_wrap_Choice_GetCurrentSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
5987
  PyObject *resultobj = 0;
 
5988
  wxChoice *arg1 = (wxChoice *) 0 ;
 
5989
  int result;
 
5990
  void *argp1 = 0 ;
 
5991
  int res1 = 0 ;
 
5992
  PyObject *swig_obj[1] ;
 
5993
  
 
5994
  if (!args) SWIG_fail;
 
5995
  swig_obj[0] = args;
 
5996
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChoice, 0 |  0 );
 
5997
  if (!SWIG_IsOK(res1)) {
 
5998
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Choice_GetCurrentSelection" "', expected argument " "1"" of type '" "wxChoice const *""'"); 
 
5999
  }
 
6000
  arg1 = reinterpret_cast< wxChoice * >(argp1);
 
6001
  {
 
6002
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6003
    result = (int)((wxChoice const *)arg1)->GetCurrentSelection();
 
6004
    wxPyEndAllowThreads(__tstate);
 
6005
    if (PyErr_Occurred()) SWIG_fail;
 
6006
  }
 
6007
  resultobj = SWIG_From_int(static_cast< int >(result));
 
6008
  return resultobj;
 
6009
fail:
 
6010
  return NULL;
 
6011
}
 
6012
 
 
6013
 
 
6014
SWIGINTERN PyObject *_wrap_Choice_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
6015
  PyObject *resultobj = 0;
 
6016
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
6017
  SwigValueWrapper<wxVisualAttributes > result;
 
6018
  int val1 ;
 
6019
  int ecode1 = 0 ;
 
6020
  PyObject * obj0 = 0 ;
 
6021
  char *  kwnames[] = {
 
6022
    (char *) "variant", NULL 
 
6023
  };
 
6024
  
 
6025
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Choice_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
6026
  if (obj0) {
 
6027
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
6028
    if (!SWIG_IsOK(ecode1)) {
 
6029
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Choice_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
6030
    } 
 
6031
    arg1 = static_cast< wxWindowVariant >(val1);
 
6032
  }
 
6033
  {
 
6034
    if (!wxPyCheckForApp()) SWIG_fail;
 
6035
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6036
    result = wxChoice::GetClassDefaultAttributes(arg1);
 
6037
    wxPyEndAllowThreads(__tstate);
 
6038
    if (PyErr_Occurred()) SWIG_fail;
 
6039
  }
 
6040
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
6041
  return resultobj;
 
6042
fail:
 
6043
  return NULL;
 
6044
}
 
6045
 
 
6046
 
 
6047
SWIGINTERN PyObject *Choice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6048
  PyObject *obj;
 
6049
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
6050
  SWIG_TypeNewClientData(SWIGTYPE_p_wxChoice, SWIG_NewClientData(obj));
 
6051
  return SWIG_Py_Void();
 
6052
}
 
6053
 
 
6054
SWIGINTERN PyObject *Choice_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6055
  return SWIG_Python_InitShadowInstance(args);
 
6056
}
 
6057
 
 
6058
SWIGINTERN int ComboBoxNameStr_set(PyObject *) {
 
6059
  SWIG_Error(SWIG_AttributeError,"Variable ComboBoxNameStr is read-only.");
 
6060
  return 1;
 
6061
}
 
6062
 
 
6063
 
 
6064
SWIGINTERN PyObject *ComboBoxNameStr_get(void) {
 
6065
  PyObject *pyobj = 0;
 
6066
  
 
6067
  {
 
6068
#if wxUSE_UNICODE
 
6069
    pyobj = PyUnicode_FromWideChar((&wxPyComboBoxNameStr)->c_str(), (&wxPyComboBoxNameStr)->Len());
 
6070
#else
 
6071
    pyobj = PyString_FromStringAndSize((&wxPyComboBoxNameStr)->c_str(), (&wxPyComboBoxNameStr)->Len());
 
6072
#endif
 
6073
  }
 
6074
  return pyobj;
 
6075
}
 
6076
 
 
6077
 
 
6078
SWIGINTERN PyObject *_wrap_new_ComboBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
6079
  PyObject *resultobj = 0;
 
6080
  wxWindow *arg1 = (wxWindow *) 0 ;
 
6081
  int arg2 = (int) -1 ;
 
6082
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
6083
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
6084
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
6085
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
6086
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
6087
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
6088
  wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
 
6089
  wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
 
6090
  long arg7 = (long) 0 ;
 
6091
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
6092
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
6093
  wxString const &arg9_defvalue = wxPyComboBoxNameStr ;
 
6094
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
6095
  wxComboBox *result = 0 ;
 
6096
  void *argp1 = 0 ;
 
6097
  int res1 = 0 ;
 
6098
  int val2 ;
 
6099
  int ecode2 = 0 ;
 
6100
  bool temp3 = false ;
 
6101
  wxPoint temp4 ;
 
6102
  wxSize temp5 ;
 
6103
  bool temp6 = false ;
 
6104
  long val7 ;
 
6105
  int ecode7 = 0 ;
 
6106
  void *argp8 = 0 ;
 
6107
  int res8 = 0 ;
 
6108
  bool temp9 = false ;
 
6109
  PyObject * obj0 = 0 ;
 
6110
  PyObject * obj1 = 0 ;
 
6111
  PyObject * obj2 = 0 ;
 
6112
  PyObject * obj3 = 0 ;
 
6113
  PyObject * obj4 = 0 ;
 
6114
  PyObject * obj5 = 0 ;
 
6115
  PyObject * obj6 = 0 ;
 
6116
  PyObject * obj7 = 0 ;
 
6117
  PyObject * obj8 = 0 ;
 
6118
  char *  kwnames[] = {
 
6119
    (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
6120
  };
 
6121
  
 
6122
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_ComboBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
6123
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
6124
  if (!SWIG_IsOK(res1)) {
 
6125
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComboBox" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
6126
  }
 
6127
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
6128
  if (obj1) {
 
6129
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
6130
    if (!SWIG_IsOK(ecode2)) {
 
6131
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ComboBox" "', expected argument " "2"" of type '" "int""'");
 
6132
    } 
 
6133
    arg2 = static_cast< int >(val2);
 
6134
  }
 
6135
  if (obj2) {
 
6136
    {
 
6137
      arg3 = wxString_in_helper(obj2);
 
6138
      if (arg3 == NULL) SWIG_fail;
 
6139
      temp3 = true;
 
6140
    }
 
6141
  }
 
6142
  if (obj3) {
 
6143
    {
 
6144
      arg4 = &temp4;
 
6145
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
6146
    }
 
6147
  }
 
6148
  if (obj4) {
 
6149
    {
 
6150
      arg5 = &temp5;
 
6151
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
6152
    }
 
6153
  }
 
6154
  if (obj5) {
 
6155
    {
 
6156
      if (! PySequence_Check(obj5)) {
 
6157
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
6158
        SWIG_fail;
 
6159
      }
 
6160
      arg6 = new wxArrayString;
 
6161
      temp6 = true;
 
6162
      int i, len=PySequence_Length(obj5);
 
6163
      for (i=0; i<len; i++) {
 
6164
        PyObject* item = PySequence_GetItem(obj5, i);
 
6165
        wxString* s = wxString_in_helper(item);
 
6166
        if (PyErr_Occurred())  SWIG_fail;
 
6167
        arg6->Add(*s);
 
6168
        delete s;
 
6169
        Py_DECREF(item);
 
6170
      }
 
6171
    }
 
6172
  }
 
6173
  if (obj6) {
 
6174
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
6175
    if (!SWIG_IsOK(ecode7)) {
 
6176
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ComboBox" "', expected argument " "7"" of type '" "long""'");
 
6177
    } 
 
6178
    arg7 = static_cast< long >(val7);
 
6179
  }
 
6180
  if (obj7) {
 
6181
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
6182
    if (!SWIG_IsOK(res8)) {
 
6183
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ComboBox" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
6184
    }
 
6185
    if (!argp8) {
 
6186
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComboBox" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
6187
    }
 
6188
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
6189
  }
 
6190
  if (obj8) {
 
6191
    {
 
6192
      arg9 = wxString_in_helper(obj8);
 
6193
      if (arg9 == NULL) SWIG_fail;
 
6194
      temp9 = true;
 
6195
    }
 
6196
  }
 
6197
  {
 
6198
    if (!wxPyCheckForApp()) SWIG_fail;
 
6199
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6200
    result = (wxComboBox *)new wxComboBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
6201
    wxPyEndAllowThreads(__tstate);
 
6202
    if (PyErr_Occurred()) SWIG_fail;
 
6203
  }
 
6204
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxComboBox, SWIG_POINTER_NEW |  0 );
 
6205
  {
 
6206
    if (temp3)
 
6207
    delete arg3;
 
6208
  }
 
6209
  {
 
6210
    if (temp6) delete arg6;
 
6211
  }
 
6212
  {
 
6213
    if (temp9)
 
6214
    delete arg9;
 
6215
  }
 
6216
  return resultobj;
 
6217
fail:
 
6218
  {
 
6219
    if (temp3)
 
6220
    delete arg3;
 
6221
  }
 
6222
  {
 
6223
    if (temp6) delete arg6;
 
6224
  }
 
6225
  {
 
6226
    if (temp9)
 
6227
    delete arg9;
 
6228
  }
 
6229
  return NULL;
 
6230
}
 
6231
 
 
6232
 
 
6233
SWIGINTERN PyObject *_wrap_new_PreComboBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6234
  PyObject *resultobj = 0;
 
6235
  wxComboBox *result = 0 ;
 
6236
  
 
6237
  if (!SWIG_Python_UnpackTuple(args,"new_PreComboBox",0,0,0)) SWIG_fail;
 
6238
  {
 
6239
    if (!wxPyCheckForApp()) SWIG_fail;
 
6240
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6241
    result = (wxComboBox *)new wxComboBox();
 
6242
    wxPyEndAllowThreads(__tstate);
 
6243
    if (PyErr_Occurred()) SWIG_fail;
 
6244
  }
 
6245
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxComboBox, SWIG_POINTER_OWN |  0 );
 
6246
  return resultobj;
 
6247
fail:
 
6248
  return NULL;
 
6249
}
 
6250
 
 
6251
 
 
6252
SWIGINTERN PyObject *_wrap_ComboBox_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
6253
  PyObject *resultobj = 0;
 
6254
  wxComboBox *arg1 = (wxComboBox *) 0 ;
 
6255
  wxWindow *arg2 = (wxWindow *) 0 ;
 
6256
  int arg3 = (int) -1 ;
 
6257
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
6258
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
6259
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
6260
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
6261
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
6262
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
6263
  wxArrayString const &arg7_defvalue = wxPyEmptyStringArray ;
 
6264
  wxArrayString *arg7 = (wxArrayString *) &arg7_defvalue ;
 
6265
  long arg8 = (long) 0 ;
 
6266
  wxValidator const &arg9_defvalue = wxDefaultValidator ;
 
6267
  wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
 
6268
  wxString const &arg10_defvalue = wxPyChoiceNameStr ;
 
6269
  wxString *arg10 = (wxString *) &arg10_defvalue ;
 
6270
  bool result;
 
6271
  void *argp1 = 0 ;
 
6272
  int res1 = 0 ;
 
6273
  void *argp2 = 0 ;
 
6274
  int res2 = 0 ;
 
6275
  int val3 ;
 
6276
  int ecode3 = 0 ;
 
6277
  bool temp4 = false ;
 
6278
  wxPoint temp5 ;
 
6279
  wxSize temp6 ;
 
6280
  bool temp7 = false ;
 
6281
  long val8 ;
 
6282
  int ecode8 = 0 ;
 
6283
  void *argp9 = 0 ;
 
6284
  int res9 = 0 ;
 
6285
  bool temp10 = false ;
 
6286
  PyObject * obj0 = 0 ;
 
6287
  PyObject * obj1 = 0 ;
 
6288
  PyObject * obj2 = 0 ;
 
6289
  PyObject * obj3 = 0 ;
 
6290
  PyObject * obj4 = 0 ;
 
6291
  PyObject * obj5 = 0 ;
 
6292
  PyObject * obj6 = 0 ;
 
6293
  PyObject * obj7 = 0 ;
 
6294
  PyObject * obj8 = 0 ;
 
6295
  PyObject * obj9 = 0 ;
 
6296
  char *  kwnames[] = {
 
6297
    (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
6298
  };
 
6299
  
 
6300
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:ComboBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
 
6301
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxComboBox, 0 |  0 );
 
6302
  if (!SWIG_IsOK(res1)) {
 
6303
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboBox_Create" "', expected argument " "1"" of type '" "wxComboBox *""'"); 
 
6304
  }
 
6305
  arg1 = reinterpret_cast< wxComboBox * >(argp1);
 
6306
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
6307
  if (!SWIG_IsOK(res2)) {
 
6308
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComboBox_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
6309
  }
 
6310
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
6311
  if (obj2) {
 
6312
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
6313
    if (!SWIG_IsOK(ecode3)) {
 
6314
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboBox_Create" "', expected argument " "3"" of type '" "int""'");
 
6315
    } 
 
6316
    arg3 = static_cast< int >(val3);
 
6317
  }
 
6318
  if (obj3) {
 
6319
    {
 
6320
      arg4 = wxString_in_helper(obj3);
 
6321
      if (arg4 == NULL) SWIG_fail;
 
6322
      temp4 = true;
 
6323
    }
 
6324
  }
 
6325
  if (obj4) {
 
6326
    {
 
6327
      arg5 = &temp5;
 
6328
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
6329
    }
 
6330
  }
 
6331
  if (obj5) {
 
6332
    {
 
6333
      arg6 = &temp6;
 
6334
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
6335
    }
 
6336
  }
 
6337
  if (obj6) {
 
6338
    {
 
6339
      if (! PySequence_Check(obj6)) {
 
6340
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
6341
        SWIG_fail;
 
6342
      }
 
6343
      arg7 = new wxArrayString;
 
6344
      temp7 = true;
 
6345
      int i, len=PySequence_Length(obj6);
 
6346
      for (i=0; i<len; i++) {
 
6347
        PyObject* item = PySequence_GetItem(obj6, i);
 
6348
        wxString* s = wxString_in_helper(item);
 
6349
        if (PyErr_Occurred())  SWIG_fail;
 
6350
        arg7->Add(*s);
 
6351
        delete s;
 
6352
        Py_DECREF(item);
 
6353
      }
 
6354
    }
 
6355
  }
 
6356
  if (obj7) {
 
6357
    ecode8 = SWIG_AsVal_long(obj7, &val8);
 
6358
    if (!SWIG_IsOK(ecode8)) {
 
6359
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ComboBox_Create" "', expected argument " "8"" of type '" "long""'");
 
6360
    } 
 
6361
    arg8 = static_cast< long >(val8);
 
6362
  }
 
6363
  if (obj8) {
 
6364
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_wxValidator,  0  | 0);
 
6365
    if (!SWIG_IsOK(res9)) {
 
6366
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ComboBox_Create" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
6367
    }
 
6368
    if (!argp9) {
 
6369
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComboBox_Create" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
6370
    }
 
6371
    arg9 = reinterpret_cast< wxValidator * >(argp9);
 
6372
  }
 
6373
  if (obj9) {
 
6374
    {
 
6375
      arg10 = wxString_in_helper(obj9);
 
6376
      if (arg10 == NULL) SWIG_fail;
 
6377
      temp10 = true;
 
6378
    }
 
6379
  }
 
6380
  {
 
6381
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6382
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,(wxArrayString const &)*arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);
 
6383
    wxPyEndAllowThreads(__tstate);
 
6384
    if (PyErr_Occurred()) SWIG_fail;
 
6385
  }
 
6386
  {
 
6387
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
6388
  }
 
6389
  {
 
6390
    if (temp4)
 
6391
    delete arg4;
 
6392
  }
 
6393
  {
 
6394
    if (temp7) delete arg7;
 
6395
  }
 
6396
  {
 
6397
    if (temp10)
 
6398
    delete arg10;
 
6399
  }
 
6400
  return resultobj;
 
6401
fail:
 
6402
  {
 
6403
    if (temp4)
 
6404
    delete arg4;
 
6405
  }
 
6406
  {
 
6407
    if (temp7) delete arg7;
 
6408
  }
 
6409
  {
 
6410
    if (temp10)
 
6411
    delete arg10;
 
6412
  }
 
6413
  return NULL;
 
6414
}
 
6415
 
 
6416
 
 
6417
SWIGINTERN PyObject *_wrap_ComboBox_SetMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
6418
  PyObject *resultobj = 0;
 
6419
  wxComboBox *arg1 = (wxComboBox *) 0 ;
 
6420
  long arg2 ;
 
6421
  long arg3 ;
 
6422
  void *argp1 = 0 ;
 
6423
  int res1 = 0 ;
 
6424
  long val2 ;
 
6425
  int ecode2 = 0 ;
 
6426
  long val3 ;
 
6427
  int ecode3 = 0 ;
 
6428
  PyObject * obj0 = 0 ;
 
6429
  PyObject * obj1 = 0 ;
 
6430
  PyObject * obj2 = 0 ;
 
6431
  char *  kwnames[] = {
 
6432
    (char *) "self",(char *) "from",(char *) "to", NULL 
 
6433
  };
 
6434
  
 
6435
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboBox_SetMark",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
6436
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxComboBox, 0 |  0 );
 
6437
  if (!SWIG_IsOK(res1)) {
 
6438
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboBox_SetMark" "', expected argument " "1"" of type '" "wxComboBox *""'"); 
 
6439
  }
 
6440
  arg1 = reinterpret_cast< wxComboBox * >(argp1);
 
6441
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
6442
  if (!SWIG_IsOK(ecode2)) {
 
6443
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboBox_SetMark" "', expected argument " "2"" of type '" "long""'");
 
6444
  } 
 
6445
  arg2 = static_cast< long >(val2);
 
6446
  ecode3 = SWIG_AsVal_long(obj2, &val3);
 
6447
  if (!SWIG_IsOK(ecode3)) {
 
6448
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboBox_SetMark" "', expected argument " "3"" of type '" "long""'");
 
6449
  } 
 
6450
  arg3 = static_cast< long >(val3);
 
6451
  {
 
6452
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6453
    wxComboBox_SetMark(arg1,arg2,arg3);
 
6454
    wxPyEndAllowThreads(__tstate);
 
6455
    if (PyErr_Occurred()) SWIG_fail;
 
6456
  }
 
6457
  resultobj = SWIG_Py_Void();
 
6458
  return resultobj;
 
6459
fail:
 
6460
  return NULL;
 
6461
}
 
6462
 
 
6463
 
 
6464
SWIGINTERN PyObject *_wrap_ComboBox_GetMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6465
  PyObject *resultobj = 0;
 
6466
  wxComboBox *arg1 = (wxComboBox *) 0 ;
 
6467
  long *arg2 = (long *) 0 ;
 
6468
  long *arg3 = (long *) 0 ;
 
6469
  void *argp1 = 0 ;
 
6470
  int res1 = 0 ;
 
6471
  long temp2 ;
 
6472
  int res2 = SWIG_TMPOBJ ;
 
6473
  long temp3 ;
 
6474
  int res3 = SWIG_TMPOBJ ;
 
6475
  PyObject *swig_obj[1] ;
 
6476
  
 
6477
  arg2 = &temp2;
 
6478
  arg3 = &temp3;
 
6479
  if (!args) SWIG_fail;
 
6480
  swig_obj[0] = args;
 
6481
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxComboBox, 0 |  0 );
 
6482
  if (!SWIG_IsOK(res1)) {
 
6483
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboBox_GetMark" "', expected argument " "1"" of type '" "wxComboBox *""'"); 
 
6484
  }
 
6485
  arg1 = reinterpret_cast< wxComboBox * >(argp1);
 
6486
  {
 
6487
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6488
    (arg1)->GetSelection(arg2,arg3);
 
6489
    wxPyEndAllowThreads(__tstate);
 
6490
    if (PyErr_Occurred()) SWIG_fail;
 
6491
  }
 
6492
  resultobj = SWIG_Py_Void();
 
6493
  if (SWIG_IsTmpObj(res2)) {
 
6494
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
 
6495
  } else {
 
6496
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
6497
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
 
6498
  }
 
6499
  if (SWIG_IsTmpObj(res3)) {
 
6500
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
 
6501
  } else {
 
6502
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
6503
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
 
6504
  }
 
6505
  return resultobj;
 
6506
fail:
 
6507
  return NULL;
 
6508
}
 
6509
 
 
6510
 
 
6511
SWIGINTERN PyObject *_wrap_ComboBox_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6512
  PyObject *resultobj = 0;
 
6513
  wxComboBox *arg1 = (wxComboBox *) 0 ;
 
6514
  bool result;
 
6515
  void *argp1 = 0 ;
 
6516
  int res1 = 0 ;
 
6517
  PyObject *swig_obj[1] ;
 
6518
  
 
6519
  if (!args) SWIG_fail;
 
6520
  swig_obj[0] = args;
 
6521
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxComboBox, 0 |  0 );
 
6522
  if (!SWIG_IsOK(res1)) {
 
6523
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboBox_IsEmpty" "', expected argument " "1"" of type '" "wxComboBox *""'"); 
 
6524
  }
 
6525
  arg1 = reinterpret_cast< wxComboBox * >(argp1);
 
6526
  {
 
6527
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6528
    result = (bool)wxComboBox_IsEmpty(arg1);
 
6529
    wxPyEndAllowThreads(__tstate);
 
6530
    if (PyErr_Occurred()) SWIG_fail;
 
6531
  }
 
6532
  {
 
6533
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
6534
  }
 
6535
  return resultobj;
 
6536
fail:
 
6537
  return NULL;
 
6538
}
 
6539
 
 
6540
 
 
6541
SWIGINTERN PyObject *_wrap_ComboBox_IsListEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6542
  PyObject *resultobj = 0;
 
6543
  wxComboBox *arg1 = (wxComboBox *) 0 ;
 
6544
  bool result;
 
6545
  void *argp1 = 0 ;
 
6546
  int res1 = 0 ;
 
6547
  PyObject *swig_obj[1] ;
 
6548
  
 
6549
  if (!args) SWIG_fail;
 
6550
  swig_obj[0] = args;
 
6551
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxComboBox, 0 |  0 );
 
6552
  if (!SWIG_IsOK(res1)) {
 
6553
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboBox_IsListEmpty" "', expected argument " "1"" of type '" "wxComboBox const *""'"); 
 
6554
  }
 
6555
  arg1 = reinterpret_cast< wxComboBox * >(argp1);
 
6556
  {
 
6557
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6558
    result = (bool)((wxComboBox const *)arg1)->IsListEmpty();
 
6559
    wxPyEndAllowThreads(__tstate);
 
6560
    if (PyErr_Occurred()) SWIG_fail;
 
6561
  }
 
6562
  {
 
6563
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
6564
  }
 
6565
  return resultobj;
 
6566
fail:
 
6567
  return NULL;
 
6568
}
 
6569
 
 
6570
 
 
6571
SWIGINTERN PyObject *_wrap_ComboBox_IsTextEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6572
  PyObject *resultobj = 0;
 
6573
  wxComboBox *arg1 = (wxComboBox *) 0 ;
 
6574
  bool result;
 
6575
  void *argp1 = 0 ;
 
6576
  int res1 = 0 ;
 
6577
  PyObject *swig_obj[1] ;
 
6578
  
 
6579
  if (!args) SWIG_fail;
 
6580
  swig_obj[0] = args;
 
6581
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxComboBox, 0 |  0 );
 
6582
  if (!SWIG_IsOK(res1)) {
 
6583
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboBox_IsTextEmpty" "', expected argument " "1"" of type '" "wxComboBox const *""'"); 
 
6584
  }
 
6585
  arg1 = reinterpret_cast< wxComboBox * >(argp1);
 
6586
  {
 
6587
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6588
    result = (bool)((wxComboBox const *)arg1)->IsTextEmpty();
 
6589
    wxPyEndAllowThreads(__tstate);
 
6590
    if (PyErr_Occurred()) SWIG_fail;
 
6591
  }
 
6592
  {
 
6593
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
6594
  }
 
6595
  return resultobj;
 
6596
fail:
 
6597
  return NULL;
 
6598
}
 
6599
 
 
6600
 
 
6601
SWIGINTERN PyObject *_wrap_ComboBox_Popup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6602
  PyObject *resultobj = 0;
 
6603
  wxComboBox *arg1 = (wxComboBox *) 0 ;
 
6604
  void *argp1 = 0 ;
 
6605
  int res1 = 0 ;
 
6606
  PyObject *swig_obj[1] ;
 
6607
  
 
6608
  if (!args) SWIG_fail;
 
6609
  swig_obj[0] = args;
 
6610
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxComboBox, 0 |  0 );
 
6611
  if (!SWIG_IsOK(res1)) {
 
6612
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboBox_Popup" "', expected argument " "1"" of type '" "wxComboBox *""'"); 
 
6613
  }
 
6614
  arg1 = reinterpret_cast< wxComboBox * >(argp1);
 
6615
  {
 
6616
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6617
    (arg1)->Popup();
 
6618
    wxPyEndAllowThreads(__tstate);
 
6619
    if (PyErr_Occurred()) SWIG_fail;
 
6620
  }
 
6621
  resultobj = SWIG_Py_Void();
 
6622
  return resultobj;
 
6623
fail:
 
6624
  return NULL;
 
6625
}
 
6626
 
 
6627
 
 
6628
SWIGINTERN PyObject *_wrap_ComboBox_Dismiss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6629
  PyObject *resultobj = 0;
 
6630
  wxComboBox *arg1 = (wxComboBox *) 0 ;
 
6631
  void *argp1 = 0 ;
 
6632
  int res1 = 0 ;
 
6633
  PyObject *swig_obj[1] ;
 
6634
  
 
6635
  if (!args) SWIG_fail;
 
6636
  swig_obj[0] = args;
 
6637
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxComboBox, 0 |  0 );
 
6638
  if (!SWIG_IsOK(res1)) {
 
6639
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboBox_Dismiss" "', expected argument " "1"" of type '" "wxComboBox *""'"); 
 
6640
  }
 
6641
  arg1 = reinterpret_cast< wxComboBox * >(argp1);
 
6642
  {
 
6643
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6644
    (arg1)->Dismiss();
 
6645
    wxPyEndAllowThreads(__tstate);
 
6646
    if (PyErr_Occurred()) SWIG_fail;
 
6647
  }
 
6648
  resultobj = SWIG_Py_Void();
 
6649
  return resultobj;
 
6650
fail:
 
6651
  return NULL;
 
6652
}
 
6653
 
 
6654
 
 
6655
SWIGINTERN PyObject *_wrap_ComboBox_GetCurrentSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6656
  PyObject *resultobj = 0;
 
6657
  wxComboBox *arg1 = (wxComboBox *) 0 ;
 
6658
  int result;
 
6659
  void *argp1 = 0 ;
 
6660
  int res1 = 0 ;
 
6661
  PyObject *swig_obj[1] ;
 
6662
  
 
6663
  if (!args) SWIG_fail;
 
6664
  swig_obj[0] = args;
 
6665
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxComboBox, 0 |  0 );
 
6666
  if (!SWIG_IsOK(res1)) {
 
6667
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboBox_GetCurrentSelection" "', expected argument " "1"" of type '" "wxComboBox const *""'"); 
 
6668
  }
 
6669
  arg1 = reinterpret_cast< wxComboBox * >(argp1);
 
6670
  {
 
6671
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6672
    result = (int)((wxComboBox const *)arg1)->GetCurrentSelection();
 
6673
    wxPyEndAllowThreads(__tstate);
 
6674
    if (PyErr_Occurred()) SWIG_fail;
 
6675
  }
 
6676
  resultobj = SWIG_From_int(static_cast< int >(result));
 
6677
  return resultobj;
 
6678
fail:
 
6679
  return NULL;
 
6680
}
 
6681
 
 
6682
 
 
6683
SWIGINTERN PyObject *_wrap_ComboBox_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
6684
  PyObject *resultobj = 0;
 
6685
  wxComboBox *arg1 = (wxComboBox *) 0 ;
 
6686
  wxString *arg2 = 0 ;
 
6687
  bool result;
 
6688
  void *argp1 = 0 ;
 
6689
  int res1 = 0 ;
 
6690
  bool temp2 = false ;
 
6691
  PyObject * obj0 = 0 ;
 
6692
  PyObject * obj1 = 0 ;
 
6693
  char *  kwnames[] = {
 
6694
    (char *) "self",(char *) "string", NULL 
 
6695
  };
 
6696
  
 
6697
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboBox_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
 
6698
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxComboBox, 0 |  0 );
 
6699
  if (!SWIG_IsOK(res1)) {
 
6700
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboBox_SetStringSelection" "', expected argument " "1"" of type '" "wxComboBox *""'"); 
 
6701
  }
 
6702
  arg1 = reinterpret_cast< wxComboBox * >(argp1);
 
6703
  {
 
6704
    arg2 = wxString_in_helper(obj1);
 
6705
    if (arg2 == NULL) SWIG_fail;
 
6706
    temp2 = true;
 
6707
  }
 
6708
  {
 
6709
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6710
    result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
 
6711
    wxPyEndAllowThreads(__tstate);
 
6712
    if (PyErr_Occurred()) SWIG_fail;
 
6713
  }
 
6714
  {
 
6715
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
6716
  }
 
6717
  {
 
6718
    if (temp2)
 
6719
    delete arg2;
 
6720
  }
 
6721
  return resultobj;
 
6722
fail:
 
6723
  {
 
6724
    if (temp2)
 
6725
    delete arg2;
 
6726
  }
 
6727
  return NULL;
 
6728
}
 
6729
 
 
6730
 
 
6731
SWIGINTERN PyObject *_wrap_ComboBox_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
6732
  PyObject *resultobj = 0;
 
6733
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
6734
  SwigValueWrapper<wxVisualAttributes > result;
 
6735
  int val1 ;
 
6736
  int ecode1 = 0 ;
 
6737
  PyObject * obj0 = 0 ;
 
6738
  char *  kwnames[] = {
 
6739
    (char *) "variant", NULL 
 
6740
  };
 
6741
  
 
6742
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ComboBox_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
6743
  if (obj0) {
 
6744
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
6745
    if (!SWIG_IsOK(ecode1)) {
 
6746
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ComboBox_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
6747
    } 
 
6748
    arg1 = static_cast< wxWindowVariant >(val1);
 
6749
  }
 
6750
  {
 
6751
    if (!wxPyCheckForApp()) SWIG_fail;
 
6752
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6753
    result = wxComboBox::GetClassDefaultAttributes(arg1);
 
6754
    wxPyEndAllowThreads(__tstate);
 
6755
    if (PyErr_Occurred()) SWIG_fail;
 
6756
  }
 
6757
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
6758
  return resultobj;
 
6759
fail:
 
6760
  return NULL;
 
6761
}
 
6762
 
 
6763
 
 
6764
SWIGINTERN PyObject *ComboBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6765
  PyObject *obj;
 
6766
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
6767
  SWIG_TypeNewClientData(SWIGTYPE_p_wxComboBox, SWIG_NewClientData(obj));
 
6768
  return SWIG_Py_Void();
 
6769
}
 
6770
 
 
6771
SWIGINTERN PyObject *ComboBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6772
  return SWIG_Python_InitShadowInstance(args);
 
6773
}
 
6774
 
 
6775
SWIGINTERN int GaugeNameStr_set(PyObject *) {
 
6776
  SWIG_Error(SWIG_AttributeError,"Variable GaugeNameStr is read-only.");
 
6777
  return 1;
 
6778
}
 
6779
 
 
6780
 
 
6781
SWIGINTERN PyObject *GaugeNameStr_get(void) {
 
6782
  PyObject *pyobj = 0;
 
6783
  
 
6784
  {
 
6785
#if wxUSE_UNICODE
 
6786
    pyobj = PyUnicode_FromWideChar((&wxPyGaugeNameStr)->c_str(), (&wxPyGaugeNameStr)->Len());
 
6787
#else
 
6788
    pyobj = PyString_FromStringAndSize((&wxPyGaugeNameStr)->c_str(), (&wxPyGaugeNameStr)->Len());
 
6789
#endif
 
6790
  }
 
6791
  return pyobj;
 
6792
}
 
6793
 
 
6794
 
 
6795
SWIGINTERN PyObject *_wrap_new_Gauge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
6796
  PyObject *resultobj = 0;
 
6797
  wxWindow *arg1 = (wxWindow *) 0 ;
 
6798
  int arg2 = (int) -1 ;
 
6799
  int arg3 = (int) 100 ;
 
6800
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
6801
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
6802
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
6803
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
6804
  long arg6 = (long) wxGA_HORIZONTAL ;
 
6805
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
6806
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
6807
  wxString const &arg8_defvalue = wxPyGaugeNameStr ;
 
6808
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
6809
  wxGauge *result = 0 ;
 
6810
  void *argp1 = 0 ;
 
6811
  int res1 = 0 ;
 
6812
  int val2 ;
 
6813
  int ecode2 = 0 ;
 
6814
  int val3 ;
 
6815
  int ecode3 = 0 ;
 
6816
  wxPoint temp4 ;
 
6817
  wxSize temp5 ;
 
6818
  long val6 ;
 
6819
  int ecode6 = 0 ;
 
6820
  void *argp7 = 0 ;
 
6821
  int res7 = 0 ;
 
6822
  bool temp8 = false ;
 
6823
  PyObject * obj0 = 0 ;
 
6824
  PyObject * obj1 = 0 ;
 
6825
  PyObject * obj2 = 0 ;
 
6826
  PyObject * obj3 = 0 ;
 
6827
  PyObject * obj4 = 0 ;
 
6828
  PyObject * obj5 = 0 ;
 
6829
  PyObject * obj6 = 0 ;
 
6830
  PyObject * obj7 = 0 ;
 
6831
  char *  kwnames[] = {
 
6832
    (char *) "parent",(char *) "id",(char *) "range",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
6833
  };
 
6834
  
 
6835
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_Gauge",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
6836
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
6837
  if (!SWIG_IsOK(res1)) {
 
6838
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gauge" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
6839
  }
 
6840
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
6841
  if (obj1) {
 
6842
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
6843
    if (!SWIG_IsOK(ecode2)) {
 
6844
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gauge" "', expected argument " "2"" of type '" "int""'");
 
6845
    } 
 
6846
    arg2 = static_cast< int >(val2);
 
6847
  }
 
6848
  if (obj2) {
 
6849
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
6850
    if (!SWIG_IsOK(ecode3)) {
 
6851
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gauge" "', expected argument " "3"" of type '" "int""'");
 
6852
    } 
 
6853
    arg3 = static_cast< int >(val3);
 
6854
  }
 
6855
  if (obj3) {
 
6856
    {
 
6857
      arg4 = &temp4;
 
6858
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
6859
    }
 
6860
  }
 
6861
  if (obj4) {
 
6862
    {
 
6863
      arg5 = &temp5;
 
6864
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
6865
    }
 
6866
  }
 
6867
  if (obj5) {
 
6868
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
6869
    if (!SWIG_IsOK(ecode6)) {
 
6870
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Gauge" "', expected argument " "6"" of type '" "long""'");
 
6871
    } 
 
6872
    arg6 = static_cast< long >(val6);
 
6873
  }
 
6874
  if (obj6) {
 
6875
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
6876
    if (!SWIG_IsOK(res7)) {
 
6877
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Gauge" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
6878
    }
 
6879
    if (!argp7) {
 
6880
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gauge" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
6881
    }
 
6882
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
6883
  }
 
6884
  if (obj7) {
 
6885
    {
 
6886
      arg8 = wxString_in_helper(obj7);
 
6887
      if (arg8 == NULL) SWIG_fail;
 
6888
      temp8 = true;
 
6889
    }
 
6890
  }
 
6891
  {
 
6892
    if (!wxPyCheckForApp()) SWIG_fail;
 
6893
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6894
    result = (wxGauge *)new wxGauge(arg1,arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
6895
    wxPyEndAllowThreads(__tstate);
 
6896
    if (PyErr_Occurred()) SWIG_fail;
 
6897
  }
 
6898
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGauge, SWIG_POINTER_NEW |  0 );
 
6899
  {
 
6900
    if (temp8)
 
6901
    delete arg8;
 
6902
  }
 
6903
  return resultobj;
 
6904
fail:
 
6905
  {
 
6906
    if (temp8)
 
6907
    delete arg8;
 
6908
  }
 
6909
  return NULL;
 
6910
}
 
6911
 
 
6912
 
 
6913
SWIGINTERN PyObject *_wrap_new_PreGauge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
6914
  PyObject *resultobj = 0;
 
6915
  wxGauge *result = 0 ;
 
6916
  
 
6917
  if (!SWIG_Python_UnpackTuple(args,"new_PreGauge",0,0,0)) SWIG_fail;
 
6918
  {
 
6919
    if (!wxPyCheckForApp()) SWIG_fail;
 
6920
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
6921
    result = (wxGauge *)new wxGauge();
 
6922
    wxPyEndAllowThreads(__tstate);
 
6923
    if (PyErr_Occurred()) SWIG_fail;
 
6924
  }
 
6925
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGauge, SWIG_POINTER_OWN |  0 );
 
6926
  return resultobj;
 
6927
fail:
 
6928
  return NULL;
 
6929
}
 
6930
 
 
6931
 
 
6932
SWIGINTERN PyObject *_wrap_Gauge_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
6933
  PyObject *resultobj = 0;
 
6934
  wxGauge *arg1 = (wxGauge *) 0 ;
 
6935
  wxWindow *arg2 = (wxWindow *) 0 ;
 
6936
  int arg3 = (int) -1 ;
 
6937
  int arg4 = (int) 100 ;
 
6938
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
6939
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
6940
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
6941
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
6942
  long arg7 = (long) wxGA_HORIZONTAL ;
 
6943
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
6944
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
6945
  wxString const &arg9_defvalue = wxPyGaugeNameStr ;
 
6946
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
6947
  bool result;
 
6948
  void *argp1 = 0 ;
 
6949
  int res1 = 0 ;
 
6950
  void *argp2 = 0 ;
 
6951
  int res2 = 0 ;
 
6952
  int val3 ;
 
6953
  int ecode3 = 0 ;
 
6954
  int val4 ;
 
6955
  int ecode4 = 0 ;
 
6956
  wxPoint temp5 ;
 
6957
  wxSize temp6 ;
 
6958
  long val7 ;
 
6959
  int ecode7 = 0 ;
 
6960
  void *argp8 = 0 ;
 
6961
  int res8 = 0 ;
 
6962
  bool temp9 = false ;
 
6963
  PyObject * obj0 = 0 ;
 
6964
  PyObject * obj1 = 0 ;
 
6965
  PyObject * obj2 = 0 ;
 
6966
  PyObject * obj3 = 0 ;
 
6967
  PyObject * obj4 = 0 ;
 
6968
  PyObject * obj5 = 0 ;
 
6969
  PyObject * obj6 = 0 ;
 
6970
  PyObject * obj7 = 0 ;
 
6971
  PyObject * obj8 = 0 ;
 
6972
  char *  kwnames[] = {
 
6973
    (char *) "self",(char *) "parent",(char *) "id",(char *) "range",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
6974
  };
 
6975
  
 
6976
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:Gauge_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
6977
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
6978
  if (!SWIG_IsOK(res1)) {
 
6979
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_Create" "', expected argument " "1"" of type '" "wxGauge *""'"); 
 
6980
  }
 
6981
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
6982
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
6983
  if (!SWIG_IsOK(res2)) {
 
6984
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gauge_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
6985
  }
 
6986
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
6987
  if (obj2) {
 
6988
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
6989
    if (!SWIG_IsOK(ecode3)) {
 
6990
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gauge_Create" "', expected argument " "3"" of type '" "int""'");
 
6991
    } 
 
6992
    arg3 = static_cast< int >(val3);
 
6993
  }
 
6994
  if (obj3) {
 
6995
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
6996
    if (!SWIG_IsOK(ecode4)) {
 
6997
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gauge_Create" "', expected argument " "4"" of type '" "int""'");
 
6998
    } 
 
6999
    arg4 = static_cast< int >(val4);
 
7000
  }
 
7001
  if (obj4) {
 
7002
    {
 
7003
      arg5 = &temp5;
 
7004
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
7005
    }
 
7006
  }
 
7007
  if (obj5) {
 
7008
    {
 
7009
      arg6 = &temp6;
 
7010
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
7011
    }
 
7012
  }
 
7013
  if (obj6) {
 
7014
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
7015
    if (!SWIG_IsOK(ecode7)) {
 
7016
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Gauge_Create" "', expected argument " "7"" of type '" "long""'");
 
7017
    } 
 
7018
    arg7 = static_cast< long >(val7);
 
7019
  }
 
7020
  if (obj7) {
 
7021
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
7022
    if (!SWIG_IsOK(res8)) {
 
7023
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Gauge_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
7024
    }
 
7025
    if (!argp8) {
 
7026
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gauge_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
7027
    }
 
7028
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
7029
  }
 
7030
  if (obj8) {
 
7031
    {
 
7032
      arg9 = wxString_in_helper(obj8);
 
7033
      if (arg9 == NULL) SWIG_fail;
 
7034
      temp9 = true;
 
7035
    }
 
7036
  }
 
7037
  {
 
7038
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7039
    result = (bool)(arg1)->Create(arg2,arg3,arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
7040
    wxPyEndAllowThreads(__tstate);
 
7041
    if (PyErr_Occurred()) SWIG_fail;
 
7042
  }
 
7043
  {
 
7044
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
7045
  }
 
7046
  {
 
7047
    if (temp9)
 
7048
    delete arg9;
 
7049
  }
 
7050
  return resultobj;
 
7051
fail:
 
7052
  {
 
7053
    if (temp9)
 
7054
    delete arg9;
 
7055
  }
 
7056
  return NULL;
 
7057
}
 
7058
 
 
7059
 
 
7060
SWIGINTERN PyObject *_wrap_Gauge_SetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
7061
  PyObject *resultobj = 0;
 
7062
  wxGauge *arg1 = (wxGauge *) 0 ;
 
7063
  int arg2 ;
 
7064
  void *argp1 = 0 ;
 
7065
  int res1 = 0 ;
 
7066
  int val2 ;
 
7067
  int ecode2 = 0 ;
 
7068
  PyObject * obj0 = 0 ;
 
7069
  PyObject * obj1 = 0 ;
 
7070
  char *  kwnames[] = {
 
7071
    (char *) "self",(char *) "range", NULL 
 
7072
  };
 
7073
  
 
7074
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetRange",kwnames,&obj0,&obj1)) SWIG_fail;
 
7075
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
7076
  if (!SWIG_IsOK(res1)) {
 
7077
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_SetRange" "', expected argument " "1"" of type '" "wxGauge *""'"); 
 
7078
  }
 
7079
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
7080
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
7081
  if (!SWIG_IsOK(ecode2)) {
 
7082
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gauge_SetRange" "', expected argument " "2"" of type '" "int""'");
 
7083
  } 
 
7084
  arg2 = static_cast< int >(val2);
 
7085
  {
 
7086
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7087
    (arg1)->SetRange(arg2);
 
7088
    wxPyEndAllowThreads(__tstate);
 
7089
    if (PyErr_Occurred()) SWIG_fail;
 
7090
  }
 
7091
  resultobj = SWIG_Py_Void();
 
7092
  return resultobj;
 
7093
fail:
 
7094
  return NULL;
 
7095
}
 
7096
 
 
7097
 
 
7098
SWIGINTERN PyObject *_wrap_Gauge_GetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7099
  PyObject *resultobj = 0;
 
7100
  wxGauge *arg1 = (wxGauge *) 0 ;
 
7101
  int result;
 
7102
  void *argp1 = 0 ;
 
7103
  int res1 = 0 ;
 
7104
  PyObject *swig_obj[1] ;
 
7105
  
 
7106
  if (!args) SWIG_fail;
 
7107
  swig_obj[0] = args;
 
7108
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
7109
  if (!SWIG_IsOK(res1)) {
 
7110
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_GetRange" "', expected argument " "1"" of type '" "wxGauge const *""'"); 
 
7111
  }
 
7112
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
7113
  {
 
7114
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7115
    result = (int)((wxGauge const *)arg1)->GetRange();
 
7116
    wxPyEndAllowThreads(__tstate);
 
7117
    if (PyErr_Occurred()) SWIG_fail;
 
7118
  }
 
7119
  resultobj = SWIG_From_int(static_cast< int >(result));
 
7120
  return resultobj;
 
7121
fail:
 
7122
  return NULL;
 
7123
}
 
7124
 
 
7125
 
 
7126
SWIGINTERN PyObject *_wrap_Gauge_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
7127
  PyObject *resultobj = 0;
 
7128
  wxGauge *arg1 = (wxGauge *) 0 ;
 
7129
  int arg2 ;
 
7130
  void *argp1 = 0 ;
 
7131
  int res1 = 0 ;
 
7132
  int val2 ;
 
7133
  int ecode2 = 0 ;
 
7134
  PyObject * obj0 = 0 ;
 
7135
  PyObject * obj1 = 0 ;
 
7136
  char *  kwnames[] = {
 
7137
    (char *) "self",(char *) "pos", NULL 
 
7138
  };
 
7139
  
 
7140
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
7141
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
7142
  if (!SWIG_IsOK(res1)) {
 
7143
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_SetValue" "', expected argument " "1"" of type '" "wxGauge *""'"); 
 
7144
  }
 
7145
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
7146
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
7147
  if (!SWIG_IsOK(ecode2)) {
 
7148
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gauge_SetValue" "', expected argument " "2"" of type '" "int""'");
 
7149
  } 
 
7150
  arg2 = static_cast< int >(val2);
 
7151
  {
 
7152
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7153
    (arg1)->SetValue(arg2);
 
7154
    wxPyEndAllowThreads(__tstate);
 
7155
    if (PyErr_Occurred()) SWIG_fail;
 
7156
  }
 
7157
  resultobj = SWIG_Py_Void();
 
7158
  return resultobj;
 
7159
fail:
 
7160
  return NULL;
 
7161
}
 
7162
 
 
7163
 
 
7164
SWIGINTERN PyObject *_wrap_Gauge_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7165
  PyObject *resultobj = 0;
 
7166
  wxGauge *arg1 = (wxGauge *) 0 ;
 
7167
  int result;
 
7168
  void *argp1 = 0 ;
 
7169
  int res1 = 0 ;
 
7170
  PyObject *swig_obj[1] ;
 
7171
  
 
7172
  if (!args) SWIG_fail;
 
7173
  swig_obj[0] = args;
 
7174
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
7175
  if (!SWIG_IsOK(res1)) {
 
7176
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_GetValue" "', expected argument " "1"" of type '" "wxGauge const *""'"); 
 
7177
  }
 
7178
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
7179
  {
 
7180
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7181
    result = (int)((wxGauge const *)arg1)->GetValue();
 
7182
    wxPyEndAllowThreads(__tstate);
 
7183
    if (PyErr_Occurred()) SWIG_fail;
 
7184
  }
 
7185
  resultobj = SWIG_From_int(static_cast< int >(result));
 
7186
  return resultobj;
 
7187
fail:
 
7188
  return NULL;
 
7189
}
 
7190
 
 
7191
 
 
7192
SWIGINTERN PyObject *_wrap_Gauge_Pulse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7193
  PyObject *resultobj = 0;
 
7194
  wxGauge *arg1 = (wxGauge *) 0 ;
 
7195
  void *argp1 = 0 ;
 
7196
  int res1 = 0 ;
 
7197
  PyObject *swig_obj[1] ;
 
7198
  
 
7199
  if (!args) SWIG_fail;
 
7200
  swig_obj[0] = args;
 
7201
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
7202
  if (!SWIG_IsOK(res1)) {
 
7203
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_Pulse" "', expected argument " "1"" of type '" "wxGauge *""'"); 
 
7204
  }
 
7205
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
7206
  {
 
7207
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7208
    (arg1)->Pulse();
 
7209
    wxPyEndAllowThreads(__tstate);
 
7210
    if (PyErr_Occurred()) SWIG_fail;
 
7211
  }
 
7212
  resultobj = SWIG_Py_Void();
 
7213
  return resultobj;
 
7214
fail:
 
7215
  return NULL;
 
7216
}
 
7217
 
 
7218
 
 
7219
SWIGINTERN PyObject *_wrap_Gauge_IsVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7220
  PyObject *resultobj = 0;
 
7221
  wxGauge *arg1 = (wxGauge *) 0 ;
 
7222
  bool result;
 
7223
  void *argp1 = 0 ;
 
7224
  int res1 = 0 ;
 
7225
  PyObject *swig_obj[1] ;
 
7226
  
 
7227
  if (!args) SWIG_fail;
 
7228
  swig_obj[0] = args;
 
7229
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
7230
  if (!SWIG_IsOK(res1)) {
 
7231
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_IsVertical" "', expected argument " "1"" of type '" "wxGauge const *""'"); 
 
7232
  }
 
7233
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
7234
  {
 
7235
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7236
    result = (bool)((wxGauge const *)arg1)->IsVertical();
 
7237
    wxPyEndAllowThreads(__tstate);
 
7238
    if (PyErr_Occurred()) SWIG_fail;
 
7239
  }
 
7240
  {
 
7241
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
7242
  }
 
7243
  return resultobj;
 
7244
fail:
 
7245
  return NULL;
 
7246
}
 
7247
 
 
7248
 
 
7249
SWIGINTERN PyObject *_wrap_Gauge_SetShadowWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
7250
  PyObject *resultobj = 0;
 
7251
  wxGauge *arg1 = (wxGauge *) 0 ;
 
7252
  int arg2 ;
 
7253
  void *argp1 = 0 ;
 
7254
  int res1 = 0 ;
 
7255
  int val2 ;
 
7256
  int ecode2 = 0 ;
 
7257
  PyObject * obj0 = 0 ;
 
7258
  PyObject * obj1 = 0 ;
 
7259
  char *  kwnames[] = {
 
7260
    (char *) "self",(char *) "w", NULL 
 
7261
  };
 
7262
  
 
7263
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetShadowWidth",kwnames,&obj0,&obj1)) SWIG_fail;
 
7264
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
7265
  if (!SWIG_IsOK(res1)) {
 
7266
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_SetShadowWidth" "', expected argument " "1"" of type '" "wxGauge *""'"); 
 
7267
  }
 
7268
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
7269
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
7270
  if (!SWIG_IsOK(ecode2)) {
 
7271
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gauge_SetShadowWidth" "', expected argument " "2"" of type '" "int""'");
 
7272
  } 
 
7273
  arg2 = static_cast< int >(val2);
 
7274
  {
 
7275
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7276
    (arg1)->SetShadowWidth(arg2);
 
7277
    wxPyEndAllowThreads(__tstate);
 
7278
    if (PyErr_Occurred()) SWIG_fail;
 
7279
  }
 
7280
  resultobj = SWIG_Py_Void();
 
7281
  return resultobj;
 
7282
fail:
 
7283
  return NULL;
 
7284
}
 
7285
 
 
7286
 
 
7287
SWIGINTERN PyObject *_wrap_Gauge_GetShadowWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7288
  PyObject *resultobj = 0;
 
7289
  wxGauge *arg1 = (wxGauge *) 0 ;
 
7290
  int result;
 
7291
  void *argp1 = 0 ;
 
7292
  int res1 = 0 ;
 
7293
  PyObject *swig_obj[1] ;
 
7294
  
 
7295
  if (!args) SWIG_fail;
 
7296
  swig_obj[0] = args;
 
7297
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
7298
  if (!SWIG_IsOK(res1)) {
 
7299
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_GetShadowWidth" "', expected argument " "1"" of type '" "wxGauge const *""'"); 
 
7300
  }
 
7301
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
7302
  {
 
7303
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7304
    result = (int)((wxGauge const *)arg1)->GetShadowWidth();
 
7305
    wxPyEndAllowThreads(__tstate);
 
7306
    if (PyErr_Occurred()) SWIG_fail;
 
7307
  }
 
7308
  resultobj = SWIG_From_int(static_cast< int >(result));
 
7309
  return resultobj;
 
7310
fail:
 
7311
  return NULL;
 
7312
}
 
7313
 
 
7314
 
 
7315
SWIGINTERN PyObject *_wrap_Gauge_SetBezelFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
7316
  PyObject *resultobj = 0;
 
7317
  wxGauge *arg1 = (wxGauge *) 0 ;
 
7318
  int arg2 ;
 
7319
  void *argp1 = 0 ;
 
7320
  int res1 = 0 ;
 
7321
  int val2 ;
 
7322
  int ecode2 = 0 ;
 
7323
  PyObject * obj0 = 0 ;
 
7324
  PyObject * obj1 = 0 ;
 
7325
  char *  kwnames[] = {
 
7326
    (char *) "self",(char *) "w", NULL 
 
7327
  };
 
7328
  
 
7329
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Gauge_SetBezelFace",kwnames,&obj0,&obj1)) SWIG_fail;
 
7330
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
7331
  if (!SWIG_IsOK(res1)) {
 
7332
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_SetBezelFace" "', expected argument " "1"" of type '" "wxGauge *""'"); 
 
7333
  }
 
7334
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
7335
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
7336
  if (!SWIG_IsOK(ecode2)) {
 
7337
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gauge_SetBezelFace" "', expected argument " "2"" of type '" "int""'");
 
7338
  } 
 
7339
  arg2 = static_cast< int >(val2);
 
7340
  {
 
7341
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7342
    (arg1)->SetBezelFace(arg2);
 
7343
    wxPyEndAllowThreads(__tstate);
 
7344
    if (PyErr_Occurred()) SWIG_fail;
 
7345
  }
 
7346
  resultobj = SWIG_Py_Void();
 
7347
  return resultobj;
 
7348
fail:
 
7349
  return NULL;
 
7350
}
 
7351
 
 
7352
 
 
7353
SWIGINTERN PyObject *_wrap_Gauge_GetBezelFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7354
  PyObject *resultobj = 0;
 
7355
  wxGauge *arg1 = (wxGauge *) 0 ;
 
7356
  int result;
 
7357
  void *argp1 = 0 ;
 
7358
  int res1 = 0 ;
 
7359
  PyObject *swig_obj[1] ;
 
7360
  
 
7361
  if (!args) SWIG_fail;
 
7362
  swig_obj[0] = args;
 
7363
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGauge, 0 |  0 );
 
7364
  if (!SWIG_IsOK(res1)) {
 
7365
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gauge_GetBezelFace" "', expected argument " "1"" of type '" "wxGauge const *""'"); 
 
7366
  }
 
7367
  arg1 = reinterpret_cast< wxGauge * >(argp1);
 
7368
  {
 
7369
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7370
    result = (int)((wxGauge const *)arg1)->GetBezelFace();
 
7371
    wxPyEndAllowThreads(__tstate);
 
7372
    if (PyErr_Occurred()) SWIG_fail;
 
7373
  }
 
7374
  resultobj = SWIG_From_int(static_cast< int >(result));
 
7375
  return resultobj;
 
7376
fail:
 
7377
  return NULL;
 
7378
}
 
7379
 
 
7380
 
 
7381
SWIGINTERN PyObject *_wrap_Gauge_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
7382
  PyObject *resultobj = 0;
 
7383
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
7384
  SwigValueWrapper<wxVisualAttributes > result;
 
7385
  int val1 ;
 
7386
  int ecode1 = 0 ;
 
7387
  PyObject * obj0 = 0 ;
 
7388
  char *  kwnames[] = {
 
7389
    (char *) "variant", NULL 
 
7390
  };
 
7391
  
 
7392
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Gauge_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
7393
  if (obj0) {
 
7394
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
7395
    if (!SWIG_IsOK(ecode1)) {
 
7396
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gauge_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
7397
    } 
 
7398
    arg1 = static_cast< wxWindowVariant >(val1);
 
7399
  }
 
7400
  {
 
7401
    if (!wxPyCheckForApp()) SWIG_fail;
 
7402
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7403
    result = wxGauge::GetClassDefaultAttributes(arg1);
 
7404
    wxPyEndAllowThreads(__tstate);
 
7405
    if (PyErr_Occurred()) SWIG_fail;
 
7406
  }
 
7407
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
7408
  return resultobj;
 
7409
fail:
 
7410
  return NULL;
 
7411
}
 
7412
 
 
7413
 
 
7414
SWIGINTERN PyObject *Gauge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7415
  PyObject *obj;
 
7416
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
7417
  SWIG_TypeNewClientData(SWIGTYPE_p_wxGauge, SWIG_NewClientData(obj));
 
7418
  return SWIG_Py_Void();
 
7419
}
 
7420
 
 
7421
SWIGINTERN PyObject *Gauge_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7422
  return SWIG_Python_InitShadowInstance(args);
 
7423
}
 
7424
 
 
7425
SWIGINTERN int StaticBitmapNameStr_set(PyObject *) {
 
7426
  SWIG_Error(SWIG_AttributeError,"Variable StaticBitmapNameStr is read-only.");
 
7427
  return 1;
 
7428
}
 
7429
 
 
7430
 
 
7431
SWIGINTERN PyObject *StaticBitmapNameStr_get(void) {
 
7432
  PyObject *pyobj = 0;
 
7433
  
 
7434
  {
 
7435
#if wxUSE_UNICODE
 
7436
    pyobj = PyUnicode_FromWideChar((&wxPyStaticBitmapNameStr)->c_str(), (&wxPyStaticBitmapNameStr)->Len());
 
7437
#else
 
7438
    pyobj = PyString_FromStringAndSize((&wxPyStaticBitmapNameStr)->c_str(), (&wxPyStaticBitmapNameStr)->Len());
 
7439
#endif
 
7440
  }
 
7441
  return pyobj;
 
7442
}
 
7443
 
 
7444
 
 
7445
SWIGINTERN int StaticBoxNameStr_set(PyObject *) {
 
7446
  SWIG_Error(SWIG_AttributeError,"Variable StaticBoxNameStr is read-only.");
 
7447
  return 1;
 
7448
}
 
7449
 
 
7450
 
 
7451
SWIGINTERN PyObject *StaticBoxNameStr_get(void) {
 
7452
  PyObject *pyobj = 0;
 
7453
  
 
7454
  {
 
7455
#if wxUSE_UNICODE
 
7456
    pyobj = PyUnicode_FromWideChar((&wxPyStaticBoxNameStr)->c_str(), (&wxPyStaticBoxNameStr)->Len());
 
7457
#else
 
7458
    pyobj = PyString_FromStringAndSize((&wxPyStaticBoxNameStr)->c_str(), (&wxPyStaticBoxNameStr)->Len());
 
7459
#endif
 
7460
  }
 
7461
  return pyobj;
 
7462
}
 
7463
 
 
7464
 
 
7465
SWIGINTERN int StaticTextNameStr_set(PyObject *) {
 
7466
  SWIG_Error(SWIG_AttributeError,"Variable StaticTextNameStr is read-only.");
 
7467
  return 1;
 
7468
}
 
7469
 
 
7470
 
 
7471
SWIGINTERN PyObject *StaticTextNameStr_get(void) {
 
7472
  PyObject *pyobj = 0;
 
7473
  
 
7474
  {
 
7475
#if wxUSE_UNICODE
 
7476
    pyobj = PyUnicode_FromWideChar((&wxPyStaticTextNameStr)->c_str(), (&wxPyStaticTextNameStr)->Len());
 
7477
#else
 
7478
    pyobj = PyString_FromStringAndSize((&wxPyStaticTextNameStr)->c_str(), (&wxPyStaticTextNameStr)->Len());
 
7479
#endif
 
7480
  }
 
7481
  return pyobj;
 
7482
}
 
7483
 
 
7484
 
 
7485
SWIGINTERN int StaticLineNameStr_set(PyObject *) {
 
7486
  SWIG_Error(SWIG_AttributeError,"Variable StaticLineNameStr is read-only.");
 
7487
  return 1;
 
7488
}
 
7489
 
 
7490
 
 
7491
SWIGINTERN PyObject *StaticLineNameStr_get(void) {
 
7492
  PyObject *pyobj = 0;
 
7493
  
 
7494
  {
 
7495
#if wxUSE_UNICODE
 
7496
    pyobj = PyUnicode_FromWideChar((&wxPyStaticLineNameStr)->c_str(), (&wxPyStaticLineNameStr)->Len());
 
7497
#else
 
7498
    pyobj = PyString_FromStringAndSize((&wxPyStaticLineNameStr)->c_str(), (&wxPyStaticLineNameStr)->Len());
 
7499
#endif
 
7500
  }
 
7501
  return pyobj;
 
7502
}
 
7503
 
 
7504
 
 
7505
SWIGINTERN PyObject *_wrap_new_StaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
7506
  PyObject *resultobj = 0;
 
7507
  wxWindow *arg1 = (wxWindow *) 0 ;
 
7508
  int arg2 = (int) -1 ;
 
7509
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
7510
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
7511
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
7512
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
7513
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
7514
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
7515
  long arg6 = (long) 0 ;
 
7516
  wxString const &arg7_defvalue = wxPyStaticBoxNameStr ;
 
7517
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
7518
  wxStaticBox *result = 0 ;
 
7519
  void *argp1 = 0 ;
 
7520
  int res1 = 0 ;
 
7521
  int val2 ;
 
7522
  int ecode2 = 0 ;
 
7523
  bool temp3 = false ;
 
7524
  wxPoint temp4 ;
 
7525
  wxSize temp5 ;
 
7526
  long val6 ;
 
7527
  int ecode6 = 0 ;
 
7528
  bool temp7 = false ;
 
7529
  PyObject * obj0 = 0 ;
 
7530
  PyObject * obj1 = 0 ;
 
7531
  PyObject * obj2 = 0 ;
 
7532
  PyObject * obj3 = 0 ;
 
7533
  PyObject * obj4 = 0 ;
 
7534
  PyObject * obj5 = 0 ;
 
7535
  PyObject * obj6 = 0 ;
 
7536
  char *  kwnames[] = {
 
7537
    (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
7538
  };
 
7539
  
 
7540
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_StaticBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
7541
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
7542
  if (!SWIG_IsOK(res1)) {
 
7543
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBox" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
7544
  }
 
7545
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
7546
  if (obj1) {
 
7547
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
7548
    if (!SWIG_IsOK(ecode2)) {
 
7549
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBox" "', expected argument " "2"" of type '" "int""'");
 
7550
    } 
 
7551
    arg2 = static_cast< int >(val2);
 
7552
  }
 
7553
  if (obj2) {
 
7554
    {
 
7555
      arg3 = wxString_in_helper(obj2);
 
7556
      if (arg3 == NULL) SWIG_fail;
 
7557
      temp3 = true;
 
7558
    }
 
7559
  }
 
7560
  if (obj3) {
 
7561
    {
 
7562
      arg4 = &temp4;
 
7563
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
7564
    }
 
7565
  }
 
7566
  if (obj4) {
 
7567
    {
 
7568
      arg5 = &temp5;
 
7569
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
7570
    }
 
7571
  }
 
7572
  if (obj5) {
 
7573
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
7574
    if (!SWIG_IsOK(ecode6)) {
 
7575
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_StaticBox" "', expected argument " "6"" of type '" "long""'");
 
7576
    } 
 
7577
    arg6 = static_cast< long >(val6);
 
7578
  }
 
7579
  if (obj6) {
 
7580
    {
 
7581
      arg7 = wxString_in_helper(obj6);
 
7582
      if (arg7 == NULL) SWIG_fail;
 
7583
      temp7 = true;
 
7584
    }
 
7585
  }
 
7586
  {
 
7587
    if (!wxPyCheckForApp()) SWIG_fail;
 
7588
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7589
    result = (wxStaticBox *)new wxStaticBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
7590
    wxPyEndAllowThreads(__tstate);
 
7591
    if (PyErr_Occurred()) SWIG_fail;
 
7592
  }
 
7593
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBox, SWIG_POINTER_NEW |  0 );
 
7594
  {
 
7595
    if (temp3)
 
7596
    delete arg3;
 
7597
  }
 
7598
  {
 
7599
    if (temp7)
 
7600
    delete arg7;
 
7601
  }
 
7602
  return resultobj;
 
7603
fail:
 
7604
  {
 
7605
    if (temp3)
 
7606
    delete arg3;
 
7607
  }
 
7608
  {
 
7609
    if (temp7)
 
7610
    delete arg7;
 
7611
  }
 
7612
  return NULL;
 
7613
}
 
7614
 
 
7615
 
 
7616
SWIGINTERN PyObject *_wrap_new_PreStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7617
  PyObject *resultobj = 0;
 
7618
  wxStaticBox *result = 0 ;
 
7619
  
 
7620
  if (!SWIG_Python_UnpackTuple(args,"new_PreStaticBox",0,0,0)) SWIG_fail;
 
7621
  {
 
7622
    if (!wxPyCheckForApp()) SWIG_fail;
 
7623
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7624
    result = (wxStaticBox *)new wxStaticBox();
 
7625
    wxPyEndAllowThreads(__tstate);
 
7626
    if (PyErr_Occurred()) SWIG_fail;
 
7627
  }
 
7628
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBox, SWIG_POINTER_OWN |  0 );
 
7629
  return resultobj;
 
7630
fail:
 
7631
  return NULL;
 
7632
}
 
7633
 
 
7634
 
 
7635
SWIGINTERN PyObject *_wrap_StaticBox_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
7636
  PyObject *resultobj = 0;
 
7637
  wxStaticBox *arg1 = (wxStaticBox *) 0 ;
 
7638
  wxWindow *arg2 = (wxWindow *) 0 ;
 
7639
  int arg3 = (int) -1 ;
 
7640
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
7641
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
7642
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
7643
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
7644
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
7645
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
7646
  long arg7 = (long) 0 ;
 
7647
  wxString const &arg8_defvalue = wxPyStaticBoxNameStr ;
 
7648
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
7649
  bool result;
 
7650
  void *argp1 = 0 ;
 
7651
  int res1 = 0 ;
 
7652
  void *argp2 = 0 ;
 
7653
  int res2 = 0 ;
 
7654
  int val3 ;
 
7655
  int ecode3 = 0 ;
 
7656
  bool temp4 = false ;
 
7657
  wxPoint temp5 ;
 
7658
  wxSize temp6 ;
 
7659
  long val7 ;
 
7660
  int ecode7 = 0 ;
 
7661
  bool temp8 = false ;
 
7662
  PyObject * obj0 = 0 ;
 
7663
  PyObject * obj1 = 0 ;
 
7664
  PyObject * obj2 = 0 ;
 
7665
  PyObject * obj3 = 0 ;
 
7666
  PyObject * obj4 = 0 ;
 
7667
  PyObject * obj5 = 0 ;
 
7668
  PyObject * obj6 = 0 ;
 
7669
  PyObject * obj7 = 0 ;
 
7670
  char *  kwnames[] = {
 
7671
    (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
7672
  };
 
7673
  
 
7674
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:StaticBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
7675
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 |  0 );
 
7676
  if (!SWIG_IsOK(res1)) {
 
7677
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBox_Create" "', expected argument " "1"" of type '" "wxStaticBox *""'"); 
 
7678
  }
 
7679
  arg1 = reinterpret_cast< wxStaticBox * >(argp1);
 
7680
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
7681
  if (!SWIG_IsOK(res2)) {
 
7682
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StaticBox_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
7683
  }
 
7684
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
7685
  if (obj2) {
 
7686
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
7687
    if (!SWIG_IsOK(ecode3)) {
 
7688
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StaticBox_Create" "', expected argument " "3"" of type '" "int""'");
 
7689
    } 
 
7690
    arg3 = static_cast< int >(val3);
 
7691
  }
 
7692
  if (obj3) {
 
7693
    {
 
7694
      arg4 = wxString_in_helper(obj3);
 
7695
      if (arg4 == NULL) SWIG_fail;
 
7696
      temp4 = true;
 
7697
    }
 
7698
  }
 
7699
  if (obj4) {
 
7700
    {
 
7701
      arg5 = &temp5;
 
7702
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
7703
    }
 
7704
  }
 
7705
  if (obj5) {
 
7706
    {
 
7707
      arg6 = &temp6;
 
7708
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
7709
    }
 
7710
  }
 
7711
  if (obj6) {
 
7712
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
7713
    if (!SWIG_IsOK(ecode7)) {
 
7714
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "StaticBox_Create" "', expected argument " "7"" of type '" "long""'");
 
7715
    } 
 
7716
    arg7 = static_cast< long >(val7);
 
7717
  }
 
7718
  if (obj7) {
 
7719
    {
 
7720
      arg8 = wxString_in_helper(obj7);
 
7721
      if (arg8 == NULL) SWIG_fail;
 
7722
      temp8 = true;
 
7723
    }
 
7724
  }
 
7725
  {
 
7726
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7727
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
 
7728
    wxPyEndAllowThreads(__tstate);
 
7729
    if (PyErr_Occurred()) SWIG_fail;
 
7730
  }
 
7731
  {
 
7732
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
7733
  }
 
7734
  {
 
7735
    if (temp4)
 
7736
    delete arg4;
 
7737
  }
 
7738
  {
 
7739
    if (temp8)
 
7740
    delete arg8;
 
7741
  }
 
7742
  return resultobj;
 
7743
fail:
 
7744
  {
 
7745
    if (temp4)
 
7746
    delete arg4;
 
7747
  }
 
7748
  {
 
7749
    if (temp8)
 
7750
    delete arg8;
 
7751
  }
 
7752
  return NULL;
 
7753
}
 
7754
 
 
7755
 
 
7756
SWIGINTERN PyObject *_wrap_StaticBox_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
7757
  PyObject *resultobj = 0;
 
7758
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
7759
  SwigValueWrapper<wxVisualAttributes > result;
 
7760
  int val1 ;
 
7761
  int ecode1 = 0 ;
 
7762
  PyObject * obj0 = 0 ;
 
7763
  char *  kwnames[] = {
 
7764
    (char *) "variant", NULL 
 
7765
  };
 
7766
  
 
7767
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticBox_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
7768
  if (obj0) {
 
7769
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
7770
    if (!SWIG_IsOK(ecode1)) {
 
7771
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StaticBox_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
7772
    } 
 
7773
    arg1 = static_cast< wxWindowVariant >(val1);
 
7774
  }
 
7775
  {
 
7776
    if (!wxPyCheckForApp()) SWIG_fail;
 
7777
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7778
    result = wxStaticBox::GetClassDefaultAttributes(arg1);
 
7779
    wxPyEndAllowThreads(__tstate);
 
7780
    if (PyErr_Occurred()) SWIG_fail;
 
7781
  }
 
7782
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
7783
  return resultobj;
 
7784
fail:
 
7785
  return NULL;
 
7786
}
 
7787
 
 
7788
 
 
7789
SWIGINTERN PyObject *StaticBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7790
  PyObject *obj;
 
7791
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
7792
  SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBox, SWIG_NewClientData(obj));
 
7793
  return SWIG_Py_Void();
 
7794
}
 
7795
 
 
7796
SWIGINTERN PyObject *StaticBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7797
  return SWIG_Python_InitShadowInstance(args);
 
7798
}
 
7799
 
 
7800
SWIGINTERN PyObject *_wrap_new_StaticLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
7801
  PyObject *resultobj = 0;
 
7802
  wxWindow *arg1 = (wxWindow *) 0 ;
 
7803
  int arg2 = (int) -1 ;
 
7804
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
7805
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
7806
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
7807
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
7808
  long arg5 = (long) wxLI_HORIZONTAL ;
 
7809
  wxString const &arg6_defvalue = wxPyStaticLineNameStr ;
 
7810
  wxString *arg6 = (wxString *) &arg6_defvalue ;
 
7811
  wxStaticLine *result = 0 ;
 
7812
  void *argp1 = 0 ;
 
7813
  int res1 = 0 ;
 
7814
  int val2 ;
 
7815
  int ecode2 = 0 ;
 
7816
  wxPoint temp3 ;
 
7817
  wxSize temp4 ;
 
7818
  long val5 ;
 
7819
  int ecode5 = 0 ;
 
7820
  bool temp6 = false ;
 
7821
  PyObject * obj0 = 0 ;
 
7822
  PyObject * obj1 = 0 ;
 
7823
  PyObject * obj2 = 0 ;
 
7824
  PyObject * obj3 = 0 ;
 
7825
  PyObject * obj4 = 0 ;
 
7826
  PyObject * obj5 = 0 ;
 
7827
  char *  kwnames[] = {
 
7828
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
7829
  };
 
7830
  
 
7831
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_StaticLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
7832
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
7833
  if (!SWIG_IsOK(res1)) {
 
7834
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticLine" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
7835
  }
 
7836
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
7837
  if (obj1) {
 
7838
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
7839
    if (!SWIG_IsOK(ecode2)) {
 
7840
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticLine" "', expected argument " "2"" of type '" "int""'");
 
7841
    } 
 
7842
    arg2 = static_cast< int >(val2);
 
7843
  }
 
7844
  if (obj2) {
 
7845
    {
 
7846
      arg3 = &temp3;
 
7847
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
7848
    }
 
7849
  }
 
7850
  if (obj3) {
 
7851
    {
 
7852
      arg4 = &temp4;
 
7853
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
7854
    }
 
7855
  }
 
7856
  if (obj4) {
 
7857
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
7858
    if (!SWIG_IsOK(ecode5)) {
 
7859
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_StaticLine" "', expected argument " "5"" of type '" "long""'");
 
7860
    } 
 
7861
    arg5 = static_cast< long >(val5);
 
7862
  }
 
7863
  if (obj5) {
 
7864
    {
 
7865
      arg6 = wxString_in_helper(obj5);
 
7866
      if (arg6 == NULL) SWIG_fail;
 
7867
      temp6 = true;
 
7868
    }
 
7869
  }
 
7870
  {
 
7871
    if (!wxPyCheckForApp()) SWIG_fail;
 
7872
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7873
    result = (wxStaticLine *)new wxStaticLine(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
 
7874
    wxPyEndAllowThreads(__tstate);
 
7875
    if (PyErr_Occurred()) SWIG_fail;
 
7876
  }
 
7877
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticLine, SWIG_POINTER_NEW |  0 );
 
7878
  {
 
7879
    if (temp6)
 
7880
    delete arg6;
 
7881
  }
 
7882
  return resultobj;
 
7883
fail:
 
7884
  {
 
7885
    if (temp6)
 
7886
    delete arg6;
 
7887
  }
 
7888
  return NULL;
 
7889
}
 
7890
 
 
7891
 
 
7892
SWIGINTERN PyObject *_wrap_new_PreStaticLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
7893
  PyObject *resultobj = 0;
 
7894
  wxStaticLine *result = 0 ;
 
7895
  
 
7896
  if (!SWIG_Python_UnpackTuple(args,"new_PreStaticLine",0,0,0)) SWIG_fail;
 
7897
  {
 
7898
    if (!wxPyCheckForApp()) SWIG_fail;
 
7899
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7900
    result = (wxStaticLine *)new wxStaticLine();
 
7901
    wxPyEndAllowThreads(__tstate);
 
7902
    if (PyErr_Occurred()) SWIG_fail;
 
7903
  }
 
7904
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticLine, SWIG_POINTER_OWN |  0 );
 
7905
  return resultobj;
 
7906
fail:
 
7907
  return NULL;
 
7908
}
 
7909
 
 
7910
 
 
7911
SWIGINTERN PyObject *_wrap_StaticLine_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
7912
  PyObject *resultobj = 0;
 
7913
  wxStaticLine *arg1 = (wxStaticLine *) 0 ;
 
7914
  wxWindow *arg2 = (wxWindow *) 0 ;
 
7915
  int arg3 = (int) -1 ;
 
7916
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
7917
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
7918
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
7919
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
7920
  long arg6 = (long) wxLI_HORIZONTAL ;
 
7921
  wxString const &arg7_defvalue = wxPyStaticLineNameStr ;
 
7922
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
7923
  bool result;
 
7924
  void *argp1 = 0 ;
 
7925
  int res1 = 0 ;
 
7926
  void *argp2 = 0 ;
 
7927
  int res2 = 0 ;
 
7928
  int val3 ;
 
7929
  int ecode3 = 0 ;
 
7930
  wxPoint temp4 ;
 
7931
  wxSize temp5 ;
 
7932
  long val6 ;
 
7933
  int ecode6 = 0 ;
 
7934
  bool temp7 = false ;
 
7935
  PyObject * obj0 = 0 ;
 
7936
  PyObject * obj1 = 0 ;
 
7937
  PyObject * obj2 = 0 ;
 
7938
  PyObject * obj3 = 0 ;
 
7939
  PyObject * obj4 = 0 ;
 
7940
  PyObject * obj5 = 0 ;
 
7941
  PyObject * obj6 = 0 ;
 
7942
  char *  kwnames[] = {
 
7943
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
7944
  };
 
7945
  
 
7946
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:StaticLine_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
7947
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticLine, 0 |  0 );
 
7948
  if (!SWIG_IsOK(res1)) {
 
7949
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticLine_Create" "', expected argument " "1"" of type '" "wxStaticLine *""'"); 
 
7950
  }
 
7951
  arg1 = reinterpret_cast< wxStaticLine * >(argp1);
 
7952
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
7953
  if (!SWIG_IsOK(res2)) {
 
7954
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StaticLine_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
7955
  }
 
7956
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
7957
  if (obj2) {
 
7958
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
7959
    if (!SWIG_IsOK(ecode3)) {
 
7960
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StaticLine_Create" "', expected argument " "3"" of type '" "int""'");
 
7961
    } 
 
7962
    arg3 = static_cast< int >(val3);
 
7963
  }
 
7964
  if (obj3) {
 
7965
    {
 
7966
      arg4 = &temp4;
 
7967
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
7968
    }
 
7969
  }
 
7970
  if (obj4) {
 
7971
    {
 
7972
      arg5 = &temp5;
 
7973
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
7974
    }
 
7975
  }
 
7976
  if (obj5) {
 
7977
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
7978
    if (!SWIG_IsOK(ecode6)) {
 
7979
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "StaticLine_Create" "', expected argument " "6"" of type '" "long""'");
 
7980
    } 
 
7981
    arg6 = static_cast< long >(val6);
 
7982
  }
 
7983
  if (obj6) {
 
7984
    {
 
7985
      arg7 = wxString_in_helper(obj6);
 
7986
      if (arg7 == NULL) SWIG_fail;
 
7987
      temp7 = true;
 
7988
    }
 
7989
  }
 
7990
  {
 
7991
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
7992
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
7993
    wxPyEndAllowThreads(__tstate);
 
7994
    if (PyErr_Occurred()) SWIG_fail;
 
7995
  }
 
7996
  {
 
7997
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
7998
  }
 
7999
  {
 
8000
    if (temp7)
 
8001
    delete arg7;
 
8002
  }
 
8003
  return resultobj;
 
8004
fail:
 
8005
  {
 
8006
    if (temp7)
 
8007
    delete arg7;
 
8008
  }
 
8009
  return NULL;
 
8010
}
 
8011
 
 
8012
 
 
8013
SWIGINTERN PyObject *_wrap_StaticLine_IsVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8014
  PyObject *resultobj = 0;
 
8015
  wxStaticLine *arg1 = (wxStaticLine *) 0 ;
 
8016
  bool result;
 
8017
  void *argp1 = 0 ;
 
8018
  int res1 = 0 ;
 
8019
  PyObject *swig_obj[1] ;
 
8020
  
 
8021
  if (!args) SWIG_fail;
 
8022
  swig_obj[0] = args;
 
8023
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticLine, 0 |  0 );
 
8024
  if (!SWIG_IsOK(res1)) {
 
8025
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticLine_IsVertical" "', expected argument " "1"" of type '" "wxStaticLine const *""'"); 
 
8026
  }
 
8027
  arg1 = reinterpret_cast< wxStaticLine * >(argp1);
 
8028
  {
 
8029
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8030
    result = (bool)((wxStaticLine const *)arg1)->IsVertical();
 
8031
    wxPyEndAllowThreads(__tstate);
 
8032
    if (PyErr_Occurred()) SWIG_fail;
 
8033
  }
 
8034
  {
 
8035
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
8036
  }
 
8037
  return resultobj;
 
8038
fail:
 
8039
  return NULL;
 
8040
}
 
8041
 
 
8042
 
 
8043
SWIGINTERN PyObject *_wrap_StaticLine_GetDefaultSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8044
  PyObject *resultobj = 0;
 
8045
  int result;
 
8046
  
 
8047
  if (!SWIG_Python_UnpackTuple(args,"StaticLine_GetDefaultSize",0,0,0)) SWIG_fail;
 
8048
  {
 
8049
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8050
    result = (int)wxStaticLine::GetDefaultSize();
 
8051
    wxPyEndAllowThreads(__tstate);
 
8052
    if (PyErr_Occurred()) SWIG_fail;
 
8053
  }
 
8054
  resultobj = SWIG_From_int(static_cast< int >(result));
 
8055
  return resultobj;
 
8056
fail:
 
8057
  return NULL;
 
8058
}
 
8059
 
 
8060
 
 
8061
SWIGINTERN PyObject *_wrap_StaticLine_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8062
  PyObject *resultobj = 0;
 
8063
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
8064
  SwigValueWrapper<wxVisualAttributes > result;
 
8065
  int val1 ;
 
8066
  int ecode1 = 0 ;
 
8067
  PyObject * obj0 = 0 ;
 
8068
  char *  kwnames[] = {
 
8069
    (char *) "variant", NULL 
 
8070
  };
 
8071
  
 
8072
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticLine_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
8073
  if (obj0) {
 
8074
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
8075
    if (!SWIG_IsOK(ecode1)) {
 
8076
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StaticLine_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
8077
    } 
 
8078
    arg1 = static_cast< wxWindowVariant >(val1);
 
8079
  }
 
8080
  {
 
8081
    if (!wxPyCheckForApp()) SWIG_fail;
 
8082
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8083
    result = wxStaticLine::GetClassDefaultAttributes(arg1);
 
8084
    wxPyEndAllowThreads(__tstate);
 
8085
    if (PyErr_Occurred()) SWIG_fail;
 
8086
  }
 
8087
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
8088
  return resultobj;
 
8089
fail:
 
8090
  return NULL;
 
8091
}
 
8092
 
 
8093
 
 
8094
SWIGINTERN PyObject *StaticLine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8095
  PyObject *obj;
 
8096
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
8097
  SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticLine, SWIG_NewClientData(obj));
 
8098
  return SWIG_Py_Void();
 
8099
}
 
8100
 
 
8101
SWIGINTERN PyObject *StaticLine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8102
  return SWIG_Python_InitShadowInstance(args);
 
8103
}
 
8104
 
 
8105
SWIGINTERN PyObject *_wrap_new_StaticText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8106
  PyObject *resultobj = 0;
 
8107
  wxWindow *arg1 = (wxWindow *) 0 ;
 
8108
  int arg2 = (int) -1 ;
 
8109
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
8110
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
8111
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
8112
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
8113
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
8114
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
8115
  long arg6 = (long) 0 ;
 
8116
  wxString const &arg7_defvalue = wxPyStaticTextNameStr ;
 
8117
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
8118
  wxStaticText *result = 0 ;
 
8119
  void *argp1 = 0 ;
 
8120
  int res1 = 0 ;
 
8121
  int val2 ;
 
8122
  int ecode2 = 0 ;
 
8123
  bool temp3 = false ;
 
8124
  wxPoint temp4 ;
 
8125
  wxSize temp5 ;
 
8126
  long val6 ;
 
8127
  int ecode6 = 0 ;
 
8128
  bool temp7 = false ;
 
8129
  PyObject * obj0 = 0 ;
 
8130
  PyObject * obj1 = 0 ;
 
8131
  PyObject * obj2 = 0 ;
 
8132
  PyObject * obj3 = 0 ;
 
8133
  PyObject * obj4 = 0 ;
 
8134
  PyObject * obj5 = 0 ;
 
8135
  PyObject * obj6 = 0 ;
 
8136
  char *  kwnames[] = {
 
8137
    (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
8138
  };
 
8139
  
 
8140
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_StaticText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
8141
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
8142
  if (!SWIG_IsOK(res1)) {
 
8143
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticText" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
8144
  }
 
8145
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
8146
  if (obj1) {
 
8147
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
8148
    if (!SWIG_IsOK(ecode2)) {
 
8149
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticText" "', expected argument " "2"" of type '" "int""'");
 
8150
    } 
 
8151
    arg2 = static_cast< int >(val2);
 
8152
  }
 
8153
  if (obj2) {
 
8154
    {
 
8155
      arg3 = wxString_in_helper(obj2);
 
8156
      if (arg3 == NULL) SWIG_fail;
 
8157
      temp3 = true;
 
8158
    }
 
8159
  }
 
8160
  if (obj3) {
 
8161
    {
 
8162
      arg4 = &temp4;
 
8163
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
8164
    }
 
8165
  }
 
8166
  if (obj4) {
 
8167
    {
 
8168
      arg5 = &temp5;
 
8169
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
8170
    }
 
8171
  }
 
8172
  if (obj5) {
 
8173
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
8174
    if (!SWIG_IsOK(ecode6)) {
 
8175
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_StaticText" "', expected argument " "6"" of type '" "long""'");
 
8176
    } 
 
8177
    arg6 = static_cast< long >(val6);
 
8178
  }
 
8179
  if (obj6) {
 
8180
    {
 
8181
      arg7 = wxString_in_helper(obj6);
 
8182
      if (arg7 == NULL) SWIG_fail;
 
8183
      temp7 = true;
 
8184
    }
 
8185
  }
 
8186
  {
 
8187
    if (!wxPyCheckForApp()) SWIG_fail;
 
8188
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8189
    result = (wxStaticText *)new wxStaticText(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
8190
    wxPyEndAllowThreads(__tstate);
 
8191
    if (PyErr_Occurred()) SWIG_fail;
 
8192
  }
 
8193
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticText, SWIG_POINTER_NEW |  0 );
 
8194
  {
 
8195
    if (temp3)
 
8196
    delete arg3;
 
8197
  }
 
8198
  {
 
8199
    if (temp7)
 
8200
    delete arg7;
 
8201
  }
 
8202
  return resultobj;
 
8203
fail:
 
8204
  {
 
8205
    if (temp3)
 
8206
    delete arg3;
 
8207
  }
 
8208
  {
 
8209
    if (temp7)
 
8210
    delete arg7;
 
8211
  }
 
8212
  return NULL;
 
8213
}
 
8214
 
 
8215
 
 
8216
SWIGINTERN PyObject *_wrap_new_PreStaticText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8217
  PyObject *resultobj = 0;
 
8218
  wxStaticText *result = 0 ;
 
8219
  
 
8220
  if (!SWIG_Python_UnpackTuple(args,"new_PreStaticText",0,0,0)) SWIG_fail;
 
8221
  {
 
8222
    if (!wxPyCheckForApp()) SWIG_fail;
 
8223
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8224
    result = (wxStaticText *)new wxStaticText();
 
8225
    wxPyEndAllowThreads(__tstate);
 
8226
    if (PyErr_Occurred()) SWIG_fail;
 
8227
  }
 
8228
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticText, SWIG_POINTER_OWN |  0 );
 
8229
  return resultobj;
 
8230
fail:
 
8231
  return NULL;
 
8232
}
 
8233
 
 
8234
 
 
8235
SWIGINTERN PyObject *_wrap_StaticText_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8236
  PyObject *resultobj = 0;
 
8237
  wxStaticText *arg1 = (wxStaticText *) 0 ;
 
8238
  wxWindow *arg2 = (wxWindow *) 0 ;
 
8239
  int arg3 = (int) -1 ;
 
8240
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
8241
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
8242
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
8243
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
8244
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
8245
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
8246
  long arg7 = (long) 0 ;
 
8247
  wxString const &arg8_defvalue = wxPyStaticTextNameStr ;
 
8248
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
8249
  bool result;
 
8250
  void *argp1 = 0 ;
 
8251
  int res1 = 0 ;
 
8252
  void *argp2 = 0 ;
 
8253
  int res2 = 0 ;
 
8254
  int val3 ;
 
8255
  int ecode3 = 0 ;
 
8256
  bool temp4 = false ;
 
8257
  wxPoint temp5 ;
 
8258
  wxSize temp6 ;
 
8259
  long val7 ;
 
8260
  int ecode7 = 0 ;
 
8261
  bool temp8 = false ;
 
8262
  PyObject * obj0 = 0 ;
 
8263
  PyObject * obj1 = 0 ;
 
8264
  PyObject * obj2 = 0 ;
 
8265
  PyObject * obj3 = 0 ;
 
8266
  PyObject * obj4 = 0 ;
 
8267
  PyObject * obj5 = 0 ;
 
8268
  PyObject * obj6 = 0 ;
 
8269
  PyObject * obj7 = 0 ;
 
8270
  char *  kwnames[] = {
 
8271
    (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
8272
  };
 
8273
  
 
8274
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:StaticText_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
8275
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticText, 0 |  0 );
 
8276
  if (!SWIG_IsOK(res1)) {
 
8277
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticText_Create" "', expected argument " "1"" of type '" "wxStaticText *""'"); 
 
8278
  }
 
8279
  arg1 = reinterpret_cast< wxStaticText * >(argp1);
 
8280
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
8281
  if (!SWIG_IsOK(res2)) {
 
8282
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StaticText_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
8283
  }
 
8284
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
8285
  if (obj2) {
 
8286
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
8287
    if (!SWIG_IsOK(ecode3)) {
 
8288
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StaticText_Create" "', expected argument " "3"" of type '" "int""'");
 
8289
    } 
 
8290
    arg3 = static_cast< int >(val3);
 
8291
  }
 
8292
  if (obj3) {
 
8293
    {
 
8294
      arg4 = wxString_in_helper(obj3);
 
8295
      if (arg4 == NULL) SWIG_fail;
 
8296
      temp4 = true;
 
8297
    }
 
8298
  }
 
8299
  if (obj4) {
 
8300
    {
 
8301
      arg5 = &temp5;
 
8302
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
8303
    }
 
8304
  }
 
8305
  if (obj5) {
 
8306
    {
 
8307
      arg6 = &temp6;
 
8308
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
8309
    }
 
8310
  }
 
8311
  if (obj6) {
 
8312
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
8313
    if (!SWIG_IsOK(ecode7)) {
 
8314
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "StaticText_Create" "', expected argument " "7"" of type '" "long""'");
 
8315
    } 
 
8316
    arg7 = static_cast< long >(val7);
 
8317
  }
 
8318
  if (obj7) {
 
8319
    {
 
8320
      arg8 = wxString_in_helper(obj7);
 
8321
      if (arg8 == NULL) SWIG_fail;
 
8322
      temp8 = true;
 
8323
    }
 
8324
  }
 
8325
  {
 
8326
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8327
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
 
8328
    wxPyEndAllowThreads(__tstate);
 
8329
    if (PyErr_Occurred()) SWIG_fail;
 
8330
  }
 
8331
  {
 
8332
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
8333
  }
 
8334
  {
 
8335
    if (temp4)
 
8336
    delete arg4;
 
8337
  }
 
8338
  {
 
8339
    if (temp8)
 
8340
    delete arg8;
 
8341
  }
 
8342
  return resultobj;
 
8343
fail:
 
8344
  {
 
8345
    if (temp4)
 
8346
    delete arg4;
 
8347
  }
 
8348
  {
 
8349
    if (temp8)
 
8350
    delete arg8;
 
8351
  }
 
8352
  return NULL;
 
8353
}
 
8354
 
 
8355
 
 
8356
SWIGINTERN PyObject *_wrap_StaticText_Wrap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8357
  PyObject *resultobj = 0;
 
8358
  wxStaticText *arg1 = (wxStaticText *) 0 ;
 
8359
  int arg2 ;
 
8360
  void *argp1 = 0 ;
 
8361
  int res1 = 0 ;
 
8362
  int val2 ;
 
8363
  int ecode2 = 0 ;
 
8364
  PyObject * obj0 = 0 ;
 
8365
  PyObject * obj1 = 0 ;
 
8366
  char *  kwnames[] = {
 
8367
    (char *) "self",(char *) "width", NULL 
 
8368
  };
 
8369
  
 
8370
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StaticText_Wrap",kwnames,&obj0,&obj1)) SWIG_fail;
 
8371
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticText, 0 |  0 );
 
8372
  if (!SWIG_IsOK(res1)) {
 
8373
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticText_Wrap" "', expected argument " "1"" of type '" "wxStaticText *""'"); 
 
8374
  }
 
8375
  arg1 = reinterpret_cast< wxStaticText * >(argp1);
 
8376
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
8377
  if (!SWIG_IsOK(ecode2)) {
 
8378
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StaticText_Wrap" "', expected argument " "2"" of type '" "int""'");
 
8379
  } 
 
8380
  arg2 = static_cast< int >(val2);
 
8381
  {
 
8382
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8383
    (arg1)->Wrap(arg2);
 
8384
    wxPyEndAllowThreads(__tstate);
 
8385
    if (PyErr_Occurred()) SWIG_fail;
 
8386
  }
 
8387
  resultobj = SWIG_Py_Void();
 
8388
  return resultobj;
 
8389
fail:
 
8390
  return NULL;
 
8391
}
 
8392
 
 
8393
 
 
8394
SWIGINTERN PyObject *_wrap_StaticText_IsEllipsized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8395
  PyObject *resultobj = 0;
 
8396
  wxStaticText *arg1 = (wxStaticText *) 0 ;
 
8397
  bool result;
 
8398
  void *argp1 = 0 ;
 
8399
  int res1 = 0 ;
 
8400
  PyObject *swig_obj[1] ;
 
8401
  
 
8402
  if (!args) SWIG_fail;
 
8403
  swig_obj[0] = args;
 
8404
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticText, 0 |  0 );
 
8405
  if (!SWIG_IsOK(res1)) {
 
8406
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticText_IsEllipsized" "', expected argument " "1"" of type '" "wxStaticText const *""'"); 
 
8407
  }
 
8408
  arg1 = reinterpret_cast< wxStaticText * >(argp1);
 
8409
  {
 
8410
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8411
    result = (bool)((wxStaticText const *)arg1)->IsEllipsized();
 
8412
    wxPyEndAllowThreads(__tstate);
 
8413
    if (PyErr_Occurred()) SWIG_fail;
 
8414
  }
 
8415
  {
 
8416
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
8417
  }
 
8418
  return resultobj;
 
8419
fail:
 
8420
  return NULL;
 
8421
}
 
8422
 
 
8423
 
 
8424
SWIGINTERN PyObject *_wrap_StaticText_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8425
  PyObject *resultobj = 0;
 
8426
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
8427
  SwigValueWrapper<wxVisualAttributes > result;
 
8428
  int val1 ;
 
8429
  int ecode1 = 0 ;
 
8430
  PyObject * obj0 = 0 ;
 
8431
  char *  kwnames[] = {
 
8432
    (char *) "variant", NULL 
 
8433
  };
 
8434
  
 
8435
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticText_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
8436
  if (obj0) {
 
8437
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
8438
    if (!SWIG_IsOK(ecode1)) {
 
8439
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StaticText_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
8440
    } 
 
8441
    arg1 = static_cast< wxWindowVariant >(val1);
 
8442
  }
 
8443
  {
 
8444
    if (!wxPyCheckForApp()) SWIG_fail;
 
8445
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8446
    result = wxStaticText::GetClassDefaultAttributes(arg1);
 
8447
    wxPyEndAllowThreads(__tstate);
 
8448
    if (PyErr_Occurred()) SWIG_fail;
 
8449
  }
 
8450
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
8451
  return resultobj;
 
8452
fail:
 
8453
  return NULL;
 
8454
}
 
8455
 
 
8456
 
 
8457
SWIGINTERN PyObject *StaticText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8458
  PyObject *obj;
 
8459
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
8460
  SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticText, SWIG_NewClientData(obj));
 
8461
  return SWIG_Py_Void();
 
8462
}
 
8463
 
 
8464
SWIGINTERN PyObject *StaticText_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8465
  return SWIG_Python_InitShadowInstance(args);
 
8466
}
 
8467
 
 
8468
SWIGINTERN PyObject *_wrap_new_StaticBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8469
  PyObject *resultobj = 0;
 
8470
  wxWindow *arg1 = (wxWindow *) 0 ;
 
8471
  int arg2 = (int) -1 ;
 
8472
  wxBitmap const &arg3_defvalue = wxNullBitmap ;
 
8473
  wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
 
8474
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
8475
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
8476
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
8477
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
8478
  long arg6 = (long) 0 ;
 
8479
  wxString const &arg7_defvalue = wxPyStaticBitmapNameStr ;
 
8480
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
8481
  wxStaticBitmap *result = 0 ;
 
8482
  void *argp1 = 0 ;
 
8483
  int res1 = 0 ;
 
8484
  int val2 ;
 
8485
  int ecode2 = 0 ;
 
8486
  void *argp3 = 0 ;
 
8487
  int res3 = 0 ;
 
8488
  wxPoint temp4 ;
 
8489
  wxSize temp5 ;
 
8490
  long val6 ;
 
8491
  int ecode6 = 0 ;
 
8492
  bool temp7 = false ;
 
8493
  PyObject * obj0 = 0 ;
 
8494
  PyObject * obj1 = 0 ;
 
8495
  PyObject * obj2 = 0 ;
 
8496
  PyObject * obj3 = 0 ;
 
8497
  PyObject * obj4 = 0 ;
 
8498
  PyObject * obj5 = 0 ;
 
8499
  PyObject * obj6 = 0 ;
 
8500
  char *  kwnames[] = {
 
8501
    (char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
8502
  };
 
8503
  
 
8504
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_StaticBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
8505
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
8506
  if (!SWIG_IsOK(res1)) {
 
8507
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBitmap" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
8508
  }
 
8509
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
8510
  if (obj1) {
 
8511
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
8512
    if (!SWIG_IsOK(ecode2)) {
 
8513
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBitmap" "', expected argument " "2"" of type '" "int""'");
 
8514
    } 
 
8515
    arg2 = static_cast< int >(val2);
 
8516
  }
 
8517
  if (obj2) {
 
8518
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap,  0  | 0);
 
8519
    if (!SWIG_IsOK(res3)) {
 
8520
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_StaticBitmap" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
8521
    }
 
8522
    if (!argp3) {
 
8523
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StaticBitmap" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
8524
    }
 
8525
    arg3 = reinterpret_cast< wxBitmap * >(argp3);
 
8526
  }
 
8527
  if (obj3) {
 
8528
    {
 
8529
      arg4 = &temp4;
 
8530
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
8531
    }
 
8532
  }
 
8533
  if (obj4) {
 
8534
    {
 
8535
      arg5 = &temp5;
 
8536
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
8537
    }
 
8538
  }
 
8539
  if (obj5) {
 
8540
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
8541
    if (!SWIG_IsOK(ecode6)) {
 
8542
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_StaticBitmap" "', expected argument " "6"" of type '" "long""'");
 
8543
    } 
 
8544
    arg6 = static_cast< long >(val6);
 
8545
  }
 
8546
  if (obj6) {
 
8547
    {
 
8548
      arg7 = wxString_in_helper(obj6);
 
8549
      if (arg7 == NULL) SWIG_fail;
 
8550
      temp7 = true;
 
8551
    }
 
8552
  }
 
8553
  {
 
8554
    if (!wxPyCheckForApp()) SWIG_fail;
 
8555
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8556
    result = (wxStaticBitmap *)new wxStaticBitmap(arg1,arg2,(wxBitmap const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
8557
    wxPyEndAllowThreads(__tstate);
 
8558
    if (PyErr_Occurred()) SWIG_fail;
 
8559
  }
 
8560
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBitmap, SWIG_POINTER_NEW |  0 );
 
8561
  {
 
8562
    if (temp7)
 
8563
    delete arg7;
 
8564
  }
 
8565
  return resultobj;
 
8566
fail:
 
8567
  {
 
8568
    if (temp7)
 
8569
    delete arg7;
 
8570
  }
 
8571
  return NULL;
 
8572
}
 
8573
 
 
8574
 
 
8575
SWIGINTERN PyObject *_wrap_new_PreStaticBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8576
  PyObject *resultobj = 0;
 
8577
  wxStaticBitmap *result = 0 ;
 
8578
  
 
8579
  if (!SWIG_Python_UnpackTuple(args,"new_PreStaticBitmap",0,0,0)) SWIG_fail;
 
8580
  {
 
8581
    if (!wxPyCheckForApp()) SWIG_fail;
 
8582
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8583
    result = (wxStaticBitmap *)new wxStaticBitmap();
 
8584
    wxPyEndAllowThreads(__tstate);
 
8585
    if (PyErr_Occurred()) SWIG_fail;
 
8586
  }
 
8587
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBitmap, SWIG_POINTER_OWN |  0 );
 
8588
  return resultobj;
 
8589
fail:
 
8590
  return NULL;
 
8591
}
 
8592
 
 
8593
 
 
8594
SWIGINTERN PyObject *_wrap_StaticBitmap_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8595
  PyObject *resultobj = 0;
 
8596
  wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
 
8597
  wxWindow *arg2 = (wxWindow *) 0 ;
 
8598
  int arg3 = (int) -1 ;
 
8599
  wxBitmap const &arg4_defvalue = wxNullBitmap ;
 
8600
  wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
 
8601
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
8602
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
8603
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
8604
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
8605
  long arg7 = (long) 0 ;
 
8606
  wxString const &arg8_defvalue = wxPyStaticBitmapNameStr ;
 
8607
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
8608
  bool result;
 
8609
  void *argp1 = 0 ;
 
8610
  int res1 = 0 ;
 
8611
  void *argp2 = 0 ;
 
8612
  int res2 = 0 ;
 
8613
  int val3 ;
 
8614
  int ecode3 = 0 ;
 
8615
  void *argp4 = 0 ;
 
8616
  int res4 = 0 ;
 
8617
  wxPoint temp5 ;
 
8618
  wxSize temp6 ;
 
8619
  long val7 ;
 
8620
  int ecode7 = 0 ;
 
8621
  bool temp8 = false ;
 
8622
  PyObject * obj0 = 0 ;
 
8623
  PyObject * obj1 = 0 ;
 
8624
  PyObject * obj2 = 0 ;
 
8625
  PyObject * obj3 = 0 ;
 
8626
  PyObject * obj4 = 0 ;
 
8627
  PyObject * obj5 = 0 ;
 
8628
  PyObject * obj6 = 0 ;
 
8629
  PyObject * obj7 = 0 ;
 
8630
  char *  kwnames[] = {
 
8631
    (char *) "self",(char *) "parent",(char *) "id",(char *) "bitmap",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
8632
  };
 
8633
  
 
8634
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:StaticBitmap_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
8635
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBitmap, 0 |  0 );
 
8636
  if (!SWIG_IsOK(res1)) {
 
8637
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBitmap_Create" "', expected argument " "1"" of type '" "wxStaticBitmap *""'"); 
 
8638
  }
 
8639
  arg1 = reinterpret_cast< wxStaticBitmap * >(argp1);
 
8640
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
8641
  if (!SWIG_IsOK(res2)) {
 
8642
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StaticBitmap_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
8643
  }
 
8644
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
8645
  if (obj2) {
 
8646
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
8647
    if (!SWIG_IsOK(ecode3)) {
 
8648
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StaticBitmap_Create" "', expected argument " "3"" of type '" "int""'");
 
8649
    } 
 
8650
    arg3 = static_cast< int >(val3);
 
8651
  }
 
8652
  if (obj3) {
 
8653
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap,  0  | 0);
 
8654
    if (!SWIG_IsOK(res4)) {
 
8655
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StaticBitmap_Create" "', expected argument " "4"" of type '" "wxBitmap const &""'"); 
 
8656
    }
 
8657
    if (!argp4) {
 
8658
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StaticBitmap_Create" "', expected argument " "4"" of type '" "wxBitmap const &""'"); 
 
8659
    }
 
8660
    arg4 = reinterpret_cast< wxBitmap * >(argp4);
 
8661
  }
 
8662
  if (obj4) {
 
8663
    {
 
8664
      arg5 = &temp5;
 
8665
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
8666
    }
 
8667
  }
 
8668
  if (obj5) {
 
8669
    {
 
8670
      arg6 = &temp6;
 
8671
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
8672
    }
 
8673
  }
 
8674
  if (obj6) {
 
8675
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
8676
    if (!SWIG_IsOK(ecode7)) {
 
8677
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "StaticBitmap_Create" "', expected argument " "7"" of type '" "long""'");
 
8678
    } 
 
8679
    arg7 = static_cast< long >(val7);
 
8680
  }
 
8681
  if (obj7) {
 
8682
    {
 
8683
      arg8 = wxString_in_helper(obj7);
 
8684
      if (arg8 == NULL) SWIG_fail;
 
8685
      temp8 = true;
 
8686
    }
 
8687
  }
 
8688
  {
 
8689
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8690
    result = (bool)(arg1)->Create(arg2,arg3,(wxBitmap const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
 
8691
    wxPyEndAllowThreads(__tstate);
 
8692
    if (PyErr_Occurred()) SWIG_fail;
 
8693
  }
 
8694
  {
 
8695
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
8696
  }
 
8697
  {
 
8698
    if (temp8)
 
8699
    delete arg8;
 
8700
  }
 
8701
  return resultobj;
 
8702
fail:
 
8703
  {
 
8704
    if (temp8)
 
8705
    delete arg8;
 
8706
  }
 
8707
  return NULL;
 
8708
}
 
8709
 
 
8710
 
 
8711
SWIGINTERN PyObject *_wrap_StaticBitmap_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8712
  PyObject *resultobj = 0;
 
8713
  wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
 
8714
  wxBitmap result;
 
8715
  void *argp1 = 0 ;
 
8716
  int res1 = 0 ;
 
8717
  PyObject *swig_obj[1] ;
 
8718
  
 
8719
  if (!args) SWIG_fail;
 
8720
  swig_obj[0] = args;
 
8721
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBitmap, 0 |  0 );
 
8722
  if (!SWIG_IsOK(res1)) {
 
8723
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBitmap_GetBitmap" "', expected argument " "1"" of type '" "wxStaticBitmap *""'"); 
 
8724
  }
 
8725
  arg1 = reinterpret_cast< wxStaticBitmap * >(argp1);
 
8726
  {
 
8727
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8728
    result = (arg1)->GetBitmap();
 
8729
    wxPyEndAllowThreads(__tstate);
 
8730
    if (PyErr_Occurred()) SWIG_fail;
 
8731
  }
 
8732
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
8733
  return resultobj;
 
8734
fail:
 
8735
  return NULL;
 
8736
}
 
8737
 
 
8738
 
 
8739
SWIGINTERN PyObject *_wrap_StaticBitmap_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8740
  PyObject *resultobj = 0;
 
8741
  wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
 
8742
  wxBitmap *arg2 = 0 ;
 
8743
  void *argp1 = 0 ;
 
8744
  int res1 = 0 ;
 
8745
  void *argp2 = 0 ;
 
8746
  int res2 = 0 ;
 
8747
  PyObject * obj0 = 0 ;
 
8748
  PyObject * obj1 = 0 ;
 
8749
  char *  kwnames[] = {
 
8750
    (char *) "self",(char *) "bitmap", NULL 
 
8751
  };
 
8752
  
 
8753
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StaticBitmap_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
 
8754
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBitmap, 0 |  0 );
 
8755
  if (!SWIG_IsOK(res1)) {
 
8756
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBitmap_SetBitmap" "', expected argument " "1"" of type '" "wxStaticBitmap *""'"); 
 
8757
  }
 
8758
  arg1 = reinterpret_cast< wxStaticBitmap * >(argp1);
 
8759
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
8760
  if (!SWIG_IsOK(res2)) {
 
8761
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StaticBitmap_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
8762
  }
 
8763
  if (!argp2) {
 
8764
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StaticBitmap_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
8765
  }
 
8766
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
8767
  {
 
8768
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8769
    (arg1)->SetBitmap((wxBitmap const &)*arg2);
 
8770
    wxPyEndAllowThreads(__tstate);
 
8771
    if (PyErr_Occurred()) SWIG_fail;
 
8772
  }
 
8773
  resultobj = SWIG_Py_Void();
 
8774
  return resultobj;
 
8775
fail:
 
8776
  return NULL;
 
8777
}
 
8778
 
 
8779
 
 
8780
SWIGINTERN PyObject *_wrap_StaticBitmap_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8781
  PyObject *resultobj = 0;
 
8782
  wxStaticBitmap *arg1 = (wxStaticBitmap *) 0 ;
 
8783
  wxIcon *arg2 = 0 ;
 
8784
  void *argp1 = 0 ;
 
8785
  int res1 = 0 ;
 
8786
  void *argp2 = 0 ;
 
8787
  int res2 = 0 ;
 
8788
  PyObject * obj0 = 0 ;
 
8789
  PyObject * obj1 = 0 ;
 
8790
  char *  kwnames[] = {
 
8791
    (char *) "self",(char *) "icon", NULL 
 
8792
  };
 
8793
  
 
8794
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StaticBitmap_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
 
8795
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBitmap, 0 |  0 );
 
8796
  if (!SWIG_IsOK(res1)) {
 
8797
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBitmap_SetIcon" "', expected argument " "1"" of type '" "wxStaticBitmap *""'"); 
 
8798
  }
 
8799
  arg1 = reinterpret_cast< wxStaticBitmap * >(argp1);
 
8800
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon,  0  | 0);
 
8801
  if (!SWIG_IsOK(res2)) {
 
8802
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StaticBitmap_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'"); 
 
8803
  }
 
8804
  if (!argp2) {
 
8805
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StaticBitmap_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'"); 
 
8806
  }
 
8807
  arg2 = reinterpret_cast< wxIcon * >(argp2);
 
8808
  {
 
8809
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8810
    (arg1)->SetIcon((wxIcon const &)*arg2);
 
8811
    wxPyEndAllowThreads(__tstate);
 
8812
    if (PyErr_Occurred()) SWIG_fail;
 
8813
  }
 
8814
  resultobj = SWIG_Py_Void();
 
8815
  return resultobj;
 
8816
fail:
 
8817
  return NULL;
 
8818
}
 
8819
 
 
8820
 
 
8821
SWIGINTERN PyObject *_wrap_StaticBitmap_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8822
  PyObject *resultobj = 0;
 
8823
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
8824
  SwigValueWrapper<wxVisualAttributes > result;
 
8825
  int val1 ;
 
8826
  int ecode1 = 0 ;
 
8827
  PyObject * obj0 = 0 ;
 
8828
  char *  kwnames[] = {
 
8829
    (char *) "variant", NULL 
 
8830
  };
 
8831
  
 
8832
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:StaticBitmap_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
8833
  if (obj0) {
 
8834
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
8835
    if (!SWIG_IsOK(ecode1)) {
 
8836
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StaticBitmap_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
8837
    } 
 
8838
    arg1 = static_cast< wxWindowVariant >(val1);
 
8839
  }
 
8840
  {
 
8841
    if (!wxPyCheckForApp()) SWIG_fail;
 
8842
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8843
    result = wxStaticBitmap::GetClassDefaultAttributes(arg1);
 
8844
    wxPyEndAllowThreads(__tstate);
 
8845
    if (PyErr_Occurred()) SWIG_fail;
 
8846
  }
 
8847
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
8848
  return resultobj;
 
8849
fail:
 
8850
  return NULL;
 
8851
}
 
8852
 
 
8853
 
 
8854
SWIGINTERN PyObject *StaticBitmap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8855
  PyObject *obj;
 
8856
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
8857
  SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBitmap, SWIG_NewClientData(obj));
 
8858
  return SWIG_Py_Void();
 
8859
}
 
8860
 
 
8861
SWIGINTERN PyObject *StaticBitmap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
8862
  return SWIG_Python_InitShadowInstance(args);
 
8863
}
 
8864
 
 
8865
SWIGINTERN int ListBoxNameStr_set(PyObject *) {
 
8866
  SWIG_Error(SWIG_AttributeError,"Variable ListBoxNameStr is read-only.");
 
8867
  return 1;
 
8868
}
 
8869
 
 
8870
 
 
8871
SWIGINTERN PyObject *ListBoxNameStr_get(void) {
 
8872
  PyObject *pyobj = 0;
 
8873
  
 
8874
  {
 
8875
#if wxUSE_UNICODE
 
8876
    pyobj = PyUnicode_FromWideChar((&wxPyListBoxNameStr)->c_str(), (&wxPyListBoxNameStr)->Len());
 
8877
#else
 
8878
    pyobj = PyString_FromStringAndSize((&wxPyListBoxNameStr)->c_str(), (&wxPyListBoxNameStr)->Len());
 
8879
#endif
 
8880
  }
 
8881
  return pyobj;
 
8882
}
 
8883
 
 
8884
 
 
8885
SWIGINTERN PyObject *_wrap_new_ListBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
8886
  PyObject *resultobj = 0;
 
8887
  wxWindow *arg1 = (wxWindow *) 0 ;
 
8888
  int arg2 = (int) -1 ;
 
8889
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
8890
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
8891
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
8892
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
8893
  wxArrayString const &arg5_defvalue = wxPyEmptyStringArray ;
 
8894
  wxArrayString *arg5 = (wxArrayString *) &arg5_defvalue ;
 
8895
  long arg6 = (long) 0 ;
 
8896
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
8897
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
8898
  wxString const &arg8_defvalue = wxPyListBoxNameStr ;
 
8899
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
8900
  wxListBox *result = 0 ;
 
8901
  void *argp1 = 0 ;
 
8902
  int res1 = 0 ;
 
8903
  int val2 ;
 
8904
  int ecode2 = 0 ;
 
8905
  wxPoint temp3 ;
 
8906
  wxSize temp4 ;
 
8907
  bool temp5 = false ;
 
8908
  long val6 ;
 
8909
  int ecode6 = 0 ;
 
8910
  void *argp7 = 0 ;
 
8911
  int res7 = 0 ;
 
8912
  bool temp8 = false ;
 
8913
  PyObject * obj0 = 0 ;
 
8914
  PyObject * obj1 = 0 ;
 
8915
  PyObject * obj2 = 0 ;
 
8916
  PyObject * obj3 = 0 ;
 
8917
  PyObject * obj4 = 0 ;
 
8918
  PyObject * obj5 = 0 ;
 
8919
  PyObject * obj6 = 0 ;
 
8920
  PyObject * obj7 = 0 ;
 
8921
  char *  kwnames[] = {
 
8922
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
8923
  };
 
8924
  
 
8925
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_ListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
8926
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
8927
  if (!SWIG_IsOK(res1)) {
 
8928
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListBox" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
8929
  }
 
8930
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
8931
  if (obj1) {
 
8932
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
8933
    if (!SWIG_IsOK(ecode2)) {
 
8934
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListBox" "', expected argument " "2"" of type '" "int""'");
 
8935
    } 
 
8936
    arg2 = static_cast< int >(val2);
 
8937
  }
 
8938
  if (obj2) {
 
8939
    {
 
8940
      arg3 = &temp3;
 
8941
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
8942
    }
 
8943
  }
 
8944
  if (obj3) {
 
8945
    {
 
8946
      arg4 = &temp4;
 
8947
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
8948
    }
 
8949
  }
 
8950
  if (obj4) {
 
8951
    {
 
8952
      if (! PySequence_Check(obj4)) {
 
8953
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
8954
        SWIG_fail;
 
8955
      }
 
8956
      arg5 = new wxArrayString;
 
8957
      temp5 = true;
 
8958
      int i, len=PySequence_Length(obj4);
 
8959
      for (i=0; i<len; i++) {
 
8960
        PyObject* item = PySequence_GetItem(obj4, i);
 
8961
        wxString* s = wxString_in_helper(item);
 
8962
        if (PyErr_Occurred())  SWIG_fail;
 
8963
        arg5->Add(*s);
 
8964
        delete s;
 
8965
        Py_DECREF(item);
 
8966
      }
 
8967
    }
 
8968
  }
 
8969
  if (obj5) {
 
8970
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
8971
    if (!SWIG_IsOK(ecode6)) {
 
8972
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ListBox" "', expected argument " "6"" of type '" "long""'");
 
8973
    } 
 
8974
    arg6 = static_cast< long >(val6);
 
8975
  }
 
8976
  if (obj6) {
 
8977
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
8978
    if (!SWIG_IsOK(res7)) {
 
8979
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ListBox" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
8980
    }
 
8981
    if (!argp7) {
 
8982
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListBox" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
8983
    }
 
8984
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
8985
  }
 
8986
  if (obj7) {
 
8987
    {
 
8988
      arg8 = wxString_in_helper(obj7);
 
8989
      if (arg8 == NULL) SWIG_fail;
 
8990
      temp8 = true;
 
8991
    }
 
8992
  }
 
8993
  {
 
8994
    if (!wxPyCheckForApp()) SWIG_fail;
 
8995
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
8996
    result = (wxListBox *)new wxListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,(wxArrayString const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
8997
    wxPyEndAllowThreads(__tstate);
 
8998
    if (PyErr_Occurred()) SWIG_fail;
 
8999
  }
 
9000
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListBox, SWIG_POINTER_NEW |  0 );
 
9001
  {
 
9002
    if (temp5) delete arg5;
 
9003
  }
 
9004
  {
 
9005
    if (temp8)
 
9006
    delete arg8;
 
9007
  }
 
9008
  return resultobj;
 
9009
fail:
 
9010
  {
 
9011
    if (temp5) delete arg5;
 
9012
  }
 
9013
  {
 
9014
    if (temp8)
 
9015
    delete arg8;
 
9016
  }
 
9017
  return NULL;
 
9018
}
 
9019
 
 
9020
 
 
9021
SWIGINTERN PyObject *_wrap_new_PreListBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
9022
  PyObject *resultobj = 0;
 
9023
  wxListBox *result = 0 ;
 
9024
  
 
9025
  if (!SWIG_Python_UnpackTuple(args,"new_PreListBox",0,0,0)) SWIG_fail;
 
9026
  {
 
9027
    if (!wxPyCheckForApp()) SWIG_fail;
 
9028
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9029
    result = (wxListBox *)new wxListBox();
 
9030
    wxPyEndAllowThreads(__tstate);
 
9031
    if (PyErr_Occurred()) SWIG_fail;
 
9032
  }
 
9033
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListBox, SWIG_POINTER_OWN |  0 );
 
9034
  return resultobj;
 
9035
fail:
 
9036
  return NULL;
 
9037
}
 
9038
 
 
9039
 
 
9040
SWIGINTERN PyObject *_wrap_ListBox_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9041
  PyObject *resultobj = 0;
 
9042
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9043
  wxWindow *arg2 = (wxWindow *) 0 ;
 
9044
  int arg3 = (int) -1 ;
 
9045
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
9046
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
9047
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
9048
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
9049
  wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
 
9050
  wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
 
9051
  long arg7 = (long) 0 ;
 
9052
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
9053
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
9054
  wxString const &arg9_defvalue = wxPyListBoxNameStr ;
 
9055
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
9056
  bool result;
 
9057
  void *argp1 = 0 ;
 
9058
  int res1 = 0 ;
 
9059
  void *argp2 = 0 ;
 
9060
  int res2 = 0 ;
 
9061
  int val3 ;
 
9062
  int ecode3 = 0 ;
 
9063
  wxPoint temp4 ;
 
9064
  wxSize temp5 ;
 
9065
  bool temp6 = false ;
 
9066
  long val7 ;
 
9067
  int ecode7 = 0 ;
 
9068
  void *argp8 = 0 ;
 
9069
  int res8 = 0 ;
 
9070
  bool temp9 = false ;
 
9071
  PyObject * obj0 = 0 ;
 
9072
  PyObject * obj1 = 0 ;
 
9073
  PyObject * obj2 = 0 ;
 
9074
  PyObject * obj3 = 0 ;
 
9075
  PyObject * obj4 = 0 ;
 
9076
  PyObject * obj5 = 0 ;
 
9077
  PyObject * obj6 = 0 ;
 
9078
  PyObject * obj7 = 0 ;
 
9079
  PyObject * obj8 = 0 ;
 
9080
  char *  kwnames[] = {
 
9081
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
9082
  };
 
9083
  
 
9084
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:ListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
9085
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9086
  if (!SWIG_IsOK(res1)) {
 
9087
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_Create" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9088
  }
 
9089
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9090
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
9091
  if (!SWIG_IsOK(res2)) {
 
9092
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListBox_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
9093
  }
 
9094
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
9095
  if (obj2) {
 
9096
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
9097
    if (!SWIG_IsOK(ecode3)) {
 
9098
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListBox_Create" "', expected argument " "3"" of type '" "int""'");
 
9099
    } 
 
9100
    arg3 = static_cast< int >(val3);
 
9101
  }
 
9102
  if (obj3) {
 
9103
    {
 
9104
      arg4 = &temp4;
 
9105
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
9106
    }
 
9107
  }
 
9108
  if (obj4) {
 
9109
    {
 
9110
      arg5 = &temp5;
 
9111
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
9112
    }
 
9113
  }
 
9114
  if (obj5) {
 
9115
    {
 
9116
      if (! PySequence_Check(obj5)) {
 
9117
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
9118
        SWIG_fail;
 
9119
      }
 
9120
      arg6 = new wxArrayString;
 
9121
      temp6 = true;
 
9122
      int i, len=PySequence_Length(obj5);
 
9123
      for (i=0; i<len; i++) {
 
9124
        PyObject* item = PySequence_GetItem(obj5, i);
 
9125
        wxString* s = wxString_in_helper(item);
 
9126
        if (PyErr_Occurred())  SWIG_fail;
 
9127
        arg6->Add(*s);
 
9128
        delete s;
 
9129
        Py_DECREF(item);
 
9130
      }
 
9131
    }
 
9132
  }
 
9133
  if (obj6) {
 
9134
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
9135
    if (!SWIG_IsOK(ecode7)) {
 
9136
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ListBox_Create" "', expected argument " "7"" of type '" "long""'");
 
9137
    } 
 
9138
    arg7 = static_cast< long >(val7);
 
9139
  }
 
9140
  if (obj7) {
 
9141
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
9142
    if (!SWIG_IsOK(res8)) {
 
9143
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ListBox_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
9144
    }
 
9145
    if (!argp8) {
 
9146
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListBox_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
9147
    }
 
9148
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
9149
  }
 
9150
  if (obj8) {
 
9151
    {
 
9152
      arg9 = wxString_in_helper(obj8);
 
9153
      if (arg9 == NULL) SWIG_fail;
 
9154
      temp9 = true;
 
9155
    }
 
9156
  }
 
9157
  {
 
9158
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9159
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
9160
    wxPyEndAllowThreads(__tstate);
 
9161
    if (PyErr_Occurred()) SWIG_fail;
 
9162
  }
 
9163
  {
 
9164
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
9165
  }
 
9166
  {
 
9167
    if (temp6) delete arg6;
 
9168
  }
 
9169
  {
 
9170
    if (temp9)
 
9171
    delete arg9;
 
9172
  }
 
9173
  return resultobj;
 
9174
fail:
 
9175
  {
 
9176
    if (temp6) delete arg6;
 
9177
  }
 
9178
  {
 
9179
    if (temp9)
 
9180
    delete arg9;
 
9181
  }
 
9182
  return NULL;
 
9183
}
 
9184
 
 
9185
 
 
9186
SWIGINTERN PyObject *_wrap_ListBox_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9187
  PyObject *resultobj = 0;
 
9188
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9189
  wxString *arg2 = 0 ;
 
9190
  int arg3 ;
 
9191
  PyObject *arg4 = (PyObject *) NULL ;
 
9192
  void *argp1 = 0 ;
 
9193
  int res1 = 0 ;
 
9194
  bool temp2 = false ;
 
9195
  int val3 ;
 
9196
  int ecode3 = 0 ;
 
9197
  PyObject * obj0 = 0 ;
 
9198
  PyObject * obj1 = 0 ;
 
9199
  PyObject * obj2 = 0 ;
 
9200
  PyObject * obj3 = 0 ;
 
9201
  char *  kwnames[] = {
 
9202
    (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL 
 
9203
  };
 
9204
  
 
9205
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ListBox_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
9206
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9207
  if (!SWIG_IsOK(res1)) {
 
9208
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_Insert" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9209
  }
 
9210
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9211
  {
 
9212
    arg2 = wxString_in_helper(obj1);
 
9213
    if (arg2 == NULL) SWIG_fail;
 
9214
    temp2 = true;
 
9215
  }
 
9216
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
9217
  if (!SWIG_IsOK(ecode3)) {
 
9218
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListBox_Insert" "', expected argument " "3"" of type '" "int""'");
 
9219
  } 
 
9220
  arg3 = static_cast< int >(val3);
 
9221
  if (obj3) {
 
9222
    arg4 = obj3;
 
9223
  }
 
9224
  {
 
9225
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9226
    wxListBox_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
 
9227
    wxPyEndAllowThreads(__tstate);
 
9228
    if (PyErr_Occurred()) SWIG_fail;
 
9229
  }
 
9230
  resultobj = SWIG_Py_Void();
 
9231
  {
 
9232
    if (temp2)
 
9233
    delete arg2;
 
9234
  }
 
9235
  return resultobj;
 
9236
fail:
 
9237
  {
 
9238
    if (temp2)
 
9239
    delete arg2;
 
9240
  }
 
9241
  return NULL;
 
9242
}
 
9243
 
 
9244
 
 
9245
SWIGINTERN PyObject *_wrap_ListBox_InsertItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9246
  PyObject *resultobj = 0;
 
9247
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9248
  wxArrayString *arg2 = 0 ;
 
9249
  unsigned int arg3 ;
 
9250
  void *argp1 = 0 ;
 
9251
  int res1 = 0 ;
 
9252
  bool temp2 = false ;
 
9253
  unsigned int val3 ;
 
9254
  int ecode3 = 0 ;
 
9255
  PyObject * obj0 = 0 ;
 
9256
  PyObject * obj1 = 0 ;
 
9257
  PyObject * obj2 = 0 ;
 
9258
  char *  kwnames[] = {
 
9259
    (char *) "self",(char *) "items",(char *) "pos", NULL 
 
9260
  };
 
9261
  
 
9262
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_InsertItems",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
9263
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9264
  if (!SWIG_IsOK(res1)) {
 
9265
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_InsertItems" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9266
  }
 
9267
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9268
  {
 
9269
    if (! PySequence_Check(obj1)) {
 
9270
      PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
9271
      SWIG_fail;
 
9272
    }
 
9273
    arg2 = new wxArrayString;
 
9274
    temp2 = true;
 
9275
    int i, len=PySequence_Length(obj1);
 
9276
    for (i=0; i<len; i++) {
 
9277
      PyObject* item = PySequence_GetItem(obj1, i);
 
9278
      wxString* s = wxString_in_helper(item);
 
9279
      if (PyErr_Occurred())  SWIG_fail;
 
9280
      arg2->Add(*s);
 
9281
      delete s;
 
9282
      Py_DECREF(item);
 
9283
    }
 
9284
  }
 
9285
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
 
9286
  if (!SWIG_IsOK(ecode3)) {
 
9287
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListBox_InsertItems" "', expected argument " "3"" of type '" "unsigned int""'");
 
9288
  } 
 
9289
  arg3 = static_cast< unsigned int >(val3);
 
9290
  {
 
9291
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9292
    (arg1)->InsertItems((wxArrayString const &)*arg2,arg3);
 
9293
    wxPyEndAllowThreads(__tstate);
 
9294
    if (PyErr_Occurred()) SWIG_fail;
 
9295
  }
 
9296
  resultobj = SWIG_Py_Void();
 
9297
  {
 
9298
    if (temp2) delete arg2;
 
9299
  }
 
9300
  return resultobj;
 
9301
fail:
 
9302
  {
 
9303
    if (temp2) delete arg2;
 
9304
  }
 
9305
  return NULL;
 
9306
}
 
9307
 
 
9308
 
 
9309
SWIGINTERN PyObject *_wrap_ListBox_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9310
  PyObject *resultobj = 0;
 
9311
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9312
  wxArrayString *arg2 = 0 ;
 
9313
  void *argp1 = 0 ;
 
9314
  int res1 = 0 ;
 
9315
  bool temp2 = false ;
 
9316
  PyObject * obj0 = 0 ;
 
9317
  PyObject * obj1 = 0 ;
 
9318
  char *  kwnames[] = {
 
9319
    (char *) "self",(char *) "items", NULL 
 
9320
  };
 
9321
  
 
9322
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_Set",kwnames,&obj0,&obj1)) SWIG_fail;
 
9323
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9324
  if (!SWIG_IsOK(res1)) {
 
9325
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_Set" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9326
  }
 
9327
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9328
  {
 
9329
    if (! PySequence_Check(obj1)) {
 
9330
      PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
9331
      SWIG_fail;
 
9332
    }
 
9333
    arg2 = new wxArrayString;
 
9334
    temp2 = true;
 
9335
    int i, len=PySequence_Length(obj1);
 
9336
    for (i=0; i<len; i++) {
 
9337
      PyObject* item = PySequence_GetItem(obj1, i);
 
9338
      wxString* s = wxString_in_helper(item);
 
9339
      if (PyErr_Occurred())  SWIG_fail;
 
9340
      arg2->Add(*s);
 
9341
      delete s;
 
9342
      Py_DECREF(item);
 
9343
    }
 
9344
  }
 
9345
  {
 
9346
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9347
    (arg1)->Set((wxArrayString const &)*arg2);
 
9348
    wxPyEndAllowThreads(__tstate);
 
9349
    if (PyErr_Occurred()) SWIG_fail;
 
9350
  }
 
9351
  resultobj = SWIG_Py_Void();
 
9352
  {
 
9353
    if (temp2) delete arg2;
 
9354
  }
 
9355
  return resultobj;
 
9356
fail:
 
9357
  {
 
9358
    if (temp2) delete arg2;
 
9359
  }
 
9360
  return NULL;
 
9361
}
 
9362
 
 
9363
 
 
9364
SWIGINTERN PyObject *_wrap_ListBox_IsSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9365
  PyObject *resultobj = 0;
 
9366
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9367
  int arg2 ;
 
9368
  bool result;
 
9369
  void *argp1 = 0 ;
 
9370
  int res1 = 0 ;
 
9371
  int val2 ;
 
9372
  int ecode2 = 0 ;
 
9373
  PyObject * obj0 = 0 ;
 
9374
  PyObject * obj1 = 0 ;
 
9375
  char *  kwnames[] = {
 
9376
    (char *) "self",(char *) "n", NULL 
 
9377
  };
 
9378
  
 
9379
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_IsSelected",kwnames,&obj0,&obj1)) SWIG_fail;
 
9380
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9381
  if (!SWIG_IsOK(res1)) {
 
9382
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_IsSelected" "', expected argument " "1"" of type '" "wxListBox const *""'"); 
 
9383
  }
 
9384
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9385
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
9386
  if (!SWIG_IsOK(ecode2)) {
 
9387
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListBox_IsSelected" "', expected argument " "2"" of type '" "int""'");
 
9388
  } 
 
9389
  arg2 = static_cast< int >(val2);
 
9390
  {
 
9391
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9392
    result = (bool)((wxListBox const *)arg1)->IsSelected(arg2);
 
9393
    wxPyEndAllowThreads(__tstate);
 
9394
    if (PyErr_Occurred()) SWIG_fail;
 
9395
  }
 
9396
  {
 
9397
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
9398
  }
 
9399
  return resultobj;
 
9400
fail:
 
9401
  return NULL;
 
9402
}
 
9403
 
 
9404
 
 
9405
SWIGINTERN PyObject *_wrap_ListBox_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9406
  PyObject *resultobj = 0;
 
9407
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9408
  int arg2 ;
 
9409
  bool arg3 = (bool) true ;
 
9410
  void *argp1 = 0 ;
 
9411
  int res1 = 0 ;
 
9412
  int val2 ;
 
9413
  int ecode2 = 0 ;
 
9414
  bool val3 ;
 
9415
  int ecode3 = 0 ;
 
9416
  PyObject * obj0 = 0 ;
 
9417
  PyObject * obj1 = 0 ;
 
9418
  PyObject * obj2 = 0 ;
 
9419
  char *  kwnames[] = {
 
9420
    (char *) "self",(char *) "n",(char *) "select", NULL 
 
9421
  };
 
9422
  
 
9423
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListBox_SetSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
9424
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9425
  if (!SWIG_IsOK(res1)) {
 
9426
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_SetSelection" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9427
  }
 
9428
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9429
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
9430
  if (!SWIG_IsOK(ecode2)) {
 
9431
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListBox_SetSelection" "', expected argument " "2"" of type '" "int""'");
 
9432
  } 
 
9433
  arg2 = static_cast< int >(val2);
 
9434
  if (obj2) {
 
9435
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
9436
    if (!SWIG_IsOK(ecode3)) {
 
9437
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListBox_SetSelection" "', expected argument " "3"" of type '" "bool""'");
 
9438
    } 
 
9439
    arg3 = static_cast< bool >(val3);
 
9440
  }
 
9441
  {
 
9442
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9443
    (arg1)->SetSelection(arg2,arg3);
 
9444
    wxPyEndAllowThreads(__tstate);
 
9445
    if (PyErr_Occurred()) SWIG_fail;
 
9446
  }
 
9447
  resultobj = SWIG_Py_Void();
 
9448
  return resultobj;
 
9449
fail:
 
9450
  return NULL;
 
9451
}
 
9452
 
 
9453
 
 
9454
SWIGINTERN PyObject *_wrap_ListBox_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9455
  PyObject *resultobj = 0;
 
9456
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9457
  int arg2 ;
 
9458
  void *argp1 = 0 ;
 
9459
  int res1 = 0 ;
 
9460
  int val2 ;
 
9461
  int ecode2 = 0 ;
 
9462
  PyObject * obj0 = 0 ;
 
9463
  PyObject * obj1 = 0 ;
 
9464
  char *  kwnames[] = {
 
9465
    (char *) "self",(char *) "n", NULL 
 
9466
  };
 
9467
  
 
9468
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_Select",kwnames,&obj0,&obj1)) SWIG_fail;
 
9469
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9470
  if (!SWIG_IsOK(res1)) {
 
9471
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_Select" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9472
  }
 
9473
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9474
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
9475
  if (!SWIG_IsOK(ecode2)) {
 
9476
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListBox_Select" "', expected argument " "2"" of type '" "int""'");
 
9477
  } 
 
9478
  arg2 = static_cast< int >(val2);
 
9479
  {
 
9480
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9481
    (arg1)->Select(arg2);
 
9482
    wxPyEndAllowThreads(__tstate);
 
9483
    if (PyErr_Occurred()) SWIG_fail;
 
9484
  }
 
9485
  resultobj = SWIG_Py_Void();
 
9486
  return resultobj;
 
9487
fail:
 
9488
  return NULL;
 
9489
}
 
9490
 
 
9491
 
 
9492
SWIGINTERN PyObject *_wrap_ListBox_Deselect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9493
  PyObject *resultobj = 0;
 
9494
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9495
  int arg2 ;
 
9496
  void *argp1 = 0 ;
 
9497
  int res1 = 0 ;
 
9498
  int val2 ;
 
9499
  int ecode2 = 0 ;
 
9500
  PyObject * obj0 = 0 ;
 
9501
  PyObject * obj1 = 0 ;
 
9502
  char *  kwnames[] = {
 
9503
    (char *) "self",(char *) "n", NULL 
 
9504
  };
 
9505
  
 
9506
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_Deselect",kwnames,&obj0,&obj1)) SWIG_fail;
 
9507
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9508
  if (!SWIG_IsOK(res1)) {
 
9509
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_Deselect" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9510
  }
 
9511
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9512
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
9513
  if (!SWIG_IsOK(ecode2)) {
 
9514
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListBox_Deselect" "', expected argument " "2"" of type '" "int""'");
 
9515
  } 
 
9516
  arg2 = static_cast< int >(val2);
 
9517
  {
 
9518
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9519
    (arg1)->Deselect(arg2);
 
9520
    wxPyEndAllowThreads(__tstate);
 
9521
    if (PyErr_Occurred()) SWIG_fail;
 
9522
  }
 
9523
  resultobj = SWIG_Py_Void();
 
9524
  return resultobj;
 
9525
fail:
 
9526
  return NULL;
 
9527
}
 
9528
 
 
9529
 
 
9530
SWIGINTERN PyObject *_wrap_ListBox_DeselectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9531
  PyObject *resultobj = 0;
 
9532
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9533
  int arg2 = (int) -1 ;
 
9534
  void *argp1 = 0 ;
 
9535
  int res1 = 0 ;
 
9536
  int val2 ;
 
9537
  int ecode2 = 0 ;
 
9538
  PyObject * obj0 = 0 ;
 
9539
  PyObject * obj1 = 0 ;
 
9540
  char *  kwnames[] = {
 
9541
    (char *) "self",(char *) "itemToLeaveSelected", NULL 
 
9542
  };
 
9543
  
 
9544
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ListBox_DeselectAll",kwnames,&obj0,&obj1)) SWIG_fail;
 
9545
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9546
  if (!SWIG_IsOK(res1)) {
 
9547
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_DeselectAll" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9548
  }
 
9549
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9550
  if (obj1) {
 
9551
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
9552
    if (!SWIG_IsOK(ecode2)) {
 
9553
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListBox_DeselectAll" "', expected argument " "2"" of type '" "int""'");
 
9554
    } 
 
9555
    arg2 = static_cast< int >(val2);
 
9556
  }
 
9557
  {
 
9558
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9559
    (arg1)->DeselectAll(arg2);
 
9560
    wxPyEndAllowThreads(__tstate);
 
9561
    if (PyErr_Occurred()) SWIG_fail;
 
9562
  }
 
9563
  resultobj = SWIG_Py_Void();
 
9564
  return resultobj;
 
9565
fail:
 
9566
  return NULL;
 
9567
}
 
9568
 
 
9569
 
 
9570
SWIGINTERN PyObject *_wrap_ListBox_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9571
  PyObject *resultobj = 0;
 
9572
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9573
  wxString *arg2 = 0 ;
 
9574
  bool arg3 = (bool) true ;
 
9575
  bool result;
 
9576
  void *argp1 = 0 ;
 
9577
  int res1 = 0 ;
 
9578
  bool temp2 = false ;
 
9579
  bool val3 ;
 
9580
  int ecode3 = 0 ;
 
9581
  PyObject * obj0 = 0 ;
 
9582
  PyObject * obj1 = 0 ;
 
9583
  PyObject * obj2 = 0 ;
 
9584
  char *  kwnames[] = {
 
9585
    (char *) "self",(char *) "s",(char *) "select", NULL 
 
9586
  };
 
9587
  
 
9588
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListBox_SetStringSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
9589
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9590
  if (!SWIG_IsOK(res1)) {
 
9591
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_SetStringSelection" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9592
  }
 
9593
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9594
  {
 
9595
    arg2 = wxString_in_helper(obj1);
 
9596
    if (arg2 == NULL) SWIG_fail;
 
9597
    temp2 = true;
 
9598
  }
 
9599
  if (obj2) {
 
9600
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
9601
    if (!SWIG_IsOK(ecode3)) {
 
9602
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListBox_SetStringSelection" "', expected argument " "3"" of type '" "bool""'");
 
9603
    } 
 
9604
    arg3 = static_cast< bool >(val3);
 
9605
  }
 
9606
  {
 
9607
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9608
    result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2,arg3);
 
9609
    wxPyEndAllowThreads(__tstate);
 
9610
    if (PyErr_Occurred()) SWIG_fail;
 
9611
  }
 
9612
  {
 
9613
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
9614
  }
 
9615
  {
 
9616
    if (temp2)
 
9617
    delete arg2;
 
9618
  }
 
9619
  return resultobj;
 
9620
fail:
 
9621
  {
 
9622
    if (temp2)
 
9623
    delete arg2;
 
9624
  }
 
9625
  return NULL;
 
9626
}
 
9627
 
 
9628
 
 
9629
SWIGINTERN PyObject *_wrap_ListBox_GetSelections(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
9630
  PyObject *resultobj = 0;
 
9631
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9632
  PyObject *result = 0 ;
 
9633
  void *argp1 = 0 ;
 
9634
  int res1 = 0 ;
 
9635
  PyObject *swig_obj[1] ;
 
9636
  
 
9637
  if (!args) SWIG_fail;
 
9638
  swig_obj[0] = args;
 
9639
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9640
  if (!SWIG_IsOK(res1)) {
 
9641
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_GetSelections" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9642
  }
 
9643
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9644
  {
 
9645
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9646
    result = (PyObject *)wxListBox_GetSelections(arg1);
 
9647
    wxPyEndAllowThreads(__tstate);
 
9648
    if (PyErr_Occurred()) SWIG_fail;
 
9649
  }
 
9650
  resultobj = result;
 
9651
  return resultobj;
 
9652
fail:
 
9653
  return NULL;
 
9654
}
 
9655
 
 
9656
 
 
9657
SWIGINTERN PyObject *_wrap_ListBox_SetFirstItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9658
  PyObject *resultobj = 0;
 
9659
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9660
  int arg2 ;
 
9661
  void *argp1 = 0 ;
 
9662
  int res1 = 0 ;
 
9663
  int val2 ;
 
9664
  int ecode2 = 0 ;
 
9665
  PyObject * obj0 = 0 ;
 
9666
  PyObject * obj1 = 0 ;
 
9667
  char *  kwnames[] = {
 
9668
    (char *) "self",(char *) "n", NULL 
 
9669
  };
 
9670
  
 
9671
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_SetFirstItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
9672
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9673
  if (!SWIG_IsOK(res1)) {
 
9674
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_SetFirstItem" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9675
  }
 
9676
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9677
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
9678
  if (!SWIG_IsOK(ecode2)) {
 
9679
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListBox_SetFirstItem" "', expected argument " "2"" of type '" "int""'");
 
9680
  } 
 
9681
  arg2 = static_cast< int >(val2);
 
9682
  {
 
9683
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9684
    (arg1)->SetFirstItem(arg2);
 
9685
    wxPyEndAllowThreads(__tstate);
 
9686
    if (PyErr_Occurred()) SWIG_fail;
 
9687
  }
 
9688
  resultobj = SWIG_Py_Void();
 
9689
  return resultobj;
 
9690
fail:
 
9691
  return NULL;
 
9692
}
 
9693
 
 
9694
 
 
9695
SWIGINTERN PyObject *_wrap_ListBox_SetFirstItemStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9696
  PyObject *resultobj = 0;
 
9697
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9698
  wxString *arg2 = 0 ;
 
9699
  void *argp1 = 0 ;
 
9700
  int res1 = 0 ;
 
9701
  bool temp2 = false ;
 
9702
  PyObject * obj0 = 0 ;
 
9703
  PyObject * obj1 = 0 ;
 
9704
  char *  kwnames[] = {
 
9705
    (char *) "self",(char *) "s", NULL 
 
9706
  };
 
9707
  
 
9708
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_SetFirstItemStr",kwnames,&obj0,&obj1)) SWIG_fail;
 
9709
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9710
  if (!SWIG_IsOK(res1)) {
 
9711
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_SetFirstItemStr" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9712
  }
 
9713
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9714
  {
 
9715
    arg2 = wxString_in_helper(obj1);
 
9716
    if (arg2 == NULL) SWIG_fail;
 
9717
    temp2 = true;
 
9718
  }
 
9719
  {
 
9720
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9721
    (arg1)->SetFirstItem((wxString const &)*arg2);
 
9722
    wxPyEndAllowThreads(__tstate);
 
9723
    if (PyErr_Occurred()) SWIG_fail;
 
9724
  }
 
9725
  resultobj = SWIG_Py_Void();
 
9726
  {
 
9727
    if (temp2)
 
9728
    delete arg2;
 
9729
  }
 
9730
  return resultobj;
 
9731
fail:
 
9732
  {
 
9733
    if (temp2)
 
9734
    delete arg2;
 
9735
  }
 
9736
  return NULL;
 
9737
}
 
9738
 
 
9739
 
 
9740
SWIGINTERN PyObject *_wrap_ListBox_EnsureVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9741
  PyObject *resultobj = 0;
 
9742
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9743
  int arg2 ;
 
9744
  void *argp1 = 0 ;
 
9745
  int res1 = 0 ;
 
9746
  int val2 ;
 
9747
  int ecode2 = 0 ;
 
9748
  PyObject * obj0 = 0 ;
 
9749
  PyObject * obj1 = 0 ;
 
9750
  char *  kwnames[] = {
 
9751
    (char *) "self",(char *) "n", NULL 
 
9752
  };
 
9753
  
 
9754
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_EnsureVisible",kwnames,&obj0,&obj1)) SWIG_fail;
 
9755
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9756
  if (!SWIG_IsOK(res1)) {
 
9757
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_EnsureVisible" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9758
  }
 
9759
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9760
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
9761
  if (!SWIG_IsOK(ecode2)) {
 
9762
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListBox_EnsureVisible" "', expected argument " "2"" of type '" "int""'");
 
9763
  } 
 
9764
  arg2 = static_cast< int >(val2);
 
9765
  {
 
9766
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9767
    (arg1)->EnsureVisible(arg2);
 
9768
    wxPyEndAllowThreads(__tstate);
 
9769
    if (PyErr_Occurred()) SWIG_fail;
 
9770
  }
 
9771
  resultobj = SWIG_Py_Void();
 
9772
  return resultobj;
 
9773
fail:
 
9774
  return NULL;
 
9775
}
 
9776
 
 
9777
 
 
9778
SWIGINTERN PyObject *_wrap_ListBox_AppendAndEnsureVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9779
  PyObject *resultobj = 0;
 
9780
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9781
  wxString *arg2 = 0 ;
 
9782
  void *argp1 = 0 ;
 
9783
  int res1 = 0 ;
 
9784
  bool temp2 = false ;
 
9785
  PyObject * obj0 = 0 ;
 
9786
  PyObject * obj1 = 0 ;
 
9787
  char *  kwnames[] = {
 
9788
    (char *) "self",(char *) "s", NULL 
 
9789
  };
 
9790
  
 
9791
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_AppendAndEnsureVisible",kwnames,&obj0,&obj1)) SWIG_fail;
 
9792
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9793
  if (!SWIG_IsOK(res1)) {
 
9794
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_AppendAndEnsureVisible" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9795
  }
 
9796
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9797
  {
 
9798
    arg2 = wxString_in_helper(obj1);
 
9799
    if (arg2 == NULL) SWIG_fail;
 
9800
    temp2 = true;
 
9801
  }
 
9802
  {
 
9803
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9804
    (arg1)->AppendAndEnsureVisible((wxString const &)*arg2);
 
9805
    wxPyEndAllowThreads(__tstate);
 
9806
    if (PyErr_Occurred()) SWIG_fail;
 
9807
  }
 
9808
  resultobj = SWIG_Py_Void();
 
9809
  {
 
9810
    if (temp2)
 
9811
    delete arg2;
 
9812
  }
 
9813
  return resultobj;
 
9814
fail:
 
9815
  {
 
9816
    if (temp2)
 
9817
    delete arg2;
 
9818
  }
 
9819
  return NULL;
 
9820
}
 
9821
 
 
9822
 
 
9823
SWIGINTERN PyObject *_wrap_ListBox_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9824
  PyObject *resultobj = 0;
 
9825
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9826
  wxPoint *arg2 = 0 ;
 
9827
  int result;
 
9828
  void *argp1 = 0 ;
 
9829
  int res1 = 0 ;
 
9830
  wxPoint temp2 ;
 
9831
  PyObject * obj0 = 0 ;
 
9832
  PyObject * obj1 = 0 ;
 
9833
  char *  kwnames[] = {
 
9834
    (char *) "self",(char *) "pt", NULL 
 
9835
  };
 
9836
  
 
9837
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListBox_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
 
9838
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9839
  if (!SWIG_IsOK(res1)) {
 
9840
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_HitTest" "', expected argument " "1"" of type '" "wxListBox const *""'"); 
 
9841
  }
 
9842
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9843
  {
 
9844
    arg2 = &temp2;
 
9845
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
9846
  }
 
9847
  {
 
9848
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9849
    result = (int)((wxListBox const *)arg1)->HitTest((wxPoint const &)*arg2);
 
9850
    wxPyEndAllowThreads(__tstate);
 
9851
    if (PyErr_Occurred()) SWIG_fail;
 
9852
  }
 
9853
  resultobj = SWIG_From_int(static_cast< int >(result));
 
9854
  return resultobj;
 
9855
fail:
 
9856
  return NULL;
 
9857
}
 
9858
 
 
9859
 
 
9860
SWIGINTERN PyObject *_wrap_ListBox_SetItemForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9861
  PyObject *resultobj = 0;
 
9862
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9863
  int arg2 ;
 
9864
  wxColour *arg3 = 0 ;
 
9865
  void *argp1 = 0 ;
 
9866
  int res1 = 0 ;
 
9867
  int val2 ;
 
9868
  int ecode2 = 0 ;
 
9869
  wxColour temp3 ;
 
9870
  PyObject * obj0 = 0 ;
 
9871
  PyObject * obj1 = 0 ;
 
9872
  PyObject * obj2 = 0 ;
 
9873
  char *  kwnames[] = {
 
9874
    (char *) "self",(char *) "item",(char *) "c", NULL 
 
9875
  };
 
9876
  
 
9877
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_SetItemForegroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
9878
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9879
  if (!SWIG_IsOK(res1)) {
 
9880
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_SetItemForegroundColour" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9881
  }
 
9882
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9883
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
9884
  if (!SWIG_IsOK(ecode2)) {
 
9885
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListBox_SetItemForegroundColour" "', expected argument " "2"" of type '" "int""'");
 
9886
  } 
 
9887
  arg2 = static_cast< int >(val2);
 
9888
  {
 
9889
    arg3 = &temp3;
 
9890
    if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
 
9891
  }
 
9892
  {
 
9893
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9894
    wxListBox_SetItemForegroundColour(arg1,arg2,(wxColour const &)*arg3);
 
9895
    wxPyEndAllowThreads(__tstate);
 
9896
    if (PyErr_Occurred()) SWIG_fail;
 
9897
  }
 
9898
  resultobj = SWIG_Py_Void();
 
9899
  return resultobj;
 
9900
fail:
 
9901
  return NULL;
 
9902
}
 
9903
 
 
9904
 
 
9905
SWIGINTERN PyObject *_wrap_ListBox_SetItemBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9906
  PyObject *resultobj = 0;
 
9907
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9908
  int arg2 ;
 
9909
  wxColour *arg3 = 0 ;
 
9910
  void *argp1 = 0 ;
 
9911
  int res1 = 0 ;
 
9912
  int val2 ;
 
9913
  int ecode2 = 0 ;
 
9914
  wxColour temp3 ;
 
9915
  PyObject * obj0 = 0 ;
 
9916
  PyObject * obj1 = 0 ;
 
9917
  PyObject * obj2 = 0 ;
 
9918
  char *  kwnames[] = {
 
9919
    (char *) "self",(char *) "item",(char *) "c", NULL 
 
9920
  };
 
9921
  
 
9922
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_SetItemBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
9923
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9924
  if (!SWIG_IsOK(res1)) {
 
9925
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_SetItemBackgroundColour" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9926
  }
 
9927
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9928
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
9929
  if (!SWIG_IsOK(ecode2)) {
 
9930
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListBox_SetItemBackgroundColour" "', expected argument " "2"" of type '" "int""'");
 
9931
  } 
 
9932
  arg2 = static_cast< int >(val2);
 
9933
  {
 
9934
    arg3 = &temp3;
 
9935
    if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
 
9936
  }
 
9937
  {
 
9938
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9939
    wxListBox_SetItemBackgroundColour(arg1,arg2,(wxColour const &)*arg3);
 
9940
    wxPyEndAllowThreads(__tstate);
 
9941
    if (PyErr_Occurred()) SWIG_fail;
 
9942
  }
 
9943
  resultobj = SWIG_Py_Void();
 
9944
  return resultobj;
 
9945
fail:
 
9946
  return NULL;
 
9947
}
 
9948
 
 
9949
 
 
9950
SWIGINTERN PyObject *_wrap_ListBox_SetItemFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
9951
  PyObject *resultobj = 0;
 
9952
  wxListBox *arg1 = (wxListBox *) 0 ;
 
9953
  int arg2 ;
 
9954
  wxFont *arg3 = 0 ;
 
9955
  void *argp1 = 0 ;
 
9956
  int res1 = 0 ;
 
9957
  int val2 ;
 
9958
  int ecode2 = 0 ;
 
9959
  void *argp3 = 0 ;
 
9960
  int res3 = 0 ;
 
9961
  PyObject * obj0 = 0 ;
 
9962
  PyObject * obj1 = 0 ;
 
9963
  PyObject * obj2 = 0 ;
 
9964
  char *  kwnames[] = {
 
9965
    (char *) "self",(char *) "item",(char *) "f", NULL 
 
9966
  };
 
9967
  
 
9968
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListBox_SetItemFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
9969
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListBox, 0 |  0 );
 
9970
  if (!SWIG_IsOK(res1)) {
 
9971
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListBox_SetItemFont" "', expected argument " "1"" of type '" "wxListBox *""'"); 
 
9972
  }
 
9973
  arg1 = reinterpret_cast< wxListBox * >(argp1);
 
9974
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
9975
  if (!SWIG_IsOK(ecode2)) {
 
9976
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListBox_SetItemFont" "', expected argument " "2"" of type '" "int""'");
 
9977
  } 
 
9978
  arg2 = static_cast< int >(val2);
 
9979
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxFont,  0  | 0);
 
9980
  if (!SWIG_IsOK(res3)) {
 
9981
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ListBox_SetItemFont" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
9982
  }
 
9983
  if (!argp3) {
 
9984
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListBox_SetItemFont" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
9985
  }
 
9986
  arg3 = reinterpret_cast< wxFont * >(argp3);
 
9987
  {
 
9988
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
9989
    wxListBox_SetItemFont(arg1,arg2,(wxFont const &)*arg3);
 
9990
    wxPyEndAllowThreads(__tstate);
 
9991
    if (PyErr_Occurred()) SWIG_fail;
 
9992
  }
 
9993
  resultobj = SWIG_Py_Void();
 
9994
  return resultobj;
 
9995
fail:
 
9996
  return NULL;
 
9997
}
 
9998
 
 
9999
 
 
10000
SWIGINTERN PyObject *_wrap_ListBox_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10001
  PyObject *resultobj = 0;
 
10002
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
10003
  SwigValueWrapper<wxVisualAttributes > result;
 
10004
  int val1 ;
 
10005
  int ecode1 = 0 ;
 
10006
  PyObject * obj0 = 0 ;
 
10007
  char *  kwnames[] = {
 
10008
    (char *) "variant", NULL 
 
10009
  };
 
10010
  
 
10011
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ListBox_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
10012
  if (obj0) {
 
10013
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
10014
    if (!SWIG_IsOK(ecode1)) {
 
10015
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ListBox_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
10016
    } 
 
10017
    arg1 = static_cast< wxWindowVariant >(val1);
 
10018
  }
 
10019
  {
 
10020
    if (!wxPyCheckForApp()) SWIG_fail;
 
10021
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10022
    result = wxListBox::GetClassDefaultAttributes(arg1);
 
10023
    wxPyEndAllowThreads(__tstate);
 
10024
    if (PyErr_Occurred()) SWIG_fail;
 
10025
  }
 
10026
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
10027
  return resultobj;
 
10028
fail:
 
10029
  return NULL;
 
10030
}
 
10031
 
 
10032
 
 
10033
SWIGINTERN PyObject *ListBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10034
  PyObject *obj;
 
10035
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
10036
  SWIG_TypeNewClientData(SWIGTYPE_p_wxListBox, SWIG_NewClientData(obj));
 
10037
  return SWIG_Py_Void();
 
10038
}
 
10039
 
 
10040
SWIGINTERN PyObject *ListBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10041
  return SWIG_Python_InitShadowInstance(args);
 
10042
}
 
10043
 
 
10044
SWIGINTERN PyObject *_wrap_new_CheckListBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10045
  PyObject *resultobj = 0;
 
10046
  wxWindow *arg1 = (wxWindow *) 0 ;
 
10047
  int arg2 = (int) -1 ;
 
10048
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
10049
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
10050
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
10051
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
10052
  wxArrayString const &arg5_defvalue = wxPyEmptyStringArray ;
 
10053
  wxArrayString *arg5 = (wxArrayString *) &arg5_defvalue ;
 
10054
  long arg6 = (long) 0 ;
 
10055
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
10056
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
10057
  wxString const &arg8_defvalue = wxPyListBoxNameStr ;
 
10058
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
10059
  wxCheckListBox *result = 0 ;
 
10060
  void *argp1 = 0 ;
 
10061
  int res1 = 0 ;
 
10062
  int val2 ;
 
10063
  int ecode2 = 0 ;
 
10064
  wxPoint temp3 ;
 
10065
  wxSize temp4 ;
 
10066
  bool temp5 = false ;
 
10067
  long val6 ;
 
10068
  int ecode6 = 0 ;
 
10069
  void *argp7 = 0 ;
 
10070
  int res7 = 0 ;
 
10071
  bool temp8 = false ;
 
10072
  PyObject * obj0 = 0 ;
 
10073
  PyObject * obj1 = 0 ;
 
10074
  PyObject * obj2 = 0 ;
 
10075
  PyObject * obj3 = 0 ;
 
10076
  PyObject * obj4 = 0 ;
 
10077
  PyObject * obj5 = 0 ;
 
10078
  PyObject * obj6 = 0 ;
 
10079
  PyObject * obj7 = 0 ;
 
10080
  char *  kwnames[] = {
 
10081
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
10082
  };
 
10083
  
 
10084
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_CheckListBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
10085
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
10086
  if (!SWIG_IsOK(res1)) {
 
10087
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CheckListBox" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
10088
  }
 
10089
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
10090
  if (obj1) {
 
10091
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
10092
    if (!SWIG_IsOK(ecode2)) {
 
10093
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CheckListBox" "', expected argument " "2"" of type '" "int""'");
 
10094
    } 
 
10095
    arg2 = static_cast< int >(val2);
 
10096
  }
 
10097
  if (obj2) {
 
10098
    {
 
10099
      arg3 = &temp3;
 
10100
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
10101
    }
 
10102
  }
 
10103
  if (obj3) {
 
10104
    {
 
10105
      arg4 = &temp4;
 
10106
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
10107
    }
 
10108
  }
 
10109
  if (obj4) {
 
10110
    {
 
10111
      if (! PySequence_Check(obj4)) {
 
10112
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
10113
        SWIG_fail;
 
10114
      }
 
10115
      arg5 = new wxArrayString;
 
10116
      temp5 = true;
 
10117
      int i, len=PySequence_Length(obj4);
 
10118
      for (i=0; i<len; i++) {
 
10119
        PyObject* item = PySequence_GetItem(obj4, i);
 
10120
        wxString* s = wxString_in_helper(item);
 
10121
        if (PyErr_Occurred())  SWIG_fail;
 
10122
        arg5->Add(*s);
 
10123
        delete s;
 
10124
        Py_DECREF(item);
 
10125
      }
 
10126
    }
 
10127
  }
 
10128
  if (obj5) {
 
10129
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
10130
    if (!SWIG_IsOK(ecode6)) {
 
10131
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CheckListBox" "', expected argument " "6"" of type '" "long""'");
 
10132
    } 
 
10133
    arg6 = static_cast< long >(val6);
 
10134
  }
 
10135
  if (obj6) {
 
10136
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
10137
    if (!SWIG_IsOK(res7)) {
 
10138
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CheckListBox" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
10139
    }
 
10140
    if (!argp7) {
 
10141
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CheckListBox" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
10142
    }
 
10143
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
10144
  }
 
10145
  if (obj7) {
 
10146
    {
 
10147
      arg8 = wxString_in_helper(obj7);
 
10148
      if (arg8 == NULL) SWIG_fail;
 
10149
      temp8 = true;
 
10150
    }
 
10151
  }
 
10152
  {
 
10153
    if (!wxPyCheckForApp()) SWIG_fail;
 
10154
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10155
    result = (wxCheckListBox *)new wxCheckListBox(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,(wxArrayString const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
10156
    wxPyEndAllowThreads(__tstate);
 
10157
    if (PyErr_Occurred()) SWIG_fail;
 
10158
  }
 
10159
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_NEW |  0 );
 
10160
  {
 
10161
    if (temp5) delete arg5;
 
10162
  }
 
10163
  {
 
10164
    if (temp8)
 
10165
    delete arg8;
 
10166
  }
 
10167
  return resultobj;
 
10168
fail:
 
10169
  {
 
10170
    if (temp5) delete arg5;
 
10171
  }
 
10172
  {
 
10173
    if (temp8)
 
10174
    delete arg8;
 
10175
  }
 
10176
  return NULL;
 
10177
}
 
10178
 
 
10179
 
 
10180
SWIGINTERN PyObject *_wrap_new_PreCheckListBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10181
  PyObject *resultobj = 0;
 
10182
  wxCheckListBox *result = 0 ;
 
10183
  
 
10184
  if (!SWIG_Python_UnpackTuple(args,"new_PreCheckListBox",0,0,0)) SWIG_fail;
 
10185
  {
 
10186
    if (!wxPyCheckForApp()) SWIG_fail;
 
10187
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10188
    result = (wxCheckListBox *)new wxCheckListBox();
 
10189
    wxPyEndAllowThreads(__tstate);
 
10190
    if (PyErr_Occurred()) SWIG_fail;
 
10191
  }
 
10192
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCheckListBox, SWIG_POINTER_OWN |  0 );
 
10193
  return resultobj;
 
10194
fail:
 
10195
  return NULL;
 
10196
}
 
10197
 
 
10198
 
 
10199
SWIGINTERN PyObject *_wrap_CheckListBox_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10200
  PyObject *resultobj = 0;
 
10201
  wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
 
10202
  wxWindow *arg2 = (wxWindow *) 0 ;
 
10203
  int arg3 = (int) -1 ;
 
10204
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
10205
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
10206
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
10207
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
10208
  wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
 
10209
  wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
 
10210
  long arg7 = (long) 0 ;
 
10211
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
10212
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
10213
  wxString const &arg9_defvalue = wxPyListBoxNameStr ;
 
10214
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
10215
  bool result;
 
10216
  void *argp1 = 0 ;
 
10217
  int res1 = 0 ;
 
10218
  void *argp2 = 0 ;
 
10219
  int res2 = 0 ;
 
10220
  int val3 ;
 
10221
  int ecode3 = 0 ;
 
10222
  wxPoint temp4 ;
 
10223
  wxSize temp5 ;
 
10224
  bool temp6 = false ;
 
10225
  long val7 ;
 
10226
  int ecode7 = 0 ;
 
10227
  void *argp8 = 0 ;
 
10228
  int res8 = 0 ;
 
10229
  bool temp9 = false ;
 
10230
  PyObject * obj0 = 0 ;
 
10231
  PyObject * obj1 = 0 ;
 
10232
  PyObject * obj2 = 0 ;
 
10233
  PyObject * obj3 = 0 ;
 
10234
  PyObject * obj4 = 0 ;
 
10235
  PyObject * obj5 = 0 ;
 
10236
  PyObject * obj6 = 0 ;
 
10237
  PyObject * obj7 = 0 ;
 
10238
  PyObject * obj8 = 0 ;
 
10239
  char *  kwnames[] = {
 
10240
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
10241
  };
 
10242
  
 
10243
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:CheckListBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
10244
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCheckListBox, 0 |  0 );
 
10245
  if (!SWIG_IsOK(res1)) {
 
10246
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckListBox_Create" "', expected argument " "1"" of type '" "wxCheckListBox *""'"); 
 
10247
  }
 
10248
  arg1 = reinterpret_cast< wxCheckListBox * >(argp1);
 
10249
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
10250
  if (!SWIG_IsOK(res2)) {
 
10251
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CheckListBox_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
10252
  }
 
10253
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
10254
  if (obj2) {
 
10255
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
10256
    if (!SWIG_IsOK(ecode3)) {
 
10257
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CheckListBox_Create" "', expected argument " "3"" of type '" "int""'");
 
10258
    } 
 
10259
    arg3 = static_cast< int >(val3);
 
10260
  }
 
10261
  if (obj3) {
 
10262
    {
 
10263
      arg4 = &temp4;
 
10264
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
10265
    }
 
10266
  }
 
10267
  if (obj4) {
 
10268
    {
 
10269
      arg5 = &temp5;
 
10270
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
10271
    }
 
10272
  }
 
10273
  if (obj5) {
 
10274
    {
 
10275
      if (! PySequence_Check(obj5)) {
 
10276
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
10277
        SWIG_fail;
 
10278
      }
 
10279
      arg6 = new wxArrayString;
 
10280
      temp6 = true;
 
10281
      int i, len=PySequence_Length(obj5);
 
10282
      for (i=0; i<len; i++) {
 
10283
        PyObject* item = PySequence_GetItem(obj5, i);
 
10284
        wxString* s = wxString_in_helper(item);
 
10285
        if (PyErr_Occurred())  SWIG_fail;
 
10286
        arg6->Add(*s);
 
10287
        delete s;
 
10288
        Py_DECREF(item);
 
10289
      }
 
10290
    }
 
10291
  }
 
10292
  if (obj6) {
 
10293
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
10294
    if (!SWIG_IsOK(ecode7)) {
 
10295
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CheckListBox_Create" "', expected argument " "7"" of type '" "long""'");
 
10296
    } 
 
10297
    arg7 = static_cast< long >(val7);
 
10298
  }
 
10299
  if (obj7) {
 
10300
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
10301
    if (!SWIG_IsOK(res8)) {
 
10302
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CheckListBox_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
10303
    }
 
10304
    if (!argp8) {
 
10305
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CheckListBox_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
10306
    }
 
10307
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
10308
  }
 
10309
  if (obj8) {
 
10310
    {
 
10311
      arg9 = wxString_in_helper(obj8);
 
10312
      if (arg9 == NULL) SWIG_fail;
 
10313
      temp9 = true;
 
10314
    }
 
10315
  }
 
10316
  {
 
10317
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10318
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
10319
    wxPyEndAllowThreads(__tstate);
 
10320
    if (PyErr_Occurred()) SWIG_fail;
 
10321
  }
 
10322
  {
 
10323
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
10324
  }
 
10325
  {
 
10326
    if (temp6) delete arg6;
 
10327
  }
 
10328
  {
 
10329
    if (temp9)
 
10330
    delete arg9;
 
10331
  }
 
10332
  return resultobj;
 
10333
fail:
 
10334
  {
 
10335
    if (temp6) delete arg6;
 
10336
  }
 
10337
  {
 
10338
    if (temp9)
 
10339
    delete arg9;
 
10340
  }
 
10341
  return NULL;
 
10342
}
 
10343
 
 
10344
 
 
10345
SWIGINTERN PyObject *_wrap_CheckListBox_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10346
  PyObject *resultobj = 0;
 
10347
  wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
 
10348
  unsigned int arg2 ;
 
10349
  bool result;
 
10350
  void *argp1 = 0 ;
 
10351
  int res1 = 0 ;
 
10352
  unsigned int val2 ;
 
10353
  int ecode2 = 0 ;
 
10354
  PyObject * obj0 = 0 ;
 
10355
  PyObject * obj1 = 0 ;
 
10356
  char *  kwnames[] = {
 
10357
    (char *) "self",(char *) "index", NULL 
 
10358
  };
 
10359
  
 
10360
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CheckListBox_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
 
10361
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCheckListBox, 0 |  0 );
 
10362
  if (!SWIG_IsOK(res1)) {
 
10363
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckListBox_IsChecked" "', expected argument " "1"" of type '" "wxCheckListBox *""'"); 
 
10364
  }
 
10365
  arg1 = reinterpret_cast< wxCheckListBox * >(argp1);
 
10366
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
10367
  if (!SWIG_IsOK(ecode2)) {
 
10368
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CheckListBox_IsChecked" "', expected argument " "2"" of type '" "unsigned int""'");
 
10369
  } 
 
10370
  arg2 = static_cast< unsigned int >(val2);
 
10371
  {
 
10372
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10373
    result = (bool)(arg1)->IsChecked(arg2);
 
10374
    wxPyEndAllowThreads(__tstate);
 
10375
    if (PyErr_Occurred()) SWIG_fail;
 
10376
  }
 
10377
  {
 
10378
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
10379
  }
 
10380
  return resultobj;
 
10381
fail:
 
10382
  return NULL;
 
10383
}
 
10384
 
 
10385
 
 
10386
SWIGINTERN PyObject *_wrap_CheckListBox_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10387
  PyObject *resultobj = 0;
 
10388
  wxCheckListBox *arg1 = (wxCheckListBox *) 0 ;
 
10389
  unsigned int arg2 ;
 
10390
  int arg3 = (int) true ;
 
10391
  void *argp1 = 0 ;
 
10392
  int res1 = 0 ;
 
10393
  unsigned int val2 ;
 
10394
  int ecode2 = 0 ;
 
10395
  int val3 ;
 
10396
  int ecode3 = 0 ;
 
10397
  PyObject * obj0 = 0 ;
 
10398
  PyObject * obj1 = 0 ;
 
10399
  PyObject * obj2 = 0 ;
 
10400
  char *  kwnames[] = {
 
10401
    (char *) "self",(char *) "index",(char *) "check", NULL 
 
10402
  };
 
10403
  
 
10404
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:CheckListBox_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
10405
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCheckListBox, 0 |  0 );
 
10406
  if (!SWIG_IsOK(res1)) {
 
10407
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckListBox_Check" "', expected argument " "1"" of type '" "wxCheckListBox *""'"); 
 
10408
  }
 
10409
  arg1 = reinterpret_cast< wxCheckListBox * >(argp1);
 
10410
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
10411
  if (!SWIG_IsOK(ecode2)) {
 
10412
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CheckListBox_Check" "', expected argument " "2"" of type '" "unsigned int""'");
 
10413
  } 
 
10414
  arg2 = static_cast< unsigned int >(val2);
 
10415
  if (obj2) {
 
10416
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
10417
    if (!SWIG_IsOK(ecode3)) {
 
10418
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CheckListBox_Check" "', expected argument " "3"" of type '" "int""'");
 
10419
    } 
 
10420
    arg3 = static_cast< int >(val3);
 
10421
  }
 
10422
  {
 
10423
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10424
    (arg1)->Check(arg2,arg3);
 
10425
    wxPyEndAllowThreads(__tstate);
 
10426
    if (PyErr_Occurred()) SWIG_fail;
 
10427
  }
 
10428
  resultobj = SWIG_Py_Void();
 
10429
  return resultobj;
 
10430
fail:
 
10431
  return NULL;
 
10432
}
 
10433
 
 
10434
 
 
10435
SWIGINTERN PyObject *CheckListBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10436
  PyObject *obj;
 
10437
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
10438
  SWIG_TypeNewClientData(SWIGTYPE_p_wxCheckListBox, SWIG_NewClientData(obj));
 
10439
  return SWIG_Py_Void();
 
10440
}
 
10441
 
 
10442
SWIGINTERN PyObject *CheckListBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10443
  return SWIG_Python_InitShadowInstance(args);
 
10444
}
 
10445
 
 
10446
SWIGINTERN int TextCtrlNameStr_set(PyObject *) {
 
10447
  SWIG_Error(SWIG_AttributeError,"Variable TextCtrlNameStr is read-only.");
 
10448
  return 1;
 
10449
}
 
10450
 
 
10451
 
 
10452
SWIGINTERN PyObject *TextCtrlNameStr_get(void) {
 
10453
  PyObject *pyobj = 0;
 
10454
  
 
10455
  {
 
10456
#if wxUSE_UNICODE
 
10457
    pyobj = PyUnicode_FromWideChar((&wxPyTextCtrlNameStr)->c_str(), (&wxPyTextCtrlNameStr)->Len());
 
10458
#else
 
10459
    pyobj = PyString_FromStringAndSize((&wxPyTextCtrlNameStr)->c_str(), (&wxPyTextCtrlNameStr)->Len());
 
10460
#endif
 
10461
  }
 
10462
  return pyobj;
 
10463
}
 
10464
 
 
10465
 
 
10466
SWIGINTERN PyObject *_wrap_new_TextAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10467
  PyObject *resultobj = 0;
 
10468
  wxColour const &arg1_defvalue = wxNullColour ;
 
10469
  wxColour *arg1 = (wxColour *) &arg1_defvalue ;
 
10470
  wxColour const &arg2_defvalue = wxNullColour ;
 
10471
  wxColour *arg2 = (wxColour *) &arg2_defvalue ;
 
10472
  wxFont const &arg3_defvalue = wxNullFont ;
 
10473
  wxFont *arg3 = (wxFont *) &arg3_defvalue ;
 
10474
  wxTextAttrAlignment arg4 = (wxTextAttrAlignment) wxTEXT_ALIGNMENT_DEFAULT ;
 
10475
  wxTextAttr *result = 0 ;
 
10476
  wxColour temp1 ;
 
10477
  wxColour temp2 ;
 
10478
  void *argp3 = 0 ;
 
10479
  int res3 = 0 ;
 
10480
  int val4 ;
 
10481
  int ecode4 = 0 ;
 
10482
  PyObject * obj0 = 0 ;
 
10483
  PyObject * obj1 = 0 ;
 
10484
  PyObject * obj2 = 0 ;
 
10485
  PyObject * obj3 = 0 ;
 
10486
  char *  kwnames[] = {
 
10487
    (char *) "colText",(char *) "colBack",(char *) "font",(char *) "alignment", NULL 
 
10488
  };
 
10489
  
 
10490
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TextAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
10491
  if (obj0) {
 
10492
    {
 
10493
      arg1 = &temp1;
 
10494
      if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
 
10495
    }
 
10496
  }
 
10497
  if (obj1) {
 
10498
    {
 
10499
      arg2 = &temp2;
 
10500
      if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
10501
    }
 
10502
  }
 
10503
  if (obj2) {
 
10504
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxFont,  0  | 0);
 
10505
    if (!SWIG_IsOK(res3)) {
 
10506
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TextAttr" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
10507
    }
 
10508
    if (!argp3) {
 
10509
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextAttr" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
10510
    }
 
10511
    arg3 = reinterpret_cast< wxFont * >(argp3);
 
10512
  }
 
10513
  if (obj3) {
 
10514
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
10515
    if (!SWIG_IsOK(ecode4)) {
 
10516
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TextAttr" "', expected argument " "4"" of type '" "wxTextAttrAlignment""'");
 
10517
    } 
 
10518
    arg4 = static_cast< wxTextAttrAlignment >(val4);
 
10519
  }
 
10520
  {
 
10521
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10522
    result = (wxTextAttr *)new wxTextAttr((wxColour const &)*arg1,(wxColour const &)*arg2,(wxFont const &)*arg3,arg4);
 
10523
    wxPyEndAllowThreads(__tstate);
 
10524
    if (PyErr_Occurred()) SWIG_fail;
 
10525
  }
 
10526
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextAttr, SWIG_POINTER_NEW |  0 );
 
10527
  return resultobj;
 
10528
fail:
 
10529
  return NULL;
 
10530
}
 
10531
 
 
10532
 
 
10533
SWIGINTERN PyObject *_wrap_delete_TextAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10534
  PyObject *resultobj = 0;
 
10535
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10536
  void *argp1 = 0 ;
 
10537
  int res1 = 0 ;
 
10538
  PyObject *swig_obj[1] ;
 
10539
  
 
10540
  if (!args) SWIG_fail;
 
10541
  swig_obj[0] = args;
 
10542
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, SWIG_POINTER_DISOWN |  0 );
 
10543
  if (!SWIG_IsOK(res1)) {
 
10544
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextAttr" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
10545
  }
 
10546
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10547
  {
 
10548
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10549
    delete arg1;
 
10550
    
 
10551
    wxPyEndAllowThreads(__tstate);
 
10552
    if (PyErr_Occurred()) SWIG_fail;
 
10553
  }
 
10554
  resultobj = SWIG_Py_Void();
 
10555
  return resultobj;
 
10556
fail:
 
10557
  return NULL;
 
10558
}
 
10559
 
 
10560
 
 
10561
SWIGINTERN PyObject *_wrap_TextAttr_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
10562
  PyObject *resultobj = 0;
 
10563
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10564
  void *argp1 = 0 ;
 
10565
  int res1 = 0 ;
 
10566
  PyObject *swig_obj[1] ;
 
10567
  
 
10568
  if (!args) SWIG_fail;
 
10569
  swig_obj[0] = args;
 
10570
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10571
  if (!SWIG_IsOK(res1)) {
 
10572
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_Init" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
10573
  }
 
10574
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10575
  {
 
10576
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10577
    (arg1)->Init();
 
10578
    wxPyEndAllowThreads(__tstate);
 
10579
    if (PyErr_Occurred()) SWIG_fail;
 
10580
  }
 
10581
  resultobj = SWIG_Py_Void();
 
10582
  return resultobj;
 
10583
fail:
 
10584
  return NULL;
 
10585
}
 
10586
 
 
10587
 
 
10588
SWIGINTERN PyObject *_wrap_TextAttr_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10589
  PyObject *resultobj = 0;
 
10590
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10591
  wxTextAttr *arg2 = 0 ;
 
10592
  void *argp1 = 0 ;
 
10593
  int res1 = 0 ;
 
10594
  void *argp2 = 0 ;
 
10595
  int res2 = 0 ;
 
10596
  PyObject * obj0 = 0 ;
 
10597
  PyObject * obj1 = 0 ;
 
10598
  char *  kwnames[] = {
 
10599
    (char *) "self",(char *) "attr", NULL 
 
10600
  };
 
10601
  
 
10602
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_Copy",kwnames,&obj0,&obj1)) SWIG_fail;
 
10603
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10604
  if (!SWIG_IsOK(res1)) {
 
10605
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_Copy" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
10606
  }
 
10607
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10608
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttr,  0  | 0);
 
10609
  if (!SWIG_IsOK(res2)) {
 
10610
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextAttr_Copy" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
10611
  }
 
10612
  if (!argp2) {
 
10613
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_Copy" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
10614
  }
 
10615
  arg2 = reinterpret_cast< wxTextAttr * >(argp2);
 
10616
  {
 
10617
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10618
    (arg1)->Copy((wxTextAttr const &)*arg2);
 
10619
    wxPyEndAllowThreads(__tstate);
 
10620
    if (PyErr_Occurred()) SWIG_fail;
 
10621
  }
 
10622
  resultobj = SWIG_Py_Void();
 
10623
  return resultobj;
 
10624
fail:
 
10625
  return NULL;
 
10626
}
 
10627
 
 
10628
 
 
10629
SWIGINTERN PyObject *_wrap_TextAttr_EqPartial(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10630
  PyObject *resultobj = 0;
 
10631
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10632
  wxTextAttr *arg2 = 0 ;
 
10633
  bool result;
 
10634
  void *argp1 = 0 ;
 
10635
  int res1 = 0 ;
 
10636
  void *argp2 = 0 ;
 
10637
  int res2 = 0 ;
 
10638
  PyObject * obj0 = 0 ;
 
10639
  PyObject * obj1 = 0 ;
 
10640
  char *  kwnames[] = {
 
10641
    (char *) "self",(char *) "attr", NULL 
 
10642
  };
 
10643
  
 
10644
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_EqPartial",kwnames,&obj0,&obj1)) SWIG_fail;
 
10645
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10646
  if (!SWIG_IsOK(res1)) {
 
10647
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_EqPartial" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
10648
  }
 
10649
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10650
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttr,  0  | 0);
 
10651
  if (!SWIG_IsOK(res2)) {
 
10652
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextAttr_EqPartial" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
10653
  }
 
10654
  if (!argp2) {
 
10655
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_EqPartial" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
10656
  }
 
10657
  arg2 = reinterpret_cast< wxTextAttr * >(argp2);
 
10658
  {
 
10659
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10660
    result = (bool)((wxTextAttr const *)arg1)->EqPartial((wxTextAttr const &)*arg2);
 
10661
    wxPyEndAllowThreads(__tstate);
 
10662
    if (PyErr_Occurred()) SWIG_fail;
 
10663
  }
 
10664
  {
 
10665
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
10666
  }
 
10667
  return resultobj;
 
10668
fail:
 
10669
  return NULL;
 
10670
}
 
10671
 
 
10672
 
 
10673
SWIGINTERN PyObject *_wrap_TextAttr_GetFontAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10674
  PyObject *resultobj = 0;
 
10675
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10676
  wxFont *arg2 = 0 ;
 
10677
  int arg3 = (int) wxTEXT_ATTR_FONT ;
 
10678
  bool result;
 
10679
  void *argp1 = 0 ;
 
10680
  int res1 = 0 ;
 
10681
  void *argp2 = 0 ;
 
10682
  int res2 = 0 ;
 
10683
  int val3 ;
 
10684
  int ecode3 = 0 ;
 
10685
  PyObject * obj0 = 0 ;
 
10686
  PyObject * obj1 = 0 ;
 
10687
  PyObject * obj2 = 0 ;
 
10688
  char *  kwnames[] = {
 
10689
    (char *) "self",(char *) "font",(char *) "flags", NULL 
 
10690
  };
 
10691
  
 
10692
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TextAttr_GetFontAttributes",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
10693
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10694
  if (!SWIG_IsOK(res1)) {
 
10695
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFontAttributes" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
10696
  }
 
10697
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10698
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont,  0  | 0);
 
10699
  if (!SWIG_IsOK(res2)) {
 
10700
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextAttr_GetFontAttributes" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
10701
  }
 
10702
  if (!argp2) {
 
10703
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_GetFontAttributes" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
10704
  }
 
10705
  arg2 = reinterpret_cast< wxFont * >(argp2);
 
10706
  if (obj2) {
 
10707
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
10708
    if (!SWIG_IsOK(ecode3)) {
 
10709
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextAttr_GetFontAttributes" "', expected argument " "3"" of type '" "int""'");
 
10710
    } 
 
10711
    arg3 = static_cast< int >(val3);
 
10712
  }
 
10713
  {
 
10714
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10715
    result = (bool)(arg1)->GetFontAttributes((wxFont const &)*arg2,arg3);
 
10716
    wxPyEndAllowThreads(__tstate);
 
10717
    if (PyErr_Occurred()) SWIG_fail;
 
10718
  }
 
10719
  {
 
10720
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
10721
  }
 
10722
  return resultobj;
 
10723
fail:
 
10724
  return NULL;
 
10725
}
 
10726
 
 
10727
 
 
10728
SWIGINTERN PyObject *_wrap_TextAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10729
  PyObject *resultobj = 0;
 
10730
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10731
  wxColour *arg2 = 0 ;
 
10732
  void *argp1 = 0 ;
 
10733
  int res1 = 0 ;
 
10734
  wxColour temp2 ;
 
10735
  PyObject * obj0 = 0 ;
 
10736
  PyObject * obj1 = 0 ;
 
10737
  char *  kwnames[] = {
 
10738
    (char *) "self",(char *) "colText", NULL 
 
10739
  };
 
10740
  
 
10741
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
10742
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10743
  if (!SWIG_IsOK(res1)) {
 
10744
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetTextColour" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
10745
  }
 
10746
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10747
  {
 
10748
    arg2 = &temp2;
 
10749
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
10750
  }
 
10751
  {
 
10752
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10753
    (arg1)->SetTextColour((wxColour const &)*arg2);
 
10754
    wxPyEndAllowThreads(__tstate);
 
10755
    if (PyErr_Occurred()) SWIG_fail;
 
10756
  }
 
10757
  resultobj = SWIG_Py_Void();
 
10758
  return resultobj;
 
10759
fail:
 
10760
  return NULL;
 
10761
}
 
10762
 
 
10763
 
 
10764
SWIGINTERN PyObject *_wrap_TextAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10765
  PyObject *resultobj = 0;
 
10766
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10767
  wxColour *arg2 = 0 ;
 
10768
  void *argp1 = 0 ;
 
10769
  int res1 = 0 ;
 
10770
  wxColour temp2 ;
 
10771
  PyObject * obj0 = 0 ;
 
10772
  PyObject * obj1 = 0 ;
 
10773
  char *  kwnames[] = {
 
10774
    (char *) "self",(char *) "colBack", NULL 
 
10775
  };
 
10776
  
 
10777
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
10778
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10779
  if (!SWIG_IsOK(res1)) {
 
10780
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
10781
  }
 
10782
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10783
  {
 
10784
    arg2 = &temp2;
 
10785
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
10786
  }
 
10787
  {
 
10788
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10789
    (arg1)->SetBackgroundColour((wxColour const &)*arg2);
 
10790
    wxPyEndAllowThreads(__tstate);
 
10791
    if (PyErr_Occurred()) SWIG_fail;
 
10792
  }
 
10793
  resultobj = SWIG_Py_Void();
 
10794
  return resultobj;
 
10795
fail:
 
10796
  return NULL;
 
10797
}
 
10798
 
 
10799
 
 
10800
SWIGINTERN PyObject *_wrap_TextAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10801
  PyObject *resultobj = 0;
 
10802
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10803
  wxTextAttrAlignment arg2 ;
 
10804
  void *argp1 = 0 ;
 
10805
  int res1 = 0 ;
 
10806
  int val2 ;
 
10807
  int ecode2 = 0 ;
 
10808
  PyObject * obj0 = 0 ;
 
10809
  PyObject * obj1 = 0 ;
 
10810
  char *  kwnames[] = {
 
10811
    (char *) "self",(char *) "alignment", NULL 
 
10812
  };
 
10813
  
 
10814
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetAlignment",kwnames,&obj0,&obj1)) SWIG_fail;
 
10815
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10816
  if (!SWIG_IsOK(res1)) {
 
10817
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetAlignment" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
10818
  }
 
10819
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10820
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
10821
  if (!SWIG_IsOK(ecode2)) {
 
10822
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetAlignment" "', expected argument " "2"" of type '" "wxTextAttrAlignment""'");
 
10823
  } 
 
10824
  arg2 = static_cast< wxTextAttrAlignment >(val2);
 
10825
  {
 
10826
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10827
    (arg1)->SetAlignment(arg2);
 
10828
    wxPyEndAllowThreads(__tstate);
 
10829
    if (PyErr_Occurred()) SWIG_fail;
 
10830
  }
 
10831
  resultobj = SWIG_Py_Void();
 
10832
  return resultobj;
 
10833
fail:
 
10834
  return NULL;
 
10835
}
 
10836
 
 
10837
 
 
10838
SWIGINTERN PyObject *_wrap_TextAttr_SetTabs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10839
  PyObject *resultobj = 0;
 
10840
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10841
  wxArrayInt *arg2 = 0 ;
 
10842
  void *argp1 = 0 ;
 
10843
  int res1 = 0 ;
 
10844
  bool temp2 = false ;
 
10845
  PyObject * obj0 = 0 ;
 
10846
  PyObject * obj1 = 0 ;
 
10847
  char *  kwnames[] = {
 
10848
    (char *) "self",(char *) "tabs", NULL 
 
10849
  };
 
10850
  
 
10851
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetTabs",kwnames,&obj0,&obj1)) SWIG_fail;
 
10852
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10853
  if (!SWIG_IsOK(res1)) {
 
10854
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetTabs" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
10855
  }
 
10856
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10857
  {
 
10858
    if (! PySequence_Check(obj1)) {
 
10859
      PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
 
10860
      SWIG_fail;
 
10861
    }
 
10862
    arg2 = new wxArrayInt;
 
10863
    temp2 = true;
 
10864
    int i, len=PySequence_Length(obj1);
 
10865
    for (i=0; i<len; i++) {
 
10866
      PyObject* item = PySequence_GetItem(obj1, i);
 
10867
      PyObject* number  = PyNumber_Int(item);
 
10868
      if (!number) {
 
10869
        PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
 
10870
        SWIG_fail;
 
10871
      }       
 
10872
      arg2->Add(PyInt_AS_LONG(number));
 
10873
      Py_DECREF(item);
 
10874
      Py_DECREF(number);
 
10875
    }
 
10876
  }
 
10877
  {
 
10878
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10879
    (arg1)->SetTabs((wxArrayInt const &)*arg2);
 
10880
    wxPyEndAllowThreads(__tstate);
 
10881
    if (PyErr_Occurred()) SWIG_fail;
 
10882
  }
 
10883
  resultobj = SWIG_Py_Void();
 
10884
  {
 
10885
    if (temp2) delete arg2;
 
10886
  }
 
10887
  return resultobj;
 
10888
fail:
 
10889
  {
 
10890
    if (temp2) delete arg2;
 
10891
  }
 
10892
  return NULL;
 
10893
}
 
10894
 
 
10895
 
 
10896
SWIGINTERN PyObject *_wrap_TextAttr_SetLeftIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10897
  PyObject *resultobj = 0;
 
10898
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10899
  int arg2 ;
 
10900
  int arg3 = (int) 0 ;
 
10901
  void *argp1 = 0 ;
 
10902
  int res1 = 0 ;
 
10903
  int val2 ;
 
10904
  int ecode2 = 0 ;
 
10905
  int val3 ;
 
10906
  int ecode3 = 0 ;
 
10907
  PyObject * obj0 = 0 ;
 
10908
  PyObject * obj1 = 0 ;
 
10909
  PyObject * obj2 = 0 ;
 
10910
  char *  kwnames[] = {
 
10911
    (char *) "self",(char *) "indent",(char *) "subIndent", NULL 
 
10912
  };
 
10913
  
 
10914
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TextAttr_SetLeftIndent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
10915
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10916
  if (!SWIG_IsOK(res1)) {
 
10917
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetLeftIndent" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
10918
  }
 
10919
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10920
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
10921
  if (!SWIG_IsOK(ecode2)) {
 
10922
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetLeftIndent" "', expected argument " "2"" of type '" "int""'");
 
10923
  } 
 
10924
  arg2 = static_cast< int >(val2);
 
10925
  if (obj2) {
 
10926
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
10927
    if (!SWIG_IsOK(ecode3)) {
 
10928
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextAttr_SetLeftIndent" "', expected argument " "3"" of type '" "int""'");
 
10929
    } 
 
10930
    arg3 = static_cast< int >(val3);
 
10931
  }
 
10932
  {
 
10933
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10934
    (arg1)->SetLeftIndent(arg2,arg3);
 
10935
    wxPyEndAllowThreads(__tstate);
 
10936
    if (PyErr_Occurred()) SWIG_fail;
 
10937
  }
 
10938
  resultobj = SWIG_Py_Void();
 
10939
  return resultobj;
 
10940
fail:
 
10941
  return NULL;
 
10942
}
 
10943
 
 
10944
 
 
10945
SWIGINTERN PyObject *_wrap_TextAttr_SetRightIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10946
  PyObject *resultobj = 0;
 
10947
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10948
  int arg2 ;
 
10949
  void *argp1 = 0 ;
 
10950
  int res1 = 0 ;
 
10951
  int val2 ;
 
10952
  int ecode2 = 0 ;
 
10953
  PyObject * obj0 = 0 ;
 
10954
  PyObject * obj1 = 0 ;
 
10955
  char *  kwnames[] = {
 
10956
    (char *) "self",(char *) "indent", NULL 
 
10957
  };
 
10958
  
 
10959
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetRightIndent",kwnames,&obj0,&obj1)) SWIG_fail;
 
10960
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10961
  if (!SWIG_IsOK(res1)) {
 
10962
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetRightIndent" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
10963
  }
 
10964
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
10965
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
10966
  if (!SWIG_IsOK(ecode2)) {
 
10967
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetRightIndent" "', expected argument " "2"" of type '" "int""'");
 
10968
  } 
 
10969
  arg2 = static_cast< int >(val2);
 
10970
  {
 
10971
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
10972
    (arg1)->SetRightIndent(arg2);
 
10973
    wxPyEndAllowThreads(__tstate);
 
10974
    if (PyErr_Occurred()) SWIG_fail;
 
10975
  }
 
10976
  resultobj = SWIG_Py_Void();
 
10977
  return resultobj;
 
10978
fail:
 
10979
  return NULL;
 
10980
}
 
10981
 
 
10982
 
 
10983
SWIGINTERN PyObject *_wrap_TextAttr_SetFontSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
10984
  PyObject *resultobj = 0;
 
10985
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
10986
  int arg2 ;
 
10987
  void *argp1 = 0 ;
 
10988
  int res1 = 0 ;
 
10989
  int val2 ;
 
10990
  int ecode2 = 0 ;
 
10991
  PyObject * obj0 = 0 ;
 
10992
  PyObject * obj1 = 0 ;
 
10993
  char *  kwnames[] = {
 
10994
    (char *) "self",(char *) "pointSize", NULL 
 
10995
  };
 
10996
  
 
10997
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFontSize",kwnames,&obj0,&obj1)) SWIG_fail;
 
10998
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
10999
  if (!SWIG_IsOK(res1)) {
 
11000
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetFontSize" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11001
  }
 
11002
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11003
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11004
  if (!SWIG_IsOK(ecode2)) {
 
11005
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetFontSize" "', expected argument " "2"" of type '" "int""'");
 
11006
  } 
 
11007
  arg2 = static_cast< int >(val2);
 
11008
  {
 
11009
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11010
    (arg1)->SetFontSize(arg2);
 
11011
    wxPyEndAllowThreads(__tstate);
 
11012
    if (PyErr_Occurred()) SWIG_fail;
 
11013
  }
 
11014
  resultobj = SWIG_Py_Void();
 
11015
  return resultobj;
 
11016
fail:
 
11017
  return NULL;
 
11018
}
 
11019
 
 
11020
 
 
11021
SWIGINTERN PyObject *_wrap_TextAttr_SetFontStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11022
  PyObject *resultobj = 0;
 
11023
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11024
  wxFontStyle arg2 ;
 
11025
  void *argp1 = 0 ;
 
11026
  int res1 = 0 ;
 
11027
  int val2 ;
 
11028
  int ecode2 = 0 ;
 
11029
  PyObject * obj0 = 0 ;
 
11030
  PyObject * obj1 = 0 ;
 
11031
  char *  kwnames[] = {
 
11032
    (char *) "self",(char *) "fontStyle", NULL 
 
11033
  };
 
11034
  
 
11035
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFontStyle",kwnames,&obj0,&obj1)) SWIG_fail;
 
11036
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11037
  if (!SWIG_IsOK(res1)) {
 
11038
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetFontStyle" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11039
  }
 
11040
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11041
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11042
  if (!SWIG_IsOK(ecode2)) {
 
11043
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetFontStyle" "', expected argument " "2"" of type '" "wxFontStyle""'");
 
11044
  } 
 
11045
  arg2 = static_cast< wxFontStyle >(val2);
 
11046
  {
 
11047
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11048
    (arg1)->SetFontStyle(arg2);
 
11049
    wxPyEndAllowThreads(__tstate);
 
11050
    if (PyErr_Occurred()) SWIG_fail;
 
11051
  }
 
11052
  resultobj = SWIG_Py_Void();
 
11053
  return resultobj;
 
11054
fail:
 
11055
  return NULL;
 
11056
}
 
11057
 
 
11058
 
 
11059
SWIGINTERN PyObject *_wrap_TextAttr_SetFontWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11060
  PyObject *resultobj = 0;
 
11061
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11062
  wxFontWeight arg2 ;
 
11063
  void *argp1 = 0 ;
 
11064
  int res1 = 0 ;
 
11065
  int val2 ;
 
11066
  int ecode2 = 0 ;
 
11067
  PyObject * obj0 = 0 ;
 
11068
  PyObject * obj1 = 0 ;
 
11069
  char *  kwnames[] = {
 
11070
    (char *) "self",(char *) "fontWeight", NULL 
 
11071
  };
 
11072
  
 
11073
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFontWeight",kwnames,&obj0,&obj1)) SWIG_fail;
 
11074
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11075
  if (!SWIG_IsOK(res1)) {
 
11076
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetFontWeight" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11077
  }
 
11078
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11079
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11080
  if (!SWIG_IsOK(ecode2)) {
 
11081
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetFontWeight" "', expected argument " "2"" of type '" "wxFontWeight""'");
 
11082
  } 
 
11083
  arg2 = static_cast< wxFontWeight >(val2);
 
11084
  {
 
11085
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11086
    (arg1)->SetFontWeight(arg2);
 
11087
    wxPyEndAllowThreads(__tstate);
 
11088
    if (PyErr_Occurred()) SWIG_fail;
 
11089
  }
 
11090
  resultobj = SWIG_Py_Void();
 
11091
  return resultobj;
 
11092
fail:
 
11093
  return NULL;
 
11094
}
 
11095
 
 
11096
 
 
11097
SWIGINTERN PyObject *_wrap_TextAttr_SetFontFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11098
  PyObject *resultobj = 0;
 
11099
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11100
  wxString *arg2 = 0 ;
 
11101
  void *argp1 = 0 ;
 
11102
  int res1 = 0 ;
 
11103
  bool temp2 = false ;
 
11104
  PyObject * obj0 = 0 ;
 
11105
  PyObject * obj1 = 0 ;
 
11106
  char *  kwnames[] = {
 
11107
    (char *) "self",(char *) "faceName", NULL 
 
11108
  };
 
11109
  
 
11110
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFontFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
 
11111
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11112
  if (!SWIG_IsOK(res1)) {
 
11113
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetFontFaceName" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11114
  }
 
11115
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11116
  {
 
11117
    arg2 = wxString_in_helper(obj1);
 
11118
    if (arg2 == NULL) SWIG_fail;
 
11119
    temp2 = true;
 
11120
  }
 
11121
  {
 
11122
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11123
    (arg1)->SetFontFaceName((wxString const &)*arg2);
 
11124
    wxPyEndAllowThreads(__tstate);
 
11125
    if (PyErr_Occurred()) SWIG_fail;
 
11126
  }
 
11127
  resultobj = SWIG_Py_Void();
 
11128
  {
 
11129
    if (temp2)
 
11130
    delete arg2;
 
11131
  }
 
11132
  return resultobj;
 
11133
fail:
 
11134
  {
 
11135
    if (temp2)
 
11136
    delete arg2;
 
11137
  }
 
11138
  return NULL;
 
11139
}
 
11140
 
 
11141
 
 
11142
SWIGINTERN PyObject *_wrap_TextAttr_SetFontUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11143
  PyObject *resultobj = 0;
 
11144
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11145
  bool arg2 ;
 
11146
  void *argp1 = 0 ;
 
11147
  int res1 = 0 ;
 
11148
  bool val2 ;
 
11149
  int ecode2 = 0 ;
 
11150
  PyObject * obj0 = 0 ;
 
11151
  PyObject * obj1 = 0 ;
 
11152
  char *  kwnames[] = {
 
11153
    (char *) "self",(char *) "underlined", NULL 
 
11154
  };
 
11155
  
 
11156
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFontUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
 
11157
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11158
  if (!SWIG_IsOK(res1)) {
 
11159
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetFontUnderlined" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11160
  }
 
11161
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11162
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
11163
  if (!SWIG_IsOK(ecode2)) {
 
11164
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetFontUnderlined" "', expected argument " "2"" of type '" "bool""'");
 
11165
  } 
 
11166
  arg2 = static_cast< bool >(val2);
 
11167
  {
 
11168
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11169
    (arg1)->SetFontUnderlined(arg2);
 
11170
    wxPyEndAllowThreads(__tstate);
 
11171
    if (PyErr_Occurred()) SWIG_fail;
 
11172
  }
 
11173
  resultobj = SWIG_Py_Void();
 
11174
  return resultobj;
 
11175
fail:
 
11176
  return NULL;
 
11177
}
 
11178
 
 
11179
 
 
11180
SWIGINTERN PyObject *_wrap_TextAttr_SetFontStrikethrough(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11181
  PyObject *resultobj = 0;
 
11182
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11183
  bool arg2 ;
 
11184
  void *argp1 = 0 ;
 
11185
  int res1 = 0 ;
 
11186
  bool val2 ;
 
11187
  int ecode2 = 0 ;
 
11188
  PyObject * obj0 = 0 ;
 
11189
  PyObject * obj1 = 0 ;
 
11190
  char *  kwnames[] = {
 
11191
    (char *) "self",(char *) "strikethrough", NULL 
 
11192
  };
 
11193
  
 
11194
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFontStrikethrough",kwnames,&obj0,&obj1)) SWIG_fail;
 
11195
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11196
  if (!SWIG_IsOK(res1)) {
 
11197
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetFontStrikethrough" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11198
  }
 
11199
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11200
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
11201
  if (!SWIG_IsOK(ecode2)) {
 
11202
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetFontStrikethrough" "', expected argument " "2"" of type '" "bool""'");
 
11203
  } 
 
11204
  arg2 = static_cast< bool >(val2);
 
11205
  {
 
11206
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11207
    (arg1)->SetFontStrikethrough(arg2);
 
11208
    wxPyEndAllowThreads(__tstate);
 
11209
    if (PyErr_Occurred()) SWIG_fail;
 
11210
  }
 
11211
  resultobj = SWIG_Py_Void();
 
11212
  return resultobj;
 
11213
fail:
 
11214
  return NULL;
 
11215
}
 
11216
 
 
11217
 
 
11218
SWIGINTERN PyObject *_wrap_TextAttr_SetFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11219
  PyObject *resultobj = 0;
 
11220
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11221
  wxFontEncoding arg2 ;
 
11222
  void *argp1 = 0 ;
 
11223
  int res1 = 0 ;
 
11224
  int val2 ;
 
11225
  int ecode2 = 0 ;
 
11226
  PyObject * obj0 = 0 ;
 
11227
  PyObject * obj1 = 0 ;
 
11228
  char *  kwnames[] = {
 
11229
    (char *) "self",(char *) "encoding", NULL 
 
11230
  };
 
11231
  
 
11232
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFontEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
 
11233
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11234
  if (!SWIG_IsOK(res1)) {
 
11235
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetFontEncoding" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11236
  }
 
11237
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11238
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11239
  if (!SWIG_IsOK(ecode2)) {
 
11240
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetFontEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
 
11241
  } 
 
11242
  arg2 = static_cast< wxFontEncoding >(val2);
 
11243
  {
 
11244
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11245
    (arg1)->SetFontEncoding(arg2);
 
11246
    wxPyEndAllowThreads(__tstate);
 
11247
    if (PyErr_Occurred()) SWIG_fail;
 
11248
  }
 
11249
  resultobj = SWIG_Py_Void();
 
11250
  return resultobj;
 
11251
fail:
 
11252
  return NULL;
 
11253
}
 
11254
 
 
11255
 
 
11256
SWIGINTERN PyObject *_wrap_TextAttr_SetFontFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11257
  PyObject *resultobj = 0;
 
11258
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11259
  wxFontFamily arg2 ;
 
11260
  void *argp1 = 0 ;
 
11261
  int res1 = 0 ;
 
11262
  int val2 ;
 
11263
  int ecode2 = 0 ;
 
11264
  PyObject * obj0 = 0 ;
 
11265
  PyObject * obj1 = 0 ;
 
11266
  char *  kwnames[] = {
 
11267
    (char *) "self",(char *) "family", NULL 
 
11268
  };
 
11269
  
 
11270
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFontFamily",kwnames,&obj0,&obj1)) SWIG_fail;
 
11271
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11272
  if (!SWIG_IsOK(res1)) {
 
11273
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetFontFamily" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11274
  }
 
11275
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11276
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11277
  if (!SWIG_IsOK(ecode2)) {
 
11278
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetFontFamily" "', expected argument " "2"" of type '" "wxFontFamily""'");
 
11279
  } 
 
11280
  arg2 = static_cast< wxFontFamily >(val2);
 
11281
  {
 
11282
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11283
    (arg1)->SetFontFamily(arg2);
 
11284
    wxPyEndAllowThreads(__tstate);
 
11285
    if (PyErr_Occurred()) SWIG_fail;
 
11286
  }
 
11287
  resultobj = SWIG_Py_Void();
 
11288
  return resultobj;
 
11289
fail:
 
11290
  return NULL;
 
11291
}
 
11292
 
 
11293
 
 
11294
SWIGINTERN PyObject *_wrap_TextAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11295
  PyObject *resultobj = 0;
 
11296
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11297
  wxFont *arg2 = 0 ;
 
11298
  int arg3 = (int) wxTEXT_ATTR_FONT ;
 
11299
  void *argp1 = 0 ;
 
11300
  int res1 = 0 ;
 
11301
  void *argp2 = 0 ;
 
11302
  int res2 = 0 ;
 
11303
  int val3 ;
 
11304
  int ecode3 = 0 ;
 
11305
  PyObject * obj0 = 0 ;
 
11306
  PyObject * obj1 = 0 ;
 
11307
  PyObject * obj2 = 0 ;
 
11308
  char *  kwnames[] = {
 
11309
    (char *) "self",(char *) "font",(char *) "flags", NULL 
 
11310
  };
 
11311
  
 
11312
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TextAttr_SetFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
11313
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11314
  if (!SWIG_IsOK(res1)) {
 
11315
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetFont" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11316
  }
 
11317
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11318
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont,  0  | 0);
 
11319
  if (!SWIG_IsOK(res2)) {
 
11320
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
11321
  }
 
11322
  if (!argp2) {
 
11323
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
11324
  }
 
11325
  arg2 = reinterpret_cast< wxFont * >(argp2);
 
11326
  if (obj2) {
 
11327
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
11328
    if (!SWIG_IsOK(ecode3)) {
 
11329
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextAttr_SetFont" "', expected argument " "3"" of type '" "int""'");
 
11330
    } 
 
11331
    arg3 = static_cast< int >(val3);
 
11332
  }
 
11333
  {
 
11334
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11335
    (arg1)->SetFont((wxFont const &)*arg2,arg3);
 
11336
    wxPyEndAllowThreads(__tstate);
 
11337
    if (PyErr_Occurred()) SWIG_fail;
 
11338
  }
 
11339
  resultobj = SWIG_Py_Void();
 
11340
  return resultobj;
 
11341
fail:
 
11342
  return NULL;
 
11343
}
 
11344
 
 
11345
 
 
11346
SWIGINTERN PyObject *_wrap_TextAttr_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11347
  PyObject *resultobj = 0;
 
11348
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11349
  long arg2 ;
 
11350
  void *argp1 = 0 ;
 
11351
  int res1 = 0 ;
 
11352
  long val2 ;
 
11353
  int ecode2 = 0 ;
 
11354
  PyObject * obj0 = 0 ;
 
11355
  PyObject * obj1 = 0 ;
 
11356
  char *  kwnames[] = {
 
11357
    (char *) "self",(char *) "flags", NULL 
 
11358
  };
 
11359
  
 
11360
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
 
11361
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11362
  if (!SWIG_IsOK(res1)) {
 
11363
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetFlags" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11364
  }
 
11365
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11366
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
11367
  if (!SWIG_IsOK(ecode2)) {
 
11368
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetFlags" "', expected argument " "2"" of type '" "long""'");
 
11369
  } 
 
11370
  arg2 = static_cast< long >(val2);
 
11371
  {
 
11372
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11373
    (arg1)->SetFlags(arg2);
 
11374
    wxPyEndAllowThreads(__tstate);
 
11375
    if (PyErr_Occurred()) SWIG_fail;
 
11376
  }
 
11377
  resultobj = SWIG_Py_Void();
 
11378
  return resultobj;
 
11379
fail:
 
11380
  return NULL;
 
11381
}
 
11382
 
 
11383
 
 
11384
SWIGINTERN PyObject *_wrap_TextAttr_SetCharacterStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11385
  PyObject *resultobj = 0;
 
11386
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11387
  wxString *arg2 = 0 ;
 
11388
  void *argp1 = 0 ;
 
11389
  int res1 = 0 ;
 
11390
  bool temp2 = false ;
 
11391
  PyObject * obj0 = 0 ;
 
11392
  PyObject * obj1 = 0 ;
 
11393
  char *  kwnames[] = {
 
11394
    (char *) "self",(char *) "name", NULL 
 
11395
  };
 
11396
  
 
11397
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetCharacterStyleName",kwnames,&obj0,&obj1)) SWIG_fail;
 
11398
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11399
  if (!SWIG_IsOK(res1)) {
 
11400
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetCharacterStyleName" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11401
  }
 
11402
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11403
  {
 
11404
    arg2 = wxString_in_helper(obj1);
 
11405
    if (arg2 == NULL) SWIG_fail;
 
11406
    temp2 = true;
 
11407
  }
 
11408
  {
 
11409
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11410
    (arg1)->SetCharacterStyleName((wxString const &)*arg2);
 
11411
    wxPyEndAllowThreads(__tstate);
 
11412
    if (PyErr_Occurred()) SWIG_fail;
 
11413
  }
 
11414
  resultobj = SWIG_Py_Void();
 
11415
  {
 
11416
    if (temp2)
 
11417
    delete arg2;
 
11418
  }
 
11419
  return resultobj;
 
11420
fail:
 
11421
  {
 
11422
    if (temp2)
 
11423
    delete arg2;
 
11424
  }
 
11425
  return NULL;
 
11426
}
 
11427
 
 
11428
 
 
11429
SWIGINTERN PyObject *_wrap_TextAttr_SetParagraphStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11430
  PyObject *resultobj = 0;
 
11431
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11432
  wxString *arg2 = 0 ;
 
11433
  void *argp1 = 0 ;
 
11434
  int res1 = 0 ;
 
11435
  bool temp2 = false ;
 
11436
  PyObject * obj0 = 0 ;
 
11437
  PyObject * obj1 = 0 ;
 
11438
  char *  kwnames[] = {
 
11439
    (char *) "self",(char *) "name", NULL 
 
11440
  };
 
11441
  
 
11442
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetParagraphStyleName",kwnames,&obj0,&obj1)) SWIG_fail;
 
11443
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11444
  if (!SWIG_IsOK(res1)) {
 
11445
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetParagraphStyleName" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11446
  }
 
11447
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11448
  {
 
11449
    arg2 = wxString_in_helper(obj1);
 
11450
    if (arg2 == NULL) SWIG_fail;
 
11451
    temp2 = true;
 
11452
  }
 
11453
  {
 
11454
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11455
    (arg1)->SetParagraphStyleName((wxString const &)*arg2);
 
11456
    wxPyEndAllowThreads(__tstate);
 
11457
    if (PyErr_Occurred()) SWIG_fail;
 
11458
  }
 
11459
  resultobj = SWIG_Py_Void();
 
11460
  {
 
11461
    if (temp2)
 
11462
    delete arg2;
 
11463
  }
 
11464
  return resultobj;
 
11465
fail:
 
11466
  {
 
11467
    if (temp2)
 
11468
    delete arg2;
 
11469
  }
 
11470
  return NULL;
 
11471
}
 
11472
 
 
11473
 
 
11474
SWIGINTERN PyObject *_wrap_TextAttr_SetListStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11475
  PyObject *resultobj = 0;
 
11476
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11477
  wxString *arg2 = 0 ;
 
11478
  void *argp1 = 0 ;
 
11479
  int res1 = 0 ;
 
11480
  bool temp2 = false ;
 
11481
  PyObject * obj0 = 0 ;
 
11482
  PyObject * obj1 = 0 ;
 
11483
  char *  kwnames[] = {
 
11484
    (char *) "self",(char *) "name", NULL 
 
11485
  };
 
11486
  
 
11487
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetListStyleName",kwnames,&obj0,&obj1)) SWIG_fail;
 
11488
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11489
  if (!SWIG_IsOK(res1)) {
 
11490
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetListStyleName" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11491
  }
 
11492
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11493
  {
 
11494
    arg2 = wxString_in_helper(obj1);
 
11495
    if (arg2 == NULL) SWIG_fail;
 
11496
    temp2 = true;
 
11497
  }
 
11498
  {
 
11499
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11500
    (arg1)->SetListStyleName((wxString const &)*arg2);
 
11501
    wxPyEndAllowThreads(__tstate);
 
11502
    if (PyErr_Occurred()) SWIG_fail;
 
11503
  }
 
11504
  resultobj = SWIG_Py_Void();
 
11505
  {
 
11506
    if (temp2)
 
11507
    delete arg2;
 
11508
  }
 
11509
  return resultobj;
 
11510
fail:
 
11511
  {
 
11512
    if (temp2)
 
11513
    delete arg2;
 
11514
  }
 
11515
  return NULL;
 
11516
}
 
11517
 
 
11518
 
 
11519
SWIGINTERN PyObject *_wrap_TextAttr_SetParagraphSpacingAfter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11520
  PyObject *resultobj = 0;
 
11521
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11522
  int arg2 ;
 
11523
  void *argp1 = 0 ;
 
11524
  int res1 = 0 ;
 
11525
  int val2 ;
 
11526
  int ecode2 = 0 ;
 
11527
  PyObject * obj0 = 0 ;
 
11528
  PyObject * obj1 = 0 ;
 
11529
  char *  kwnames[] = {
 
11530
    (char *) "self",(char *) "spacing", NULL 
 
11531
  };
 
11532
  
 
11533
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetParagraphSpacingAfter",kwnames,&obj0,&obj1)) SWIG_fail;
 
11534
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11535
  if (!SWIG_IsOK(res1)) {
 
11536
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetParagraphSpacingAfter" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11537
  }
 
11538
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11539
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11540
  if (!SWIG_IsOK(ecode2)) {
 
11541
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetParagraphSpacingAfter" "', expected argument " "2"" of type '" "int""'");
 
11542
  } 
 
11543
  arg2 = static_cast< int >(val2);
 
11544
  {
 
11545
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11546
    (arg1)->SetParagraphSpacingAfter(arg2);
 
11547
    wxPyEndAllowThreads(__tstate);
 
11548
    if (PyErr_Occurred()) SWIG_fail;
 
11549
  }
 
11550
  resultobj = SWIG_Py_Void();
 
11551
  return resultobj;
 
11552
fail:
 
11553
  return NULL;
 
11554
}
 
11555
 
 
11556
 
 
11557
SWIGINTERN PyObject *_wrap_TextAttr_SetParagraphSpacingBefore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11558
  PyObject *resultobj = 0;
 
11559
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11560
  int arg2 ;
 
11561
  void *argp1 = 0 ;
 
11562
  int res1 = 0 ;
 
11563
  int val2 ;
 
11564
  int ecode2 = 0 ;
 
11565
  PyObject * obj0 = 0 ;
 
11566
  PyObject * obj1 = 0 ;
 
11567
  char *  kwnames[] = {
 
11568
    (char *) "self",(char *) "spacing", NULL 
 
11569
  };
 
11570
  
 
11571
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetParagraphSpacingBefore",kwnames,&obj0,&obj1)) SWIG_fail;
 
11572
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11573
  if (!SWIG_IsOK(res1)) {
 
11574
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetParagraphSpacingBefore" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11575
  }
 
11576
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11577
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11578
  if (!SWIG_IsOK(ecode2)) {
 
11579
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetParagraphSpacingBefore" "', expected argument " "2"" of type '" "int""'");
 
11580
  } 
 
11581
  arg2 = static_cast< int >(val2);
 
11582
  {
 
11583
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11584
    (arg1)->SetParagraphSpacingBefore(arg2);
 
11585
    wxPyEndAllowThreads(__tstate);
 
11586
    if (PyErr_Occurred()) SWIG_fail;
 
11587
  }
 
11588
  resultobj = SWIG_Py_Void();
 
11589
  return resultobj;
 
11590
fail:
 
11591
  return NULL;
 
11592
}
 
11593
 
 
11594
 
 
11595
SWIGINTERN PyObject *_wrap_TextAttr_SetLineSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11596
  PyObject *resultobj = 0;
 
11597
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11598
  int arg2 ;
 
11599
  void *argp1 = 0 ;
 
11600
  int res1 = 0 ;
 
11601
  int val2 ;
 
11602
  int ecode2 = 0 ;
 
11603
  PyObject * obj0 = 0 ;
 
11604
  PyObject * obj1 = 0 ;
 
11605
  char *  kwnames[] = {
 
11606
    (char *) "self",(char *) "spacing", NULL 
 
11607
  };
 
11608
  
 
11609
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetLineSpacing",kwnames,&obj0,&obj1)) SWIG_fail;
 
11610
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11611
  if (!SWIG_IsOK(res1)) {
 
11612
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetLineSpacing" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11613
  }
 
11614
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11615
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11616
  if (!SWIG_IsOK(ecode2)) {
 
11617
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetLineSpacing" "', expected argument " "2"" of type '" "int""'");
 
11618
  } 
 
11619
  arg2 = static_cast< int >(val2);
 
11620
  {
 
11621
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11622
    (arg1)->SetLineSpacing(arg2);
 
11623
    wxPyEndAllowThreads(__tstate);
 
11624
    if (PyErr_Occurred()) SWIG_fail;
 
11625
  }
 
11626
  resultobj = SWIG_Py_Void();
 
11627
  return resultobj;
 
11628
fail:
 
11629
  return NULL;
 
11630
}
 
11631
 
 
11632
 
 
11633
SWIGINTERN PyObject *_wrap_TextAttr_SetBulletStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11634
  PyObject *resultobj = 0;
 
11635
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11636
  int arg2 ;
 
11637
  void *argp1 = 0 ;
 
11638
  int res1 = 0 ;
 
11639
  int val2 ;
 
11640
  int ecode2 = 0 ;
 
11641
  PyObject * obj0 = 0 ;
 
11642
  PyObject * obj1 = 0 ;
 
11643
  char *  kwnames[] = {
 
11644
    (char *) "self",(char *) "style", NULL 
 
11645
  };
 
11646
  
 
11647
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetBulletStyle",kwnames,&obj0,&obj1)) SWIG_fail;
 
11648
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11649
  if (!SWIG_IsOK(res1)) {
 
11650
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetBulletStyle" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11651
  }
 
11652
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11653
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11654
  if (!SWIG_IsOK(ecode2)) {
 
11655
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetBulletStyle" "', expected argument " "2"" of type '" "int""'");
 
11656
  } 
 
11657
  arg2 = static_cast< int >(val2);
 
11658
  {
 
11659
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11660
    (arg1)->SetBulletStyle(arg2);
 
11661
    wxPyEndAllowThreads(__tstate);
 
11662
    if (PyErr_Occurred()) SWIG_fail;
 
11663
  }
 
11664
  resultobj = SWIG_Py_Void();
 
11665
  return resultobj;
 
11666
fail:
 
11667
  return NULL;
 
11668
}
 
11669
 
 
11670
 
 
11671
SWIGINTERN PyObject *_wrap_TextAttr_SetBulletNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11672
  PyObject *resultobj = 0;
 
11673
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11674
  int arg2 ;
 
11675
  void *argp1 = 0 ;
 
11676
  int res1 = 0 ;
 
11677
  int val2 ;
 
11678
  int ecode2 = 0 ;
 
11679
  PyObject * obj0 = 0 ;
 
11680
  PyObject * obj1 = 0 ;
 
11681
  char *  kwnames[] = {
 
11682
    (char *) "self",(char *) "n", NULL 
 
11683
  };
 
11684
  
 
11685
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetBulletNumber",kwnames,&obj0,&obj1)) SWIG_fail;
 
11686
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11687
  if (!SWIG_IsOK(res1)) {
 
11688
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetBulletNumber" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11689
  }
 
11690
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11691
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11692
  if (!SWIG_IsOK(ecode2)) {
 
11693
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetBulletNumber" "', expected argument " "2"" of type '" "int""'");
 
11694
  } 
 
11695
  arg2 = static_cast< int >(val2);
 
11696
  {
 
11697
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11698
    (arg1)->SetBulletNumber(arg2);
 
11699
    wxPyEndAllowThreads(__tstate);
 
11700
    if (PyErr_Occurred()) SWIG_fail;
 
11701
  }
 
11702
  resultobj = SWIG_Py_Void();
 
11703
  return resultobj;
 
11704
fail:
 
11705
  return NULL;
 
11706
}
 
11707
 
 
11708
 
 
11709
SWIGINTERN PyObject *_wrap_TextAttr_SetBulletText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11710
  PyObject *resultobj = 0;
 
11711
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11712
  wxString *arg2 = 0 ;
 
11713
  void *argp1 = 0 ;
 
11714
  int res1 = 0 ;
 
11715
  bool temp2 = false ;
 
11716
  PyObject * obj0 = 0 ;
 
11717
  PyObject * obj1 = 0 ;
 
11718
  char *  kwnames[] = {
 
11719
    (char *) "self",(char *) "text", NULL 
 
11720
  };
 
11721
  
 
11722
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetBulletText",kwnames,&obj0,&obj1)) SWIG_fail;
 
11723
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11724
  if (!SWIG_IsOK(res1)) {
 
11725
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetBulletText" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11726
  }
 
11727
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11728
  {
 
11729
    arg2 = wxString_in_helper(obj1);
 
11730
    if (arg2 == NULL) SWIG_fail;
 
11731
    temp2 = true;
 
11732
  }
 
11733
  {
 
11734
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11735
    (arg1)->SetBulletText((wxString const &)*arg2);
 
11736
    wxPyEndAllowThreads(__tstate);
 
11737
    if (PyErr_Occurred()) SWIG_fail;
 
11738
  }
 
11739
  resultobj = SWIG_Py_Void();
 
11740
  {
 
11741
    if (temp2)
 
11742
    delete arg2;
 
11743
  }
 
11744
  return resultobj;
 
11745
fail:
 
11746
  {
 
11747
    if (temp2)
 
11748
    delete arg2;
 
11749
  }
 
11750
  return NULL;
 
11751
}
 
11752
 
 
11753
 
 
11754
SWIGINTERN PyObject *_wrap_TextAttr_SetBulletFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11755
  PyObject *resultobj = 0;
 
11756
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11757
  wxString *arg2 = 0 ;
 
11758
  void *argp1 = 0 ;
 
11759
  int res1 = 0 ;
 
11760
  bool temp2 = false ;
 
11761
  PyObject * obj0 = 0 ;
 
11762
  PyObject * obj1 = 0 ;
 
11763
  char *  kwnames[] = {
 
11764
    (char *) "self",(char *) "bulletFont", NULL 
 
11765
  };
 
11766
  
 
11767
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetBulletFont",kwnames,&obj0,&obj1)) SWIG_fail;
 
11768
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11769
  if (!SWIG_IsOK(res1)) {
 
11770
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetBulletFont" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11771
  }
 
11772
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11773
  {
 
11774
    arg2 = wxString_in_helper(obj1);
 
11775
    if (arg2 == NULL) SWIG_fail;
 
11776
    temp2 = true;
 
11777
  }
 
11778
  {
 
11779
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11780
    (arg1)->SetBulletFont((wxString const &)*arg2);
 
11781
    wxPyEndAllowThreads(__tstate);
 
11782
    if (PyErr_Occurred()) SWIG_fail;
 
11783
  }
 
11784
  resultobj = SWIG_Py_Void();
 
11785
  {
 
11786
    if (temp2)
 
11787
    delete arg2;
 
11788
  }
 
11789
  return resultobj;
 
11790
fail:
 
11791
  {
 
11792
    if (temp2)
 
11793
    delete arg2;
 
11794
  }
 
11795
  return NULL;
 
11796
}
 
11797
 
 
11798
 
 
11799
SWIGINTERN PyObject *_wrap_TextAttr_SetBulletName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11800
  PyObject *resultobj = 0;
 
11801
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11802
  wxString *arg2 = 0 ;
 
11803
  void *argp1 = 0 ;
 
11804
  int res1 = 0 ;
 
11805
  bool temp2 = false ;
 
11806
  PyObject * obj0 = 0 ;
 
11807
  PyObject * obj1 = 0 ;
 
11808
  char *  kwnames[] = {
 
11809
    (char *) "self",(char *) "name", NULL 
 
11810
  };
 
11811
  
 
11812
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetBulletName",kwnames,&obj0,&obj1)) SWIG_fail;
 
11813
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11814
  if (!SWIG_IsOK(res1)) {
 
11815
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetBulletName" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11816
  }
 
11817
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11818
  {
 
11819
    arg2 = wxString_in_helper(obj1);
 
11820
    if (arg2 == NULL) SWIG_fail;
 
11821
    temp2 = true;
 
11822
  }
 
11823
  {
 
11824
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11825
    (arg1)->SetBulletName((wxString const &)*arg2);
 
11826
    wxPyEndAllowThreads(__tstate);
 
11827
    if (PyErr_Occurred()) SWIG_fail;
 
11828
  }
 
11829
  resultobj = SWIG_Py_Void();
 
11830
  {
 
11831
    if (temp2)
 
11832
    delete arg2;
 
11833
  }
 
11834
  return resultobj;
 
11835
fail:
 
11836
  {
 
11837
    if (temp2)
 
11838
    delete arg2;
 
11839
  }
 
11840
  return NULL;
 
11841
}
 
11842
 
 
11843
 
 
11844
SWIGINTERN PyObject *_wrap_TextAttr_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11845
  PyObject *resultobj = 0;
 
11846
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11847
  wxString *arg2 = 0 ;
 
11848
  void *argp1 = 0 ;
 
11849
  int res1 = 0 ;
 
11850
  bool temp2 = false ;
 
11851
  PyObject * obj0 = 0 ;
 
11852
  PyObject * obj1 = 0 ;
 
11853
  char *  kwnames[] = {
 
11854
    (char *) "self",(char *) "url", NULL 
 
11855
  };
 
11856
  
 
11857
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
 
11858
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11859
  if (!SWIG_IsOK(res1)) {
 
11860
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetURL" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11861
  }
 
11862
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11863
  {
 
11864
    arg2 = wxString_in_helper(obj1);
 
11865
    if (arg2 == NULL) SWIG_fail;
 
11866
    temp2 = true;
 
11867
  }
 
11868
  {
 
11869
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11870
    (arg1)->SetURL((wxString const &)*arg2);
 
11871
    wxPyEndAllowThreads(__tstate);
 
11872
    if (PyErr_Occurred()) SWIG_fail;
 
11873
  }
 
11874
  resultobj = SWIG_Py_Void();
 
11875
  {
 
11876
    if (temp2)
 
11877
    delete arg2;
 
11878
  }
 
11879
  return resultobj;
 
11880
fail:
 
11881
  {
 
11882
    if (temp2)
 
11883
    delete arg2;
 
11884
  }
 
11885
  return NULL;
 
11886
}
 
11887
 
 
11888
 
 
11889
SWIGINTERN PyObject *_wrap_TextAttr_SetPageBreak(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11890
  PyObject *resultobj = 0;
 
11891
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11892
  bool arg2 = (bool) true ;
 
11893
  void *argp1 = 0 ;
 
11894
  int res1 = 0 ;
 
11895
  bool val2 ;
 
11896
  int ecode2 = 0 ;
 
11897
  PyObject * obj0 = 0 ;
 
11898
  PyObject * obj1 = 0 ;
 
11899
  char *  kwnames[] = {
 
11900
    (char *) "self",(char *) "pageBreak", NULL 
 
11901
  };
 
11902
  
 
11903
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TextAttr_SetPageBreak",kwnames,&obj0,&obj1)) SWIG_fail;
 
11904
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11905
  if (!SWIG_IsOK(res1)) {
 
11906
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetPageBreak" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11907
  }
 
11908
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11909
  if (obj1) {
 
11910
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
11911
    if (!SWIG_IsOK(ecode2)) {
 
11912
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetPageBreak" "', expected argument " "2"" of type '" "bool""'");
 
11913
    } 
 
11914
    arg2 = static_cast< bool >(val2);
 
11915
  }
 
11916
  {
 
11917
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11918
    (arg1)->SetPageBreak(arg2);
 
11919
    wxPyEndAllowThreads(__tstate);
 
11920
    if (PyErr_Occurred()) SWIG_fail;
 
11921
  }
 
11922
  resultobj = SWIG_Py_Void();
 
11923
  return resultobj;
 
11924
fail:
 
11925
  return NULL;
 
11926
}
 
11927
 
 
11928
 
 
11929
SWIGINTERN PyObject *_wrap_TextAttr_SetTextEffects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11930
  PyObject *resultobj = 0;
 
11931
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11932
  int arg2 ;
 
11933
  void *argp1 = 0 ;
 
11934
  int res1 = 0 ;
 
11935
  int val2 ;
 
11936
  int ecode2 = 0 ;
 
11937
  PyObject * obj0 = 0 ;
 
11938
  PyObject * obj1 = 0 ;
 
11939
  char *  kwnames[] = {
 
11940
    (char *) "self",(char *) "effects", NULL 
 
11941
  };
 
11942
  
 
11943
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetTextEffects",kwnames,&obj0,&obj1)) SWIG_fail;
 
11944
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11945
  if (!SWIG_IsOK(res1)) {
 
11946
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetTextEffects" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11947
  }
 
11948
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11949
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11950
  if (!SWIG_IsOK(ecode2)) {
 
11951
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetTextEffects" "', expected argument " "2"" of type '" "int""'");
 
11952
  } 
 
11953
  arg2 = static_cast< int >(val2);
 
11954
  {
 
11955
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11956
    (arg1)->SetTextEffects(arg2);
 
11957
    wxPyEndAllowThreads(__tstate);
 
11958
    if (PyErr_Occurred()) SWIG_fail;
 
11959
  }
 
11960
  resultobj = SWIG_Py_Void();
 
11961
  return resultobj;
 
11962
fail:
 
11963
  return NULL;
 
11964
}
 
11965
 
 
11966
 
 
11967
SWIGINTERN PyObject *_wrap_TextAttr_SetTextEffectFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
11968
  PyObject *resultobj = 0;
 
11969
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
11970
  int arg2 ;
 
11971
  void *argp1 = 0 ;
 
11972
  int res1 = 0 ;
 
11973
  int val2 ;
 
11974
  int ecode2 = 0 ;
 
11975
  PyObject * obj0 = 0 ;
 
11976
  PyObject * obj1 = 0 ;
 
11977
  char *  kwnames[] = {
 
11978
    (char *) "self",(char *) "effects", NULL 
 
11979
  };
 
11980
  
 
11981
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetTextEffectFlags",kwnames,&obj0,&obj1)) SWIG_fail;
 
11982
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
11983
  if (!SWIG_IsOK(res1)) {
 
11984
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetTextEffectFlags" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
11985
  }
 
11986
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
11987
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
11988
  if (!SWIG_IsOK(ecode2)) {
 
11989
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetTextEffectFlags" "', expected argument " "2"" of type '" "int""'");
 
11990
  } 
 
11991
  arg2 = static_cast< int >(val2);
 
11992
  {
 
11993
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
11994
    (arg1)->SetTextEffectFlags(arg2);
 
11995
    wxPyEndAllowThreads(__tstate);
 
11996
    if (PyErr_Occurred()) SWIG_fail;
 
11997
  }
 
11998
  resultobj = SWIG_Py_Void();
 
11999
  return resultobj;
 
12000
fail:
 
12001
  return NULL;
 
12002
}
 
12003
 
 
12004
 
 
12005
SWIGINTERN PyObject *_wrap_TextAttr_SetOutlineLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
12006
  PyObject *resultobj = 0;
 
12007
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12008
  int arg2 ;
 
12009
  void *argp1 = 0 ;
 
12010
  int res1 = 0 ;
 
12011
  int val2 ;
 
12012
  int ecode2 = 0 ;
 
12013
  PyObject * obj0 = 0 ;
 
12014
  PyObject * obj1 = 0 ;
 
12015
  char *  kwnames[] = {
 
12016
    (char *) "self",(char *) "level", NULL 
 
12017
  };
 
12018
  
 
12019
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_SetOutlineLevel",kwnames,&obj0,&obj1)) SWIG_fail;
 
12020
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12021
  if (!SWIG_IsOK(res1)) {
 
12022
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SetOutlineLevel" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
12023
  }
 
12024
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12025
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
12026
  if (!SWIG_IsOK(ecode2)) {
 
12027
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_SetOutlineLevel" "', expected argument " "2"" of type '" "int""'");
 
12028
  } 
 
12029
  arg2 = static_cast< int >(val2);
 
12030
  {
 
12031
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12032
    (arg1)->SetOutlineLevel(arg2);
 
12033
    wxPyEndAllowThreads(__tstate);
 
12034
    if (PyErr_Occurred()) SWIG_fail;
 
12035
  }
 
12036
  resultobj = SWIG_Py_Void();
 
12037
  return resultobj;
 
12038
fail:
 
12039
  return NULL;
 
12040
}
 
12041
 
 
12042
 
 
12043
SWIGINTERN PyObject *_wrap_TextAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12044
  PyObject *resultobj = 0;
 
12045
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12046
  wxColour *result = 0 ;
 
12047
  void *argp1 = 0 ;
 
12048
  int res1 = 0 ;
 
12049
  PyObject *swig_obj[1] ;
 
12050
  
 
12051
  if (!args) SWIG_fail;
 
12052
  swig_obj[0] = args;
 
12053
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12054
  if (!SWIG_IsOK(res1)) {
 
12055
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetTextColour" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12056
  }
 
12057
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12058
  {
 
12059
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12060
    {
 
12061
      wxColour const &_result_ref = ((wxTextAttr const *)arg1)->GetTextColour();
 
12062
      result = (wxColour *) &_result_ref;
 
12063
    }
 
12064
    wxPyEndAllowThreads(__tstate);
 
12065
    if (PyErr_Occurred()) SWIG_fail;
 
12066
  }
 
12067
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 |  0 );
 
12068
  return resultobj;
 
12069
fail:
 
12070
  return NULL;
 
12071
}
 
12072
 
 
12073
 
 
12074
SWIGINTERN PyObject *_wrap_TextAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12075
  PyObject *resultobj = 0;
 
12076
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12077
  wxColour *result = 0 ;
 
12078
  void *argp1 = 0 ;
 
12079
  int res1 = 0 ;
 
12080
  PyObject *swig_obj[1] ;
 
12081
  
 
12082
  if (!args) SWIG_fail;
 
12083
  swig_obj[0] = args;
 
12084
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12085
  if (!SWIG_IsOK(res1)) {
 
12086
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12087
  }
 
12088
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12089
  {
 
12090
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12091
    {
 
12092
      wxColour const &_result_ref = ((wxTextAttr const *)arg1)->GetBackgroundColour();
 
12093
      result = (wxColour *) &_result_ref;
 
12094
    }
 
12095
    wxPyEndAllowThreads(__tstate);
 
12096
    if (PyErr_Occurred()) SWIG_fail;
 
12097
  }
 
12098
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 |  0 );
 
12099
  return resultobj;
 
12100
fail:
 
12101
  return NULL;
 
12102
}
 
12103
 
 
12104
 
 
12105
SWIGINTERN PyObject *_wrap_TextAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12106
  PyObject *resultobj = 0;
 
12107
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12108
  wxTextAttrAlignment result;
 
12109
  void *argp1 = 0 ;
 
12110
  int res1 = 0 ;
 
12111
  PyObject *swig_obj[1] ;
 
12112
  
 
12113
  if (!args) SWIG_fail;
 
12114
  swig_obj[0] = args;
 
12115
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12116
  if (!SWIG_IsOK(res1)) {
 
12117
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetAlignment" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12118
  }
 
12119
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12120
  {
 
12121
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12122
    result = (wxTextAttrAlignment)((wxTextAttr const *)arg1)->GetAlignment();
 
12123
    wxPyEndAllowThreads(__tstate);
 
12124
    if (PyErr_Occurred()) SWIG_fail;
 
12125
  }
 
12126
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12127
  return resultobj;
 
12128
fail:
 
12129
  return NULL;
 
12130
}
 
12131
 
 
12132
 
 
12133
SWIGINTERN PyObject *_wrap_TextAttr_GetTabs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12134
  PyObject *resultobj = 0;
 
12135
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12136
  wxArrayInt *result = 0 ;
 
12137
  void *argp1 = 0 ;
 
12138
  int res1 = 0 ;
 
12139
  PyObject *swig_obj[1] ;
 
12140
  
 
12141
  if (!args) SWIG_fail;
 
12142
  swig_obj[0] = args;
 
12143
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12144
  if (!SWIG_IsOK(res1)) {
 
12145
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetTabs" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12146
  }
 
12147
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12148
  {
 
12149
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12150
    {
 
12151
      wxArrayInt const &_result_ref = ((wxTextAttr const *)arg1)->GetTabs();
 
12152
      result = (wxArrayInt *) &_result_ref;
 
12153
    }
 
12154
    wxPyEndAllowThreads(__tstate);
 
12155
    if (PyErr_Occurred()) SWIG_fail;
 
12156
  }
 
12157
  {
 
12158
    resultobj = wxArrayInt2PyList_helper(*result);
 
12159
  }
 
12160
  return resultobj;
 
12161
fail:
 
12162
  return NULL;
 
12163
}
 
12164
 
 
12165
 
 
12166
SWIGINTERN PyObject *_wrap_TextAttr_GetLeftIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12167
  PyObject *resultobj = 0;
 
12168
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12169
  long result;
 
12170
  void *argp1 = 0 ;
 
12171
  int res1 = 0 ;
 
12172
  PyObject *swig_obj[1] ;
 
12173
  
 
12174
  if (!args) SWIG_fail;
 
12175
  swig_obj[0] = args;
 
12176
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12177
  if (!SWIG_IsOK(res1)) {
 
12178
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetLeftIndent" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12179
  }
 
12180
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12181
  {
 
12182
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12183
    result = (long)((wxTextAttr const *)arg1)->GetLeftIndent();
 
12184
    wxPyEndAllowThreads(__tstate);
 
12185
    if (PyErr_Occurred()) SWIG_fail;
 
12186
  }
 
12187
  resultobj = SWIG_From_long(static_cast< long >(result));
 
12188
  return resultobj;
 
12189
fail:
 
12190
  return NULL;
 
12191
}
 
12192
 
 
12193
 
 
12194
SWIGINTERN PyObject *_wrap_TextAttr_GetLeftSubIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12195
  PyObject *resultobj = 0;
 
12196
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12197
  long result;
 
12198
  void *argp1 = 0 ;
 
12199
  int res1 = 0 ;
 
12200
  PyObject *swig_obj[1] ;
 
12201
  
 
12202
  if (!args) SWIG_fail;
 
12203
  swig_obj[0] = args;
 
12204
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12205
  if (!SWIG_IsOK(res1)) {
 
12206
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetLeftSubIndent" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12207
  }
 
12208
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12209
  {
 
12210
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12211
    result = (long)((wxTextAttr const *)arg1)->GetLeftSubIndent();
 
12212
    wxPyEndAllowThreads(__tstate);
 
12213
    if (PyErr_Occurred()) SWIG_fail;
 
12214
  }
 
12215
  resultobj = SWIG_From_long(static_cast< long >(result));
 
12216
  return resultobj;
 
12217
fail:
 
12218
  return NULL;
 
12219
}
 
12220
 
 
12221
 
 
12222
SWIGINTERN PyObject *_wrap_TextAttr_GetRightIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12223
  PyObject *resultobj = 0;
 
12224
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12225
  long result;
 
12226
  void *argp1 = 0 ;
 
12227
  int res1 = 0 ;
 
12228
  PyObject *swig_obj[1] ;
 
12229
  
 
12230
  if (!args) SWIG_fail;
 
12231
  swig_obj[0] = args;
 
12232
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12233
  if (!SWIG_IsOK(res1)) {
 
12234
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetRightIndent" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12235
  }
 
12236
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12237
  {
 
12238
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12239
    result = (long)((wxTextAttr const *)arg1)->GetRightIndent();
 
12240
    wxPyEndAllowThreads(__tstate);
 
12241
    if (PyErr_Occurred()) SWIG_fail;
 
12242
  }
 
12243
  resultobj = SWIG_From_long(static_cast< long >(result));
 
12244
  return resultobj;
 
12245
fail:
 
12246
  return NULL;
 
12247
}
 
12248
 
 
12249
 
 
12250
SWIGINTERN PyObject *_wrap_TextAttr_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12251
  PyObject *resultobj = 0;
 
12252
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12253
  long result;
 
12254
  void *argp1 = 0 ;
 
12255
  int res1 = 0 ;
 
12256
  PyObject *swig_obj[1] ;
 
12257
  
 
12258
  if (!args) SWIG_fail;
 
12259
  swig_obj[0] = args;
 
12260
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12261
  if (!SWIG_IsOK(res1)) {
 
12262
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFlags" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12263
  }
 
12264
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12265
  {
 
12266
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12267
    result = (long)((wxTextAttr const *)arg1)->GetFlags();
 
12268
    wxPyEndAllowThreads(__tstate);
 
12269
    if (PyErr_Occurred()) SWIG_fail;
 
12270
  }
 
12271
  resultobj = SWIG_From_long(static_cast< long >(result));
 
12272
  return resultobj;
 
12273
fail:
 
12274
  return NULL;
 
12275
}
 
12276
 
 
12277
 
 
12278
SWIGINTERN PyObject *_wrap_TextAttr_GetFontSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12279
  PyObject *resultobj = 0;
 
12280
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12281
  int result;
 
12282
  void *argp1 = 0 ;
 
12283
  int res1 = 0 ;
 
12284
  PyObject *swig_obj[1] ;
 
12285
  
 
12286
  if (!args) SWIG_fail;
 
12287
  swig_obj[0] = args;
 
12288
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12289
  if (!SWIG_IsOK(res1)) {
 
12290
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFontSize" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12291
  }
 
12292
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12293
  {
 
12294
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12295
    result = (int)((wxTextAttr const *)arg1)->GetFontSize();
 
12296
    wxPyEndAllowThreads(__tstate);
 
12297
    if (PyErr_Occurred()) SWIG_fail;
 
12298
  }
 
12299
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12300
  return resultobj;
 
12301
fail:
 
12302
  return NULL;
 
12303
}
 
12304
 
 
12305
 
 
12306
SWIGINTERN PyObject *_wrap_TextAttr_GetFontStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12307
  PyObject *resultobj = 0;
 
12308
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12309
  int result;
 
12310
  void *argp1 = 0 ;
 
12311
  int res1 = 0 ;
 
12312
  PyObject *swig_obj[1] ;
 
12313
  
 
12314
  if (!args) SWIG_fail;
 
12315
  swig_obj[0] = args;
 
12316
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12317
  if (!SWIG_IsOK(res1)) {
 
12318
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFontStyle" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12319
  }
 
12320
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12321
  {
 
12322
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12323
    result = (int)((wxTextAttr const *)arg1)->GetFontStyle();
 
12324
    wxPyEndAllowThreads(__tstate);
 
12325
    if (PyErr_Occurred()) SWIG_fail;
 
12326
  }
 
12327
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12328
  return resultobj;
 
12329
fail:
 
12330
  return NULL;
 
12331
}
 
12332
 
 
12333
 
 
12334
SWIGINTERN PyObject *_wrap_TextAttr_GetFontWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12335
  PyObject *resultobj = 0;
 
12336
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12337
  int result;
 
12338
  void *argp1 = 0 ;
 
12339
  int res1 = 0 ;
 
12340
  PyObject *swig_obj[1] ;
 
12341
  
 
12342
  if (!args) SWIG_fail;
 
12343
  swig_obj[0] = args;
 
12344
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12345
  if (!SWIG_IsOK(res1)) {
 
12346
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFontWeight" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12347
  }
 
12348
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12349
  {
 
12350
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12351
    result = (int)((wxTextAttr const *)arg1)->GetFontWeight();
 
12352
    wxPyEndAllowThreads(__tstate);
 
12353
    if (PyErr_Occurred()) SWIG_fail;
 
12354
  }
 
12355
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12356
  return resultobj;
 
12357
fail:
 
12358
  return NULL;
 
12359
}
 
12360
 
 
12361
 
 
12362
SWIGINTERN PyObject *_wrap_TextAttr_GetFontUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12363
  PyObject *resultobj = 0;
 
12364
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12365
  bool result;
 
12366
  void *argp1 = 0 ;
 
12367
  int res1 = 0 ;
 
12368
  PyObject *swig_obj[1] ;
 
12369
  
 
12370
  if (!args) SWIG_fail;
 
12371
  swig_obj[0] = args;
 
12372
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12373
  if (!SWIG_IsOK(res1)) {
 
12374
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFontUnderlined" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12375
  }
 
12376
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12377
  {
 
12378
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12379
    result = (bool)((wxTextAttr const *)arg1)->GetFontUnderlined();
 
12380
    wxPyEndAllowThreads(__tstate);
 
12381
    if (PyErr_Occurred()) SWIG_fail;
 
12382
  }
 
12383
  {
 
12384
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
12385
  }
 
12386
  return resultobj;
 
12387
fail:
 
12388
  return NULL;
 
12389
}
 
12390
 
 
12391
 
 
12392
SWIGINTERN PyObject *_wrap_TextAttr_GetFontStrikethrough(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12393
  PyObject *resultobj = 0;
 
12394
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12395
  bool result;
 
12396
  void *argp1 = 0 ;
 
12397
  int res1 = 0 ;
 
12398
  PyObject *swig_obj[1] ;
 
12399
  
 
12400
  if (!args) SWIG_fail;
 
12401
  swig_obj[0] = args;
 
12402
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12403
  if (!SWIG_IsOK(res1)) {
 
12404
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFontStrikethrough" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12405
  }
 
12406
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12407
  {
 
12408
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12409
    result = (bool)((wxTextAttr const *)arg1)->GetFontStrikethrough();
 
12410
    wxPyEndAllowThreads(__tstate);
 
12411
    if (PyErr_Occurred()) SWIG_fail;
 
12412
  }
 
12413
  {
 
12414
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
12415
  }
 
12416
  return resultobj;
 
12417
fail:
 
12418
  return NULL;
 
12419
}
 
12420
 
 
12421
 
 
12422
SWIGINTERN PyObject *_wrap_TextAttr_GetFontFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12423
  PyObject *resultobj = 0;
 
12424
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12425
  wxString *result = 0 ;
 
12426
  void *argp1 = 0 ;
 
12427
  int res1 = 0 ;
 
12428
  PyObject *swig_obj[1] ;
 
12429
  
 
12430
  if (!args) SWIG_fail;
 
12431
  swig_obj[0] = args;
 
12432
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12433
  if (!SWIG_IsOK(res1)) {
 
12434
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFontFaceName" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12435
  }
 
12436
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12437
  {
 
12438
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12439
    {
 
12440
      wxString const &_result_ref = ((wxTextAttr const *)arg1)->GetFontFaceName();
 
12441
      result = (wxString *) &_result_ref;
 
12442
    }
 
12443
    wxPyEndAllowThreads(__tstate);
 
12444
    if (PyErr_Occurred()) SWIG_fail;
 
12445
  }
 
12446
  {
 
12447
#if wxUSE_UNICODE
 
12448
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
12449
#else
 
12450
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
12451
#endif
 
12452
  }
 
12453
  return resultobj;
 
12454
fail:
 
12455
  return NULL;
 
12456
}
 
12457
 
 
12458
 
 
12459
SWIGINTERN PyObject *_wrap_TextAttr_GetFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12460
  PyObject *resultobj = 0;
 
12461
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12462
  wxFontEncoding result;
 
12463
  void *argp1 = 0 ;
 
12464
  int res1 = 0 ;
 
12465
  PyObject *swig_obj[1] ;
 
12466
  
 
12467
  if (!args) SWIG_fail;
 
12468
  swig_obj[0] = args;
 
12469
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12470
  if (!SWIG_IsOK(res1)) {
 
12471
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFontEncoding" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12472
  }
 
12473
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12474
  {
 
12475
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12476
    result = (wxFontEncoding)((wxTextAttr const *)arg1)->GetFontEncoding();
 
12477
    wxPyEndAllowThreads(__tstate);
 
12478
    if (PyErr_Occurred()) SWIG_fail;
 
12479
  }
 
12480
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12481
  return resultobj;
 
12482
fail:
 
12483
  return NULL;
 
12484
}
 
12485
 
 
12486
 
 
12487
SWIGINTERN PyObject *_wrap_TextAttr_GetFontFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12488
  PyObject *resultobj = 0;
 
12489
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12490
  wxFontFamily result;
 
12491
  void *argp1 = 0 ;
 
12492
  int res1 = 0 ;
 
12493
  PyObject *swig_obj[1] ;
 
12494
  
 
12495
  if (!args) SWIG_fail;
 
12496
  swig_obj[0] = args;
 
12497
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12498
  if (!SWIG_IsOK(res1)) {
 
12499
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFontFamily" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12500
  }
 
12501
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12502
  {
 
12503
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12504
    result = (wxFontFamily)((wxTextAttr const *)arg1)->GetFontFamily();
 
12505
    wxPyEndAllowThreads(__tstate);
 
12506
    if (PyErr_Occurred()) SWIG_fail;
 
12507
  }
 
12508
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12509
  return resultobj;
 
12510
fail:
 
12511
  return NULL;
 
12512
}
 
12513
 
 
12514
 
 
12515
SWIGINTERN PyObject *_wrap_TextAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12516
  PyObject *resultobj = 0;
 
12517
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12518
  wxFont result;
 
12519
  void *argp1 = 0 ;
 
12520
  int res1 = 0 ;
 
12521
  PyObject *swig_obj[1] ;
 
12522
  
 
12523
  if (!args) SWIG_fail;
 
12524
  swig_obj[0] = args;
 
12525
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12526
  if (!SWIG_IsOK(res1)) {
 
12527
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetFont" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12528
  }
 
12529
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12530
  {
 
12531
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12532
    result = ((wxTextAttr const *)arg1)->GetFont();
 
12533
    wxPyEndAllowThreads(__tstate);
 
12534
    if (PyErr_Occurred()) SWIG_fail;
 
12535
  }
 
12536
  resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN |  0 );
 
12537
  return resultobj;
 
12538
fail:
 
12539
  return NULL;
 
12540
}
 
12541
 
 
12542
 
 
12543
SWIGINTERN PyObject *_wrap_TextAttr_GetCharacterStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12544
  PyObject *resultobj = 0;
 
12545
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12546
  wxString *result = 0 ;
 
12547
  void *argp1 = 0 ;
 
12548
  int res1 = 0 ;
 
12549
  PyObject *swig_obj[1] ;
 
12550
  
 
12551
  if (!args) SWIG_fail;
 
12552
  swig_obj[0] = args;
 
12553
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12554
  if (!SWIG_IsOK(res1)) {
 
12555
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetCharacterStyleName" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12556
  }
 
12557
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12558
  {
 
12559
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12560
    {
 
12561
      wxString const &_result_ref = ((wxTextAttr const *)arg1)->GetCharacterStyleName();
 
12562
      result = (wxString *) &_result_ref;
 
12563
    }
 
12564
    wxPyEndAllowThreads(__tstate);
 
12565
    if (PyErr_Occurred()) SWIG_fail;
 
12566
  }
 
12567
  {
 
12568
#if wxUSE_UNICODE
 
12569
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
12570
#else
 
12571
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
12572
#endif
 
12573
  }
 
12574
  return resultobj;
 
12575
fail:
 
12576
  return NULL;
 
12577
}
 
12578
 
 
12579
 
 
12580
SWIGINTERN PyObject *_wrap_TextAttr_GetParagraphStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12581
  PyObject *resultobj = 0;
 
12582
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12583
  wxString *result = 0 ;
 
12584
  void *argp1 = 0 ;
 
12585
  int res1 = 0 ;
 
12586
  PyObject *swig_obj[1] ;
 
12587
  
 
12588
  if (!args) SWIG_fail;
 
12589
  swig_obj[0] = args;
 
12590
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12591
  if (!SWIG_IsOK(res1)) {
 
12592
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetParagraphStyleName" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12593
  }
 
12594
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12595
  {
 
12596
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12597
    {
 
12598
      wxString const &_result_ref = ((wxTextAttr const *)arg1)->GetParagraphStyleName();
 
12599
      result = (wxString *) &_result_ref;
 
12600
    }
 
12601
    wxPyEndAllowThreads(__tstate);
 
12602
    if (PyErr_Occurred()) SWIG_fail;
 
12603
  }
 
12604
  {
 
12605
#if wxUSE_UNICODE
 
12606
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
12607
#else
 
12608
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
12609
#endif
 
12610
  }
 
12611
  return resultobj;
 
12612
fail:
 
12613
  return NULL;
 
12614
}
 
12615
 
 
12616
 
 
12617
SWIGINTERN PyObject *_wrap_TextAttr_GetListStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12618
  PyObject *resultobj = 0;
 
12619
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12620
  wxString *result = 0 ;
 
12621
  void *argp1 = 0 ;
 
12622
  int res1 = 0 ;
 
12623
  PyObject *swig_obj[1] ;
 
12624
  
 
12625
  if (!args) SWIG_fail;
 
12626
  swig_obj[0] = args;
 
12627
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12628
  if (!SWIG_IsOK(res1)) {
 
12629
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetListStyleName" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12630
  }
 
12631
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12632
  {
 
12633
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12634
    {
 
12635
      wxString const &_result_ref = ((wxTextAttr const *)arg1)->GetListStyleName();
 
12636
      result = (wxString *) &_result_ref;
 
12637
    }
 
12638
    wxPyEndAllowThreads(__tstate);
 
12639
    if (PyErr_Occurred()) SWIG_fail;
 
12640
  }
 
12641
  {
 
12642
#if wxUSE_UNICODE
 
12643
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
12644
#else
 
12645
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
12646
#endif
 
12647
  }
 
12648
  return resultobj;
 
12649
fail:
 
12650
  return NULL;
 
12651
}
 
12652
 
 
12653
 
 
12654
SWIGINTERN PyObject *_wrap_TextAttr_GetParagraphSpacingAfter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12655
  PyObject *resultobj = 0;
 
12656
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12657
  int result;
 
12658
  void *argp1 = 0 ;
 
12659
  int res1 = 0 ;
 
12660
  PyObject *swig_obj[1] ;
 
12661
  
 
12662
  if (!args) SWIG_fail;
 
12663
  swig_obj[0] = args;
 
12664
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12665
  if (!SWIG_IsOK(res1)) {
 
12666
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetParagraphSpacingAfter" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12667
  }
 
12668
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12669
  {
 
12670
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12671
    result = (int)((wxTextAttr const *)arg1)->GetParagraphSpacingAfter();
 
12672
    wxPyEndAllowThreads(__tstate);
 
12673
    if (PyErr_Occurred()) SWIG_fail;
 
12674
  }
 
12675
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12676
  return resultobj;
 
12677
fail:
 
12678
  return NULL;
 
12679
}
 
12680
 
 
12681
 
 
12682
SWIGINTERN PyObject *_wrap_TextAttr_GetParagraphSpacingBefore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12683
  PyObject *resultobj = 0;
 
12684
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12685
  int result;
 
12686
  void *argp1 = 0 ;
 
12687
  int res1 = 0 ;
 
12688
  PyObject *swig_obj[1] ;
 
12689
  
 
12690
  if (!args) SWIG_fail;
 
12691
  swig_obj[0] = args;
 
12692
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12693
  if (!SWIG_IsOK(res1)) {
 
12694
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetParagraphSpacingBefore" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12695
  }
 
12696
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12697
  {
 
12698
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12699
    result = (int)((wxTextAttr const *)arg1)->GetParagraphSpacingBefore();
 
12700
    wxPyEndAllowThreads(__tstate);
 
12701
    if (PyErr_Occurred()) SWIG_fail;
 
12702
  }
 
12703
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12704
  return resultobj;
 
12705
fail:
 
12706
  return NULL;
 
12707
}
 
12708
 
 
12709
 
 
12710
SWIGINTERN PyObject *_wrap_TextAttr_GetLineSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12711
  PyObject *resultobj = 0;
 
12712
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12713
  int result;
 
12714
  void *argp1 = 0 ;
 
12715
  int res1 = 0 ;
 
12716
  PyObject *swig_obj[1] ;
 
12717
  
 
12718
  if (!args) SWIG_fail;
 
12719
  swig_obj[0] = args;
 
12720
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12721
  if (!SWIG_IsOK(res1)) {
 
12722
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetLineSpacing" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12723
  }
 
12724
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12725
  {
 
12726
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12727
    result = (int)((wxTextAttr const *)arg1)->GetLineSpacing();
 
12728
    wxPyEndAllowThreads(__tstate);
 
12729
    if (PyErr_Occurred()) SWIG_fail;
 
12730
  }
 
12731
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12732
  return resultobj;
 
12733
fail:
 
12734
  return NULL;
 
12735
}
 
12736
 
 
12737
 
 
12738
SWIGINTERN PyObject *_wrap_TextAttr_GetBulletStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12739
  PyObject *resultobj = 0;
 
12740
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12741
  int result;
 
12742
  void *argp1 = 0 ;
 
12743
  int res1 = 0 ;
 
12744
  PyObject *swig_obj[1] ;
 
12745
  
 
12746
  if (!args) SWIG_fail;
 
12747
  swig_obj[0] = args;
 
12748
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12749
  if (!SWIG_IsOK(res1)) {
 
12750
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetBulletStyle" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12751
  }
 
12752
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12753
  {
 
12754
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12755
    result = (int)((wxTextAttr const *)arg1)->GetBulletStyle();
 
12756
    wxPyEndAllowThreads(__tstate);
 
12757
    if (PyErr_Occurred()) SWIG_fail;
 
12758
  }
 
12759
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12760
  return resultobj;
 
12761
fail:
 
12762
  return NULL;
 
12763
}
 
12764
 
 
12765
 
 
12766
SWIGINTERN PyObject *_wrap_TextAttr_GetBulletNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12767
  PyObject *resultobj = 0;
 
12768
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12769
  int result;
 
12770
  void *argp1 = 0 ;
 
12771
  int res1 = 0 ;
 
12772
  PyObject *swig_obj[1] ;
 
12773
  
 
12774
  if (!args) SWIG_fail;
 
12775
  swig_obj[0] = args;
 
12776
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12777
  if (!SWIG_IsOK(res1)) {
 
12778
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetBulletNumber" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12779
  }
 
12780
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12781
  {
 
12782
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12783
    result = (int)((wxTextAttr const *)arg1)->GetBulletNumber();
 
12784
    wxPyEndAllowThreads(__tstate);
 
12785
    if (PyErr_Occurred()) SWIG_fail;
 
12786
  }
 
12787
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12788
  return resultobj;
 
12789
fail:
 
12790
  return NULL;
 
12791
}
 
12792
 
 
12793
 
 
12794
SWIGINTERN PyObject *_wrap_TextAttr_GetBulletText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12795
  PyObject *resultobj = 0;
 
12796
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12797
  wxString *result = 0 ;
 
12798
  void *argp1 = 0 ;
 
12799
  int res1 = 0 ;
 
12800
  PyObject *swig_obj[1] ;
 
12801
  
 
12802
  if (!args) SWIG_fail;
 
12803
  swig_obj[0] = args;
 
12804
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12805
  if (!SWIG_IsOK(res1)) {
 
12806
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetBulletText" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12807
  }
 
12808
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12809
  {
 
12810
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12811
    {
 
12812
      wxString const &_result_ref = ((wxTextAttr const *)arg1)->GetBulletText();
 
12813
      result = (wxString *) &_result_ref;
 
12814
    }
 
12815
    wxPyEndAllowThreads(__tstate);
 
12816
    if (PyErr_Occurred()) SWIG_fail;
 
12817
  }
 
12818
  {
 
12819
#if wxUSE_UNICODE
 
12820
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
12821
#else
 
12822
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
12823
#endif
 
12824
  }
 
12825
  return resultobj;
 
12826
fail:
 
12827
  return NULL;
 
12828
}
 
12829
 
 
12830
 
 
12831
SWIGINTERN PyObject *_wrap_TextAttr_GetBulletFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12832
  PyObject *resultobj = 0;
 
12833
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12834
  wxString *result = 0 ;
 
12835
  void *argp1 = 0 ;
 
12836
  int res1 = 0 ;
 
12837
  PyObject *swig_obj[1] ;
 
12838
  
 
12839
  if (!args) SWIG_fail;
 
12840
  swig_obj[0] = args;
 
12841
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12842
  if (!SWIG_IsOK(res1)) {
 
12843
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetBulletFont" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12844
  }
 
12845
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12846
  {
 
12847
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12848
    {
 
12849
      wxString const &_result_ref = ((wxTextAttr const *)arg1)->GetBulletFont();
 
12850
      result = (wxString *) &_result_ref;
 
12851
    }
 
12852
    wxPyEndAllowThreads(__tstate);
 
12853
    if (PyErr_Occurred()) SWIG_fail;
 
12854
  }
 
12855
  {
 
12856
#if wxUSE_UNICODE
 
12857
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
12858
#else
 
12859
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
12860
#endif
 
12861
  }
 
12862
  return resultobj;
 
12863
fail:
 
12864
  return NULL;
 
12865
}
 
12866
 
 
12867
 
 
12868
SWIGINTERN PyObject *_wrap_TextAttr_GetBulletName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12869
  PyObject *resultobj = 0;
 
12870
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12871
  wxString *result = 0 ;
 
12872
  void *argp1 = 0 ;
 
12873
  int res1 = 0 ;
 
12874
  PyObject *swig_obj[1] ;
 
12875
  
 
12876
  if (!args) SWIG_fail;
 
12877
  swig_obj[0] = args;
 
12878
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12879
  if (!SWIG_IsOK(res1)) {
 
12880
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetBulletName" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12881
  }
 
12882
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12883
  {
 
12884
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12885
    {
 
12886
      wxString const &_result_ref = ((wxTextAttr const *)arg1)->GetBulletName();
 
12887
      result = (wxString *) &_result_ref;
 
12888
    }
 
12889
    wxPyEndAllowThreads(__tstate);
 
12890
    if (PyErr_Occurred()) SWIG_fail;
 
12891
  }
 
12892
  {
 
12893
#if wxUSE_UNICODE
 
12894
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
12895
#else
 
12896
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
12897
#endif
 
12898
  }
 
12899
  return resultobj;
 
12900
fail:
 
12901
  return NULL;
 
12902
}
 
12903
 
 
12904
 
 
12905
SWIGINTERN PyObject *_wrap_TextAttr_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12906
  PyObject *resultobj = 0;
 
12907
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12908
  wxString *result = 0 ;
 
12909
  void *argp1 = 0 ;
 
12910
  int res1 = 0 ;
 
12911
  PyObject *swig_obj[1] ;
 
12912
  
 
12913
  if (!args) SWIG_fail;
 
12914
  swig_obj[0] = args;
 
12915
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12916
  if (!SWIG_IsOK(res1)) {
 
12917
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetURL" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12918
  }
 
12919
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12920
  {
 
12921
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12922
    {
 
12923
      wxString const &_result_ref = ((wxTextAttr const *)arg1)->GetURL();
 
12924
      result = (wxString *) &_result_ref;
 
12925
    }
 
12926
    wxPyEndAllowThreads(__tstate);
 
12927
    if (PyErr_Occurred()) SWIG_fail;
 
12928
  }
 
12929
  {
 
12930
#if wxUSE_UNICODE
 
12931
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
12932
#else
 
12933
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
12934
#endif
 
12935
  }
 
12936
  return resultobj;
 
12937
fail:
 
12938
  return NULL;
 
12939
}
 
12940
 
 
12941
 
 
12942
SWIGINTERN PyObject *_wrap_TextAttr_GetTextEffects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12943
  PyObject *resultobj = 0;
 
12944
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12945
  int result;
 
12946
  void *argp1 = 0 ;
 
12947
  int res1 = 0 ;
 
12948
  PyObject *swig_obj[1] ;
 
12949
  
 
12950
  if (!args) SWIG_fail;
 
12951
  swig_obj[0] = args;
 
12952
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12953
  if (!SWIG_IsOK(res1)) {
 
12954
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetTextEffects" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12955
  }
 
12956
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12957
  {
 
12958
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12959
    result = (int)((wxTextAttr const *)arg1)->GetTextEffects();
 
12960
    wxPyEndAllowThreads(__tstate);
 
12961
    if (PyErr_Occurred()) SWIG_fail;
 
12962
  }
 
12963
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12964
  return resultobj;
 
12965
fail:
 
12966
  return NULL;
 
12967
}
 
12968
 
 
12969
 
 
12970
SWIGINTERN PyObject *_wrap_TextAttr_GetTextEffectFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12971
  PyObject *resultobj = 0;
 
12972
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
12973
  int result;
 
12974
  void *argp1 = 0 ;
 
12975
  int res1 = 0 ;
 
12976
  PyObject *swig_obj[1] ;
 
12977
  
 
12978
  if (!args) SWIG_fail;
 
12979
  swig_obj[0] = args;
 
12980
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
12981
  if (!SWIG_IsOK(res1)) {
 
12982
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetTextEffectFlags" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
12983
  }
 
12984
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
12985
  {
 
12986
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
12987
    result = (int)((wxTextAttr const *)arg1)->GetTextEffectFlags();
 
12988
    wxPyEndAllowThreads(__tstate);
 
12989
    if (PyErr_Occurred()) SWIG_fail;
 
12990
  }
 
12991
  resultobj = SWIG_From_int(static_cast< int >(result));
 
12992
  return resultobj;
 
12993
fail:
 
12994
  return NULL;
 
12995
}
 
12996
 
 
12997
 
 
12998
SWIGINTERN PyObject *_wrap_TextAttr_GetOutlineLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
12999
  PyObject *resultobj = 0;
 
13000
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13001
  int result;
 
13002
  void *argp1 = 0 ;
 
13003
  int res1 = 0 ;
 
13004
  PyObject *swig_obj[1] ;
 
13005
  
 
13006
  if (!args) SWIG_fail;
 
13007
  swig_obj[0] = args;
 
13008
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13009
  if (!SWIG_IsOK(res1)) {
 
13010
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_GetOutlineLevel" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13011
  }
 
13012
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13013
  {
 
13014
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13015
    result = (int)((wxTextAttr const *)arg1)->GetOutlineLevel();
 
13016
    wxPyEndAllowThreads(__tstate);
 
13017
    if (PyErr_Occurred()) SWIG_fail;
 
13018
  }
 
13019
  resultobj = SWIG_From_int(static_cast< int >(result));
 
13020
  return resultobj;
 
13021
fail:
 
13022
  return NULL;
 
13023
}
 
13024
 
 
13025
 
 
13026
SWIGINTERN PyObject *_wrap_TextAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13027
  PyObject *resultobj = 0;
 
13028
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13029
  bool result;
 
13030
  void *argp1 = 0 ;
 
13031
  int res1 = 0 ;
 
13032
  PyObject *swig_obj[1] ;
 
13033
  
 
13034
  if (!args) SWIG_fail;
 
13035
  swig_obj[0] = args;
 
13036
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13037
  if (!SWIG_IsOK(res1)) {
 
13038
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasTextColour" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13039
  }
 
13040
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13041
  {
 
13042
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13043
    result = (bool)((wxTextAttr const *)arg1)->HasTextColour();
 
13044
    wxPyEndAllowThreads(__tstate);
 
13045
    if (PyErr_Occurred()) SWIG_fail;
 
13046
  }
 
13047
  {
 
13048
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13049
  }
 
13050
  return resultobj;
 
13051
fail:
 
13052
  return NULL;
 
13053
}
 
13054
 
 
13055
 
 
13056
SWIGINTERN PyObject *_wrap_TextAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13057
  PyObject *resultobj = 0;
 
13058
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13059
  bool result;
 
13060
  void *argp1 = 0 ;
 
13061
  int res1 = 0 ;
 
13062
  PyObject *swig_obj[1] ;
 
13063
  
 
13064
  if (!args) SWIG_fail;
 
13065
  swig_obj[0] = args;
 
13066
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13067
  if (!SWIG_IsOK(res1)) {
 
13068
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13069
  }
 
13070
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13071
  {
 
13072
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13073
    result = (bool)((wxTextAttr const *)arg1)->HasBackgroundColour();
 
13074
    wxPyEndAllowThreads(__tstate);
 
13075
    if (PyErr_Occurred()) SWIG_fail;
 
13076
  }
 
13077
  {
 
13078
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13079
  }
 
13080
  return resultobj;
 
13081
fail:
 
13082
  return NULL;
 
13083
}
 
13084
 
 
13085
 
 
13086
SWIGINTERN PyObject *_wrap_TextAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13087
  PyObject *resultobj = 0;
 
13088
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13089
  bool result;
 
13090
  void *argp1 = 0 ;
 
13091
  int res1 = 0 ;
 
13092
  PyObject *swig_obj[1] ;
 
13093
  
 
13094
  if (!args) SWIG_fail;
 
13095
  swig_obj[0] = args;
 
13096
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13097
  if (!SWIG_IsOK(res1)) {
 
13098
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasAlignment" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13099
  }
 
13100
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13101
  {
 
13102
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13103
    result = (bool)((wxTextAttr const *)arg1)->HasAlignment();
 
13104
    wxPyEndAllowThreads(__tstate);
 
13105
    if (PyErr_Occurred()) SWIG_fail;
 
13106
  }
 
13107
  {
 
13108
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13109
  }
 
13110
  return resultobj;
 
13111
fail:
 
13112
  return NULL;
 
13113
}
 
13114
 
 
13115
 
 
13116
SWIGINTERN PyObject *_wrap_TextAttr_HasTabs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13117
  PyObject *resultobj = 0;
 
13118
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13119
  bool result;
 
13120
  void *argp1 = 0 ;
 
13121
  int res1 = 0 ;
 
13122
  PyObject *swig_obj[1] ;
 
13123
  
 
13124
  if (!args) SWIG_fail;
 
13125
  swig_obj[0] = args;
 
13126
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13127
  if (!SWIG_IsOK(res1)) {
 
13128
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasTabs" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13129
  }
 
13130
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13131
  {
 
13132
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13133
    result = (bool)((wxTextAttr const *)arg1)->HasTabs();
 
13134
    wxPyEndAllowThreads(__tstate);
 
13135
    if (PyErr_Occurred()) SWIG_fail;
 
13136
  }
 
13137
  {
 
13138
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13139
  }
 
13140
  return resultobj;
 
13141
fail:
 
13142
  return NULL;
 
13143
}
 
13144
 
 
13145
 
 
13146
SWIGINTERN PyObject *_wrap_TextAttr_HasLeftIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13147
  PyObject *resultobj = 0;
 
13148
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13149
  bool result;
 
13150
  void *argp1 = 0 ;
 
13151
  int res1 = 0 ;
 
13152
  PyObject *swig_obj[1] ;
 
13153
  
 
13154
  if (!args) SWIG_fail;
 
13155
  swig_obj[0] = args;
 
13156
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13157
  if (!SWIG_IsOK(res1)) {
 
13158
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasLeftIndent" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13159
  }
 
13160
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13161
  {
 
13162
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13163
    result = (bool)((wxTextAttr const *)arg1)->HasLeftIndent();
 
13164
    wxPyEndAllowThreads(__tstate);
 
13165
    if (PyErr_Occurred()) SWIG_fail;
 
13166
  }
 
13167
  {
 
13168
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13169
  }
 
13170
  return resultobj;
 
13171
fail:
 
13172
  return NULL;
 
13173
}
 
13174
 
 
13175
 
 
13176
SWIGINTERN PyObject *_wrap_TextAttr_HasRightIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13177
  PyObject *resultobj = 0;
 
13178
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13179
  bool result;
 
13180
  void *argp1 = 0 ;
 
13181
  int res1 = 0 ;
 
13182
  PyObject *swig_obj[1] ;
 
13183
  
 
13184
  if (!args) SWIG_fail;
 
13185
  swig_obj[0] = args;
 
13186
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13187
  if (!SWIG_IsOK(res1)) {
 
13188
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasRightIndent" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13189
  }
 
13190
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13191
  {
 
13192
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13193
    result = (bool)((wxTextAttr const *)arg1)->HasRightIndent();
 
13194
    wxPyEndAllowThreads(__tstate);
 
13195
    if (PyErr_Occurred()) SWIG_fail;
 
13196
  }
 
13197
  {
 
13198
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13199
  }
 
13200
  return resultobj;
 
13201
fail:
 
13202
  return NULL;
 
13203
}
 
13204
 
 
13205
 
 
13206
SWIGINTERN PyObject *_wrap_TextAttr_HasFontWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13207
  PyObject *resultobj = 0;
 
13208
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13209
  bool result;
 
13210
  void *argp1 = 0 ;
 
13211
  int res1 = 0 ;
 
13212
  PyObject *swig_obj[1] ;
 
13213
  
 
13214
  if (!args) SWIG_fail;
 
13215
  swig_obj[0] = args;
 
13216
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13217
  if (!SWIG_IsOK(res1)) {
 
13218
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasFontWeight" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13219
  }
 
13220
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13221
  {
 
13222
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13223
    result = (bool)((wxTextAttr const *)arg1)->HasFontWeight();
 
13224
    wxPyEndAllowThreads(__tstate);
 
13225
    if (PyErr_Occurred()) SWIG_fail;
 
13226
  }
 
13227
  {
 
13228
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13229
  }
 
13230
  return resultobj;
 
13231
fail:
 
13232
  return NULL;
 
13233
}
 
13234
 
 
13235
 
 
13236
SWIGINTERN PyObject *_wrap_TextAttr_HasFontSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13237
  PyObject *resultobj = 0;
 
13238
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13239
  bool result;
 
13240
  void *argp1 = 0 ;
 
13241
  int res1 = 0 ;
 
13242
  PyObject *swig_obj[1] ;
 
13243
  
 
13244
  if (!args) SWIG_fail;
 
13245
  swig_obj[0] = args;
 
13246
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13247
  if (!SWIG_IsOK(res1)) {
 
13248
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasFontSize" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13249
  }
 
13250
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13251
  {
 
13252
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13253
    result = (bool)((wxTextAttr const *)arg1)->HasFontSize();
 
13254
    wxPyEndAllowThreads(__tstate);
 
13255
    if (PyErr_Occurred()) SWIG_fail;
 
13256
  }
 
13257
  {
 
13258
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13259
  }
 
13260
  return resultobj;
 
13261
fail:
 
13262
  return NULL;
 
13263
}
 
13264
 
 
13265
 
 
13266
SWIGINTERN PyObject *_wrap_TextAttr_HasFontItalic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13267
  PyObject *resultobj = 0;
 
13268
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13269
  bool result;
 
13270
  void *argp1 = 0 ;
 
13271
  int res1 = 0 ;
 
13272
  PyObject *swig_obj[1] ;
 
13273
  
 
13274
  if (!args) SWIG_fail;
 
13275
  swig_obj[0] = args;
 
13276
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13277
  if (!SWIG_IsOK(res1)) {
 
13278
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasFontItalic" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13279
  }
 
13280
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13281
  {
 
13282
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13283
    result = (bool)((wxTextAttr const *)arg1)->HasFontItalic();
 
13284
    wxPyEndAllowThreads(__tstate);
 
13285
    if (PyErr_Occurred()) SWIG_fail;
 
13286
  }
 
13287
  {
 
13288
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13289
  }
 
13290
  return resultobj;
 
13291
fail:
 
13292
  return NULL;
 
13293
}
 
13294
 
 
13295
 
 
13296
SWIGINTERN PyObject *_wrap_TextAttr_HasFontUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13297
  PyObject *resultobj = 0;
 
13298
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13299
  bool result;
 
13300
  void *argp1 = 0 ;
 
13301
  int res1 = 0 ;
 
13302
  PyObject *swig_obj[1] ;
 
13303
  
 
13304
  if (!args) SWIG_fail;
 
13305
  swig_obj[0] = args;
 
13306
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13307
  if (!SWIG_IsOK(res1)) {
 
13308
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasFontUnderlined" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13309
  }
 
13310
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13311
  {
 
13312
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13313
    result = (bool)((wxTextAttr const *)arg1)->HasFontUnderlined();
 
13314
    wxPyEndAllowThreads(__tstate);
 
13315
    if (PyErr_Occurred()) SWIG_fail;
 
13316
  }
 
13317
  {
 
13318
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13319
  }
 
13320
  return resultobj;
 
13321
fail:
 
13322
  return NULL;
 
13323
}
 
13324
 
 
13325
 
 
13326
SWIGINTERN PyObject *_wrap_TextAttr_HasFontStrikethrough(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13327
  PyObject *resultobj = 0;
 
13328
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13329
  bool result;
 
13330
  void *argp1 = 0 ;
 
13331
  int res1 = 0 ;
 
13332
  PyObject *swig_obj[1] ;
 
13333
  
 
13334
  if (!args) SWIG_fail;
 
13335
  swig_obj[0] = args;
 
13336
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13337
  if (!SWIG_IsOK(res1)) {
 
13338
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasFontStrikethrough" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13339
  }
 
13340
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13341
  {
 
13342
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13343
    result = (bool)((wxTextAttr const *)arg1)->HasFontStrikethrough();
 
13344
    wxPyEndAllowThreads(__tstate);
 
13345
    if (PyErr_Occurred()) SWIG_fail;
 
13346
  }
 
13347
  {
 
13348
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13349
  }
 
13350
  return resultobj;
 
13351
fail:
 
13352
  return NULL;
 
13353
}
 
13354
 
 
13355
 
 
13356
SWIGINTERN PyObject *_wrap_TextAttr_HasFontFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13357
  PyObject *resultobj = 0;
 
13358
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13359
  bool result;
 
13360
  void *argp1 = 0 ;
 
13361
  int res1 = 0 ;
 
13362
  PyObject *swig_obj[1] ;
 
13363
  
 
13364
  if (!args) SWIG_fail;
 
13365
  swig_obj[0] = args;
 
13366
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13367
  if (!SWIG_IsOK(res1)) {
 
13368
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasFontFaceName" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13369
  }
 
13370
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13371
  {
 
13372
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13373
    result = (bool)((wxTextAttr const *)arg1)->HasFontFaceName();
 
13374
    wxPyEndAllowThreads(__tstate);
 
13375
    if (PyErr_Occurred()) SWIG_fail;
 
13376
  }
 
13377
  {
 
13378
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13379
  }
 
13380
  return resultobj;
 
13381
fail:
 
13382
  return NULL;
 
13383
}
 
13384
 
 
13385
 
 
13386
SWIGINTERN PyObject *_wrap_TextAttr_HasFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13387
  PyObject *resultobj = 0;
 
13388
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13389
  bool result;
 
13390
  void *argp1 = 0 ;
 
13391
  int res1 = 0 ;
 
13392
  PyObject *swig_obj[1] ;
 
13393
  
 
13394
  if (!args) SWIG_fail;
 
13395
  swig_obj[0] = args;
 
13396
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13397
  if (!SWIG_IsOK(res1)) {
 
13398
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasFontEncoding" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13399
  }
 
13400
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13401
  {
 
13402
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13403
    result = (bool)((wxTextAttr const *)arg1)->HasFontEncoding();
 
13404
    wxPyEndAllowThreads(__tstate);
 
13405
    if (PyErr_Occurred()) SWIG_fail;
 
13406
  }
 
13407
  {
 
13408
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13409
  }
 
13410
  return resultobj;
 
13411
fail:
 
13412
  return NULL;
 
13413
}
 
13414
 
 
13415
 
 
13416
SWIGINTERN PyObject *_wrap_TextAttr_HasFontFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13417
  PyObject *resultobj = 0;
 
13418
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13419
  bool result;
 
13420
  void *argp1 = 0 ;
 
13421
  int res1 = 0 ;
 
13422
  PyObject *swig_obj[1] ;
 
13423
  
 
13424
  if (!args) SWIG_fail;
 
13425
  swig_obj[0] = args;
 
13426
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13427
  if (!SWIG_IsOK(res1)) {
 
13428
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasFontFamily" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13429
  }
 
13430
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13431
  {
 
13432
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13433
    result = (bool)((wxTextAttr const *)arg1)->HasFontFamily();
 
13434
    wxPyEndAllowThreads(__tstate);
 
13435
    if (PyErr_Occurred()) SWIG_fail;
 
13436
  }
 
13437
  {
 
13438
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13439
  }
 
13440
  return resultobj;
 
13441
fail:
 
13442
  return NULL;
 
13443
}
 
13444
 
 
13445
 
 
13446
SWIGINTERN PyObject *_wrap_TextAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13447
  PyObject *resultobj = 0;
 
13448
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13449
  bool result;
 
13450
  void *argp1 = 0 ;
 
13451
  int res1 = 0 ;
 
13452
  PyObject *swig_obj[1] ;
 
13453
  
 
13454
  if (!args) SWIG_fail;
 
13455
  swig_obj[0] = args;
 
13456
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13457
  if (!SWIG_IsOK(res1)) {
 
13458
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasFont" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13459
  }
 
13460
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13461
  {
 
13462
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13463
    result = (bool)((wxTextAttr const *)arg1)->HasFont();
 
13464
    wxPyEndAllowThreads(__tstate);
 
13465
    if (PyErr_Occurred()) SWIG_fail;
 
13466
  }
 
13467
  {
 
13468
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13469
  }
 
13470
  return resultobj;
 
13471
fail:
 
13472
  return NULL;
 
13473
}
 
13474
 
 
13475
 
 
13476
SWIGINTERN PyObject *_wrap_TextAttr_HasParagraphSpacingAfter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13477
  PyObject *resultobj = 0;
 
13478
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13479
  bool result;
 
13480
  void *argp1 = 0 ;
 
13481
  int res1 = 0 ;
 
13482
  PyObject *swig_obj[1] ;
 
13483
  
 
13484
  if (!args) SWIG_fail;
 
13485
  swig_obj[0] = args;
 
13486
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13487
  if (!SWIG_IsOK(res1)) {
 
13488
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasParagraphSpacingAfter" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13489
  }
 
13490
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13491
  {
 
13492
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13493
    result = (bool)((wxTextAttr const *)arg1)->HasParagraphSpacingAfter();
 
13494
    wxPyEndAllowThreads(__tstate);
 
13495
    if (PyErr_Occurred()) SWIG_fail;
 
13496
  }
 
13497
  {
 
13498
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13499
  }
 
13500
  return resultobj;
 
13501
fail:
 
13502
  return NULL;
 
13503
}
 
13504
 
 
13505
 
 
13506
SWIGINTERN PyObject *_wrap_TextAttr_HasParagraphSpacingBefore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13507
  PyObject *resultobj = 0;
 
13508
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13509
  bool result;
 
13510
  void *argp1 = 0 ;
 
13511
  int res1 = 0 ;
 
13512
  PyObject *swig_obj[1] ;
 
13513
  
 
13514
  if (!args) SWIG_fail;
 
13515
  swig_obj[0] = args;
 
13516
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13517
  if (!SWIG_IsOK(res1)) {
 
13518
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasParagraphSpacingBefore" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13519
  }
 
13520
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13521
  {
 
13522
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13523
    result = (bool)((wxTextAttr const *)arg1)->HasParagraphSpacingBefore();
 
13524
    wxPyEndAllowThreads(__tstate);
 
13525
    if (PyErr_Occurred()) SWIG_fail;
 
13526
  }
 
13527
  {
 
13528
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13529
  }
 
13530
  return resultobj;
 
13531
fail:
 
13532
  return NULL;
 
13533
}
 
13534
 
 
13535
 
 
13536
SWIGINTERN PyObject *_wrap_TextAttr_HasLineSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13537
  PyObject *resultobj = 0;
 
13538
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13539
  bool result;
 
13540
  void *argp1 = 0 ;
 
13541
  int res1 = 0 ;
 
13542
  PyObject *swig_obj[1] ;
 
13543
  
 
13544
  if (!args) SWIG_fail;
 
13545
  swig_obj[0] = args;
 
13546
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13547
  if (!SWIG_IsOK(res1)) {
 
13548
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasLineSpacing" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13549
  }
 
13550
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13551
  {
 
13552
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13553
    result = (bool)((wxTextAttr const *)arg1)->HasLineSpacing();
 
13554
    wxPyEndAllowThreads(__tstate);
 
13555
    if (PyErr_Occurred()) SWIG_fail;
 
13556
  }
 
13557
  {
 
13558
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13559
  }
 
13560
  return resultobj;
 
13561
fail:
 
13562
  return NULL;
 
13563
}
 
13564
 
 
13565
 
 
13566
SWIGINTERN PyObject *_wrap_TextAttr_HasCharacterStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13567
  PyObject *resultobj = 0;
 
13568
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13569
  bool result;
 
13570
  void *argp1 = 0 ;
 
13571
  int res1 = 0 ;
 
13572
  PyObject *swig_obj[1] ;
 
13573
  
 
13574
  if (!args) SWIG_fail;
 
13575
  swig_obj[0] = args;
 
13576
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13577
  if (!SWIG_IsOK(res1)) {
 
13578
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasCharacterStyleName" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13579
  }
 
13580
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13581
  {
 
13582
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13583
    result = (bool)((wxTextAttr const *)arg1)->HasCharacterStyleName();
 
13584
    wxPyEndAllowThreads(__tstate);
 
13585
    if (PyErr_Occurred()) SWIG_fail;
 
13586
  }
 
13587
  {
 
13588
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13589
  }
 
13590
  return resultobj;
 
13591
fail:
 
13592
  return NULL;
 
13593
}
 
13594
 
 
13595
 
 
13596
SWIGINTERN PyObject *_wrap_TextAttr_HasParagraphStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13597
  PyObject *resultobj = 0;
 
13598
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13599
  bool result;
 
13600
  void *argp1 = 0 ;
 
13601
  int res1 = 0 ;
 
13602
  PyObject *swig_obj[1] ;
 
13603
  
 
13604
  if (!args) SWIG_fail;
 
13605
  swig_obj[0] = args;
 
13606
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13607
  if (!SWIG_IsOK(res1)) {
 
13608
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasParagraphStyleName" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13609
  }
 
13610
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13611
  {
 
13612
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13613
    result = (bool)((wxTextAttr const *)arg1)->HasParagraphStyleName();
 
13614
    wxPyEndAllowThreads(__tstate);
 
13615
    if (PyErr_Occurred()) SWIG_fail;
 
13616
  }
 
13617
  {
 
13618
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13619
  }
 
13620
  return resultobj;
 
13621
fail:
 
13622
  return NULL;
 
13623
}
 
13624
 
 
13625
 
 
13626
SWIGINTERN PyObject *_wrap_TextAttr_HasListStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13627
  PyObject *resultobj = 0;
 
13628
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13629
  bool result;
 
13630
  void *argp1 = 0 ;
 
13631
  int res1 = 0 ;
 
13632
  PyObject *swig_obj[1] ;
 
13633
  
 
13634
  if (!args) SWIG_fail;
 
13635
  swig_obj[0] = args;
 
13636
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13637
  if (!SWIG_IsOK(res1)) {
 
13638
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasListStyleName" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13639
  }
 
13640
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13641
  {
 
13642
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13643
    result = (bool)((wxTextAttr const *)arg1)->HasListStyleName();
 
13644
    wxPyEndAllowThreads(__tstate);
 
13645
    if (PyErr_Occurred()) SWIG_fail;
 
13646
  }
 
13647
  {
 
13648
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13649
  }
 
13650
  return resultobj;
 
13651
fail:
 
13652
  return NULL;
 
13653
}
 
13654
 
 
13655
 
 
13656
SWIGINTERN PyObject *_wrap_TextAttr_HasBulletStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13657
  PyObject *resultobj = 0;
 
13658
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13659
  bool result;
 
13660
  void *argp1 = 0 ;
 
13661
  int res1 = 0 ;
 
13662
  PyObject *swig_obj[1] ;
 
13663
  
 
13664
  if (!args) SWIG_fail;
 
13665
  swig_obj[0] = args;
 
13666
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13667
  if (!SWIG_IsOK(res1)) {
 
13668
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasBulletStyle" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13669
  }
 
13670
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13671
  {
 
13672
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13673
    result = (bool)((wxTextAttr const *)arg1)->HasBulletStyle();
 
13674
    wxPyEndAllowThreads(__tstate);
 
13675
    if (PyErr_Occurred()) SWIG_fail;
 
13676
  }
 
13677
  {
 
13678
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13679
  }
 
13680
  return resultobj;
 
13681
fail:
 
13682
  return NULL;
 
13683
}
 
13684
 
 
13685
 
 
13686
SWIGINTERN PyObject *_wrap_TextAttr_HasBulletNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13687
  PyObject *resultobj = 0;
 
13688
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13689
  bool result;
 
13690
  void *argp1 = 0 ;
 
13691
  int res1 = 0 ;
 
13692
  PyObject *swig_obj[1] ;
 
13693
  
 
13694
  if (!args) SWIG_fail;
 
13695
  swig_obj[0] = args;
 
13696
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13697
  if (!SWIG_IsOK(res1)) {
 
13698
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasBulletNumber" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13699
  }
 
13700
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13701
  {
 
13702
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13703
    result = (bool)((wxTextAttr const *)arg1)->HasBulletNumber();
 
13704
    wxPyEndAllowThreads(__tstate);
 
13705
    if (PyErr_Occurred()) SWIG_fail;
 
13706
  }
 
13707
  {
 
13708
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13709
  }
 
13710
  return resultobj;
 
13711
fail:
 
13712
  return NULL;
 
13713
}
 
13714
 
 
13715
 
 
13716
SWIGINTERN PyObject *_wrap_TextAttr_HasBulletText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13717
  PyObject *resultobj = 0;
 
13718
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13719
  bool result;
 
13720
  void *argp1 = 0 ;
 
13721
  int res1 = 0 ;
 
13722
  PyObject *swig_obj[1] ;
 
13723
  
 
13724
  if (!args) SWIG_fail;
 
13725
  swig_obj[0] = args;
 
13726
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13727
  if (!SWIG_IsOK(res1)) {
 
13728
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasBulletText" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13729
  }
 
13730
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13731
  {
 
13732
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13733
    result = (bool)((wxTextAttr const *)arg1)->HasBulletText();
 
13734
    wxPyEndAllowThreads(__tstate);
 
13735
    if (PyErr_Occurred()) SWIG_fail;
 
13736
  }
 
13737
  {
 
13738
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13739
  }
 
13740
  return resultobj;
 
13741
fail:
 
13742
  return NULL;
 
13743
}
 
13744
 
 
13745
 
 
13746
SWIGINTERN PyObject *_wrap_TextAttr_HasBulletName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13747
  PyObject *resultobj = 0;
 
13748
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13749
  bool result;
 
13750
  void *argp1 = 0 ;
 
13751
  int res1 = 0 ;
 
13752
  PyObject *swig_obj[1] ;
 
13753
  
 
13754
  if (!args) SWIG_fail;
 
13755
  swig_obj[0] = args;
 
13756
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13757
  if (!SWIG_IsOK(res1)) {
 
13758
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasBulletName" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13759
  }
 
13760
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13761
  {
 
13762
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13763
    result = (bool)((wxTextAttr const *)arg1)->HasBulletName();
 
13764
    wxPyEndAllowThreads(__tstate);
 
13765
    if (PyErr_Occurred()) SWIG_fail;
 
13766
  }
 
13767
  {
 
13768
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13769
  }
 
13770
  return resultobj;
 
13771
fail:
 
13772
  return NULL;
 
13773
}
 
13774
 
 
13775
 
 
13776
SWIGINTERN PyObject *_wrap_TextAttr_HasURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13777
  PyObject *resultobj = 0;
 
13778
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13779
  bool result;
 
13780
  void *argp1 = 0 ;
 
13781
  int res1 = 0 ;
 
13782
  PyObject *swig_obj[1] ;
 
13783
  
 
13784
  if (!args) SWIG_fail;
 
13785
  swig_obj[0] = args;
 
13786
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13787
  if (!SWIG_IsOK(res1)) {
 
13788
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasURL" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13789
  }
 
13790
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13791
  {
 
13792
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13793
    result = (bool)((wxTextAttr const *)arg1)->HasURL();
 
13794
    wxPyEndAllowThreads(__tstate);
 
13795
    if (PyErr_Occurred()) SWIG_fail;
 
13796
  }
 
13797
  {
 
13798
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13799
  }
 
13800
  return resultobj;
 
13801
fail:
 
13802
  return NULL;
 
13803
}
 
13804
 
 
13805
 
 
13806
SWIGINTERN PyObject *_wrap_TextAttr_HasPageBreak(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13807
  PyObject *resultobj = 0;
 
13808
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13809
  bool result;
 
13810
  void *argp1 = 0 ;
 
13811
  int res1 = 0 ;
 
13812
  PyObject *swig_obj[1] ;
 
13813
  
 
13814
  if (!args) SWIG_fail;
 
13815
  swig_obj[0] = args;
 
13816
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13817
  if (!SWIG_IsOK(res1)) {
 
13818
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasPageBreak" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13819
  }
 
13820
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13821
  {
 
13822
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13823
    result = (bool)((wxTextAttr const *)arg1)->HasPageBreak();
 
13824
    wxPyEndAllowThreads(__tstate);
 
13825
    if (PyErr_Occurred()) SWIG_fail;
 
13826
  }
 
13827
  {
 
13828
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13829
  }
 
13830
  return resultobj;
 
13831
fail:
 
13832
  return NULL;
 
13833
}
 
13834
 
 
13835
 
 
13836
SWIGINTERN PyObject *_wrap_TextAttr_HasTextEffects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13837
  PyObject *resultobj = 0;
 
13838
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13839
  bool result;
 
13840
  void *argp1 = 0 ;
 
13841
  int res1 = 0 ;
 
13842
  PyObject *swig_obj[1] ;
 
13843
  
 
13844
  if (!args) SWIG_fail;
 
13845
  swig_obj[0] = args;
 
13846
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13847
  if (!SWIG_IsOK(res1)) {
 
13848
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasTextEffects" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13849
  }
 
13850
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13851
  {
 
13852
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13853
    result = (bool)((wxTextAttr const *)arg1)->HasTextEffects();
 
13854
    wxPyEndAllowThreads(__tstate);
 
13855
    if (PyErr_Occurred()) SWIG_fail;
 
13856
  }
 
13857
  {
 
13858
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13859
  }
 
13860
  return resultobj;
 
13861
fail:
 
13862
  return NULL;
 
13863
}
 
13864
 
 
13865
 
 
13866
SWIGINTERN PyObject *_wrap_TextAttr_HasTextEffect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
13867
  PyObject *resultobj = 0;
 
13868
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13869
  int arg2 ;
 
13870
  bool result;
 
13871
  void *argp1 = 0 ;
 
13872
  int res1 = 0 ;
 
13873
  int val2 ;
 
13874
  int ecode2 = 0 ;
 
13875
  PyObject * obj0 = 0 ;
 
13876
  PyObject * obj1 = 0 ;
 
13877
  char *  kwnames[] = {
 
13878
    (char *) "self",(char *) "effect", NULL 
 
13879
  };
 
13880
  
 
13881
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_HasTextEffect",kwnames,&obj0,&obj1)) SWIG_fail;
 
13882
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13883
  if (!SWIG_IsOK(res1)) {
 
13884
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasTextEffect" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13885
  }
 
13886
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13887
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
13888
  if (!SWIG_IsOK(ecode2)) {
 
13889
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_HasTextEffect" "', expected argument " "2"" of type '" "int""'");
 
13890
  } 
 
13891
  arg2 = static_cast< int >(val2);
 
13892
  {
 
13893
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13894
    result = (bool)((wxTextAttr const *)arg1)->HasTextEffect(arg2);
 
13895
    wxPyEndAllowThreads(__tstate);
 
13896
    if (PyErr_Occurred()) SWIG_fail;
 
13897
  }
 
13898
  {
 
13899
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13900
  }
 
13901
  return resultobj;
 
13902
fail:
 
13903
  return NULL;
 
13904
}
 
13905
 
 
13906
 
 
13907
SWIGINTERN PyObject *_wrap_TextAttr_HasOutlineLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
13908
  PyObject *resultobj = 0;
 
13909
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13910
  bool result;
 
13911
  void *argp1 = 0 ;
 
13912
  int res1 = 0 ;
 
13913
  PyObject *swig_obj[1] ;
 
13914
  
 
13915
  if (!args) SWIG_fail;
 
13916
  swig_obj[0] = args;
 
13917
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13918
  if (!SWIG_IsOK(res1)) {
 
13919
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasOutlineLevel" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13920
  }
 
13921
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13922
  {
 
13923
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13924
    result = (bool)((wxTextAttr const *)arg1)->HasOutlineLevel();
 
13925
    wxPyEndAllowThreads(__tstate);
 
13926
    if (PyErr_Occurred()) SWIG_fail;
 
13927
  }
 
13928
  {
 
13929
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13930
  }
 
13931
  return resultobj;
 
13932
fail:
 
13933
  return NULL;
 
13934
}
 
13935
 
 
13936
 
 
13937
SWIGINTERN PyObject *_wrap_TextAttr_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
13938
  PyObject *resultobj = 0;
 
13939
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13940
  long arg2 ;
 
13941
  bool result;
 
13942
  void *argp1 = 0 ;
 
13943
  int res1 = 0 ;
 
13944
  long val2 ;
 
13945
  int ecode2 = 0 ;
 
13946
  PyObject * obj0 = 0 ;
 
13947
  PyObject * obj1 = 0 ;
 
13948
  char *  kwnames[] = {
 
13949
    (char *) "self",(char *) "flag", NULL 
 
13950
  };
 
13951
  
 
13952
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
 
13953
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13954
  if (!SWIG_IsOK(res1)) {
 
13955
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_HasFlag" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
13956
  }
 
13957
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13958
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
13959
  if (!SWIG_IsOK(ecode2)) {
 
13960
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_HasFlag" "', expected argument " "2"" of type '" "long""'");
 
13961
  } 
 
13962
  arg2 = static_cast< long >(val2);
 
13963
  {
 
13964
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
13965
    result = (bool)((wxTextAttr const *)arg1)->HasFlag(arg2);
 
13966
    wxPyEndAllowThreads(__tstate);
 
13967
    if (PyErr_Occurred()) SWIG_fail;
 
13968
  }
 
13969
  {
 
13970
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
13971
  }
 
13972
  return resultobj;
 
13973
fail:
 
13974
  return NULL;
 
13975
}
 
13976
 
 
13977
 
 
13978
SWIGINTERN PyObject *_wrap_TextAttr_RemoveFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
13979
  PyObject *resultobj = 0;
 
13980
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
13981
  long arg2 ;
 
13982
  void *argp1 = 0 ;
 
13983
  int res1 = 0 ;
 
13984
  long val2 ;
 
13985
  int ecode2 = 0 ;
 
13986
  PyObject * obj0 = 0 ;
 
13987
  PyObject * obj1 = 0 ;
 
13988
  char *  kwnames[] = {
 
13989
    (char *) "self",(char *) "flag", NULL 
 
13990
  };
 
13991
  
 
13992
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_RemoveFlag",kwnames,&obj0,&obj1)) SWIG_fail;
 
13993
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
13994
  if (!SWIG_IsOK(res1)) {
 
13995
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_RemoveFlag" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
13996
  }
 
13997
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
13998
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
13999
  if (!SWIG_IsOK(ecode2)) {
 
14000
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_RemoveFlag" "', expected argument " "2"" of type '" "long""'");
 
14001
  } 
 
14002
  arg2 = static_cast< long >(val2);
 
14003
  {
 
14004
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14005
    (arg1)->RemoveFlag(arg2);
 
14006
    wxPyEndAllowThreads(__tstate);
 
14007
    if (PyErr_Occurred()) SWIG_fail;
 
14008
  }
 
14009
  resultobj = SWIG_Py_Void();
 
14010
  return resultobj;
 
14011
fail:
 
14012
  return NULL;
 
14013
}
 
14014
 
 
14015
 
 
14016
SWIGINTERN PyObject *_wrap_TextAttr_AddFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14017
  PyObject *resultobj = 0;
 
14018
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
14019
  long arg2 ;
 
14020
  void *argp1 = 0 ;
 
14021
  int res1 = 0 ;
 
14022
  long val2 ;
 
14023
  int ecode2 = 0 ;
 
14024
  PyObject * obj0 = 0 ;
 
14025
  PyObject * obj1 = 0 ;
 
14026
  char *  kwnames[] = {
 
14027
    (char *) "self",(char *) "flag", NULL 
 
14028
  };
 
14029
  
 
14030
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_AddFlag",kwnames,&obj0,&obj1)) SWIG_fail;
 
14031
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
14032
  if (!SWIG_IsOK(res1)) {
 
14033
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_AddFlag" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
14034
  }
 
14035
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
14036
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
14037
  if (!SWIG_IsOK(ecode2)) {
 
14038
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_AddFlag" "', expected argument " "2"" of type '" "long""'");
 
14039
  } 
 
14040
  arg2 = static_cast< long >(val2);
 
14041
  {
 
14042
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14043
    (arg1)->AddFlag(arg2);
 
14044
    wxPyEndAllowThreads(__tstate);
 
14045
    if (PyErr_Occurred()) SWIG_fail;
 
14046
  }
 
14047
  resultobj = SWIG_Py_Void();
 
14048
  return resultobj;
 
14049
fail:
 
14050
  return NULL;
 
14051
}
 
14052
 
 
14053
 
 
14054
SWIGINTERN PyObject *_wrap_TextAttr_IsCharacterStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14055
  PyObject *resultobj = 0;
 
14056
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
14057
  bool result;
 
14058
  void *argp1 = 0 ;
 
14059
  int res1 = 0 ;
 
14060
  PyObject *swig_obj[1] ;
 
14061
  
 
14062
  if (!args) SWIG_fail;
 
14063
  swig_obj[0] = args;
 
14064
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
14065
  if (!SWIG_IsOK(res1)) {
 
14066
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_IsCharacterStyle" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
14067
  }
 
14068
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
14069
  {
 
14070
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14071
    result = (bool)((wxTextAttr const *)arg1)->IsCharacterStyle();
 
14072
    wxPyEndAllowThreads(__tstate);
 
14073
    if (PyErr_Occurred()) SWIG_fail;
 
14074
  }
 
14075
  {
 
14076
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14077
  }
 
14078
  return resultobj;
 
14079
fail:
 
14080
  return NULL;
 
14081
}
 
14082
 
 
14083
 
 
14084
SWIGINTERN PyObject *_wrap_TextAttr_IsParagraphStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14085
  PyObject *resultobj = 0;
 
14086
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
14087
  bool result;
 
14088
  void *argp1 = 0 ;
 
14089
  int res1 = 0 ;
 
14090
  PyObject *swig_obj[1] ;
 
14091
  
 
14092
  if (!args) SWIG_fail;
 
14093
  swig_obj[0] = args;
 
14094
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
14095
  if (!SWIG_IsOK(res1)) {
 
14096
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_IsParagraphStyle" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
14097
  }
 
14098
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
14099
  {
 
14100
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14101
    result = (bool)((wxTextAttr const *)arg1)->IsParagraphStyle();
 
14102
    wxPyEndAllowThreads(__tstate);
 
14103
    if (PyErr_Occurred()) SWIG_fail;
 
14104
  }
 
14105
  {
 
14106
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14107
  }
 
14108
  return resultobj;
 
14109
fail:
 
14110
  return NULL;
 
14111
}
 
14112
 
 
14113
 
 
14114
SWIGINTERN PyObject *_wrap_TextAttr_IsDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14115
  PyObject *resultobj = 0;
 
14116
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
14117
  bool result;
 
14118
  void *argp1 = 0 ;
 
14119
  int res1 = 0 ;
 
14120
  PyObject *swig_obj[1] ;
 
14121
  
 
14122
  if (!args) SWIG_fail;
 
14123
  swig_obj[0] = args;
 
14124
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
14125
  if (!SWIG_IsOK(res1)) {
 
14126
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_IsDefault" "', expected argument " "1"" of type '" "wxTextAttr const *""'"); 
 
14127
  }
 
14128
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
14129
  {
 
14130
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14131
    result = (bool)((wxTextAttr const *)arg1)->IsDefault();
 
14132
    wxPyEndAllowThreads(__tstate);
 
14133
    if (PyErr_Occurred()) SWIG_fail;
 
14134
  }
 
14135
  {
 
14136
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14137
  }
 
14138
  return resultobj;
 
14139
fail:
 
14140
  return NULL;
 
14141
}
 
14142
 
 
14143
 
 
14144
SWIGINTERN PyObject *_wrap_TextAttr_Apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14145
  PyObject *resultobj = 0;
 
14146
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
14147
  wxTextAttr *arg2 = 0 ;
 
14148
  wxTextAttr *arg3 = (wxTextAttr *) NULL ;
 
14149
  bool result;
 
14150
  void *argp1 = 0 ;
 
14151
  int res1 = 0 ;
 
14152
  void *argp2 = 0 ;
 
14153
  int res2 = 0 ;
 
14154
  void *argp3 = 0 ;
 
14155
  int res3 = 0 ;
 
14156
  PyObject * obj0 = 0 ;
 
14157
  PyObject * obj1 = 0 ;
 
14158
  PyObject * obj2 = 0 ;
 
14159
  char *  kwnames[] = {
 
14160
    (char *) "self",(char *) "style",(char *) "compareWith", NULL 
 
14161
  };
 
14162
  
 
14163
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TextAttr_Apply",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
14164
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
14165
  if (!SWIG_IsOK(res1)) {
 
14166
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_Apply" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
14167
  }
 
14168
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
14169
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttr,  0  | 0);
 
14170
  if (!SWIG_IsOK(res2)) {
 
14171
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextAttr_Apply" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
14172
  }
 
14173
  if (!argp2) {
 
14174
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_Apply" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
14175
  }
 
14176
  arg2 = reinterpret_cast< wxTextAttr * >(argp2);
 
14177
  if (obj2) {
 
14178
    res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
14179
    if (!SWIG_IsOK(res3)) {
 
14180
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TextAttr_Apply" "', expected argument " "3"" of type '" "wxTextAttr const *""'"); 
 
14181
    }
 
14182
    arg3 = reinterpret_cast< wxTextAttr * >(argp3);
 
14183
  }
 
14184
  {
 
14185
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14186
    result = (bool)(arg1)->Apply((wxTextAttr const &)*arg2,(wxTextAttr const *)arg3);
 
14187
    wxPyEndAllowThreads(__tstate);
 
14188
    if (PyErr_Occurred()) SWIG_fail;
 
14189
  }
 
14190
  {
 
14191
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14192
  }
 
14193
  return resultobj;
 
14194
fail:
 
14195
  return NULL;
 
14196
}
 
14197
 
 
14198
 
 
14199
SWIGINTERN PyObject *_wrap_TextAttr_Merge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14200
  PyObject *resultobj = 0;
 
14201
  wxTextAttr *arg1 = (wxTextAttr *) 0 ;
 
14202
  wxTextAttr *arg2 = 0 ;
 
14203
  void *argp1 = 0 ;
 
14204
  int res1 = 0 ;
 
14205
  void *argp2 = 0 ;
 
14206
  int res2 = 0 ;
 
14207
  PyObject * obj0 = 0 ;
 
14208
  PyObject * obj1 = 0 ;
 
14209
  char *  kwnames[] = {
 
14210
    (char *) "self",(char *) "overlay", NULL 
 
14211
  };
 
14212
  
 
14213
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_Merge",kwnames,&obj0,&obj1)) SWIG_fail;
 
14214
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttr, 0 |  0 );
 
14215
  if (!SWIG_IsOK(res1)) {
 
14216
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_Merge" "', expected argument " "1"" of type '" "wxTextAttr *""'"); 
 
14217
  }
 
14218
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
14219
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttr,  0  | 0);
 
14220
  if (!SWIG_IsOK(res2)) {
 
14221
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextAttr_Merge" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
14222
  }
 
14223
  if (!argp2) {
 
14224
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_Merge" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
14225
  }
 
14226
  arg2 = reinterpret_cast< wxTextAttr * >(argp2);
 
14227
  {
 
14228
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14229
    (arg1)->Merge((wxTextAttr const &)*arg2);
 
14230
    wxPyEndAllowThreads(__tstate);
 
14231
    if (PyErr_Occurred()) SWIG_fail;
 
14232
  }
 
14233
  resultobj = SWIG_Py_Void();
 
14234
  return resultobj;
 
14235
fail:
 
14236
  return NULL;
 
14237
}
 
14238
 
 
14239
 
 
14240
SWIGINTERN PyObject *_wrap_TextAttr_Combine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14241
  PyObject *resultobj = 0;
 
14242
  wxTextAttr *arg1 = 0 ;
 
14243
  wxTextAttr *arg2 = 0 ;
 
14244
  wxTextCtrl *arg3 = (wxTextCtrl *) 0 ;
 
14245
  wxTextAttr result;
 
14246
  void *argp1 = 0 ;
 
14247
  int res1 = 0 ;
 
14248
  void *argp2 = 0 ;
 
14249
  int res2 = 0 ;
 
14250
  void *argp3 = 0 ;
 
14251
  int res3 = 0 ;
 
14252
  PyObject * obj0 = 0 ;
 
14253
  PyObject * obj1 = 0 ;
 
14254
  PyObject * obj2 = 0 ;
 
14255
  char *  kwnames[] = {
 
14256
    (char *) "attr",(char *) "attrDef",(char *) "text", NULL 
 
14257
  };
 
14258
  
 
14259
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextAttr_Combine",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
14260
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxTextAttr,  0  | 0);
 
14261
  if (!SWIG_IsOK(res1)) {
 
14262
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_Combine" "', expected argument " "1"" of type '" "wxTextAttr const &""'"); 
 
14263
  }
 
14264
  if (!argp1) {
 
14265
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_Combine" "', expected argument " "1"" of type '" "wxTextAttr const &""'"); 
 
14266
  }
 
14267
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
14268
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttr,  0  | 0);
 
14269
  if (!SWIG_IsOK(res2)) {
 
14270
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextAttr_Combine" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
14271
  }
 
14272
  if (!argp2) {
 
14273
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_Combine" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
14274
  }
 
14275
  arg2 = reinterpret_cast< wxTextAttr * >(argp2);
 
14276
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxTextCtrl, 0 |  0 );
 
14277
  if (!SWIG_IsOK(res3)) {
 
14278
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TextAttr_Combine" "', expected argument " "3"" of type '" "wxTextCtrl const *""'"); 
 
14279
  }
 
14280
  arg3 = reinterpret_cast< wxTextCtrl * >(argp3);
 
14281
  {
 
14282
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14283
    result = wxTextAttr::Combine((wxTextAttr const &)*arg1,(wxTextAttr const &)*arg2,(wxTextCtrl const *)arg3);
 
14284
    wxPyEndAllowThreads(__tstate);
 
14285
    if (PyErr_Occurred()) SWIG_fail;
 
14286
  }
 
14287
  resultobj = SWIG_NewPointerObj((new wxTextAttr(static_cast< const wxTextAttr& >(result))), SWIGTYPE_p_wxTextAttr, SWIG_POINTER_OWN |  0 );
 
14288
  return resultobj;
 
14289
fail:
 
14290
  return NULL;
 
14291
}
 
14292
 
 
14293
 
 
14294
SWIGINTERN PyObject *_wrap_TextAttr_TabsEq(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14295
  PyObject *resultobj = 0;
 
14296
  wxArrayInt *arg1 = 0 ;
 
14297
  wxArrayInt *arg2 = 0 ;
 
14298
  bool result;
 
14299
  bool temp1 = false ;
 
14300
  bool temp2 = false ;
 
14301
  PyObject * obj0 = 0 ;
 
14302
  PyObject * obj1 = 0 ;
 
14303
  char *  kwnames[] = {
 
14304
    (char *) "tabs1",(char *) "tabs2", NULL 
 
14305
  };
 
14306
  
 
14307
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_TabsEq",kwnames,&obj0,&obj1)) SWIG_fail;
 
14308
  {
 
14309
    if (! PySequence_Check(obj0)) {
 
14310
      PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
 
14311
      SWIG_fail;
 
14312
    }
 
14313
    arg1 = new wxArrayInt;
 
14314
    temp1 = true;
 
14315
    int i, len=PySequence_Length(obj0);
 
14316
    for (i=0; i<len; i++) {
 
14317
      PyObject* item = PySequence_GetItem(obj0, i);
 
14318
      PyObject* number  = PyNumber_Int(item);
 
14319
      if (!number) {
 
14320
        PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
 
14321
        SWIG_fail;
 
14322
      }       
 
14323
      arg1->Add(PyInt_AS_LONG(number));
 
14324
      Py_DECREF(item);
 
14325
      Py_DECREF(number);
 
14326
    }
 
14327
  }
 
14328
  {
 
14329
    if (! PySequence_Check(obj1)) {
 
14330
      PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
 
14331
      SWIG_fail;
 
14332
    }
 
14333
    arg2 = new wxArrayInt;
 
14334
    temp2 = true;
 
14335
    int i, len=PySequence_Length(obj1);
 
14336
    for (i=0; i<len; i++) {
 
14337
      PyObject* item = PySequence_GetItem(obj1, i);
 
14338
      PyObject* number  = PyNumber_Int(item);
 
14339
      if (!number) {
 
14340
        PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
 
14341
        SWIG_fail;
 
14342
      }       
 
14343
      arg2->Add(PyInt_AS_LONG(number));
 
14344
      Py_DECREF(item);
 
14345
      Py_DECREF(number);
 
14346
    }
 
14347
  }
 
14348
  {
 
14349
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14350
    result = (bool)wxTextAttr::TabsEq((wxArrayInt const &)*arg1,(wxArrayInt const &)*arg2);
 
14351
    wxPyEndAllowThreads(__tstate);
 
14352
    if (PyErr_Occurred()) SWIG_fail;
 
14353
  }
 
14354
  {
 
14355
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14356
  }
 
14357
  {
 
14358
    if (temp1) delete arg1;
 
14359
  }
 
14360
  {
 
14361
    if (temp2) delete arg2;
 
14362
  }
 
14363
  return resultobj;
 
14364
fail:
 
14365
  {
 
14366
    if (temp1) delete arg1;
 
14367
  }
 
14368
  {
 
14369
    if (temp2) delete arg2;
 
14370
  }
 
14371
  return NULL;
 
14372
}
 
14373
 
 
14374
 
 
14375
SWIGINTERN PyObject *_wrap_TextAttr_RemoveStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14376
  PyObject *resultobj = 0;
 
14377
  wxTextAttr *arg1 = 0 ;
 
14378
  wxTextAttr *arg2 = 0 ;
 
14379
  bool result;
 
14380
  void *argp1 = 0 ;
 
14381
  int res1 = 0 ;
 
14382
  void *argp2 = 0 ;
 
14383
  int res2 = 0 ;
 
14384
  PyObject * obj0 = 0 ;
 
14385
  PyObject * obj1 = 0 ;
 
14386
  char *  kwnames[] = {
 
14387
    (char *) "destStyle",(char *) "style", NULL 
 
14388
  };
 
14389
  
 
14390
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttr_RemoveStyle",kwnames,&obj0,&obj1)) SWIG_fail;
 
14391
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxTextAttr,  0 );
 
14392
  if (!SWIG_IsOK(res1)) {
 
14393
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_RemoveStyle" "', expected argument " "1"" of type '" "wxTextAttr &""'"); 
 
14394
  }
 
14395
  if (!argp1) {
 
14396
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_RemoveStyle" "', expected argument " "1"" of type '" "wxTextAttr &""'"); 
 
14397
  }
 
14398
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
14399
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttr,  0  | 0);
 
14400
  if (!SWIG_IsOK(res2)) {
 
14401
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextAttr_RemoveStyle" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
14402
  }
 
14403
  if (!argp2) {
 
14404
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_RemoveStyle" "', expected argument " "2"" of type '" "wxTextAttr const &""'"); 
 
14405
  }
 
14406
  arg2 = reinterpret_cast< wxTextAttr * >(argp2);
 
14407
  {
 
14408
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14409
    result = (bool)wxTextAttr::RemoveStyle(*arg1,(wxTextAttr const &)*arg2);
 
14410
    wxPyEndAllowThreads(__tstate);
 
14411
    if (PyErr_Occurred()) SWIG_fail;
 
14412
  }
 
14413
  {
 
14414
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14415
  }
 
14416
  return resultobj;
 
14417
fail:
 
14418
  return NULL;
 
14419
}
 
14420
 
 
14421
 
 
14422
SWIGINTERN PyObject *_wrap_TextAttr_CombineBitlists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14423
  PyObject *resultobj = 0;
 
14424
  int *arg1 = 0 ;
 
14425
  int arg2 ;
 
14426
  int *arg3 = 0 ;
 
14427
  int arg4 ;
 
14428
  bool result;
 
14429
  void *argp1 = 0 ;
 
14430
  int res1 = 0 ;
 
14431
  int val2 ;
 
14432
  int ecode2 = 0 ;
 
14433
  void *argp3 = 0 ;
 
14434
  int res3 = 0 ;
 
14435
  int val4 ;
 
14436
  int ecode4 = 0 ;
 
14437
  PyObject * obj0 = 0 ;
 
14438
  PyObject * obj1 = 0 ;
 
14439
  PyObject * obj2 = 0 ;
 
14440
  PyObject * obj3 = 0 ;
 
14441
  char *  kwnames[] = {
 
14442
    (char *) "valueA",(char *) "valueB",(char *) "flagsA",(char *) "flagsB", NULL 
 
14443
  };
 
14444
  
 
14445
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextAttr_CombineBitlists",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
14446
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int,  0 );
 
14447
  if (!SWIG_IsOK(res1)) {
 
14448
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_CombineBitlists" "', expected argument " "1"" of type '" "int &""'"); 
 
14449
  }
 
14450
  if (!argp1) {
 
14451
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_CombineBitlists" "', expected argument " "1"" of type '" "int &""'"); 
 
14452
  }
 
14453
  arg1 = reinterpret_cast< int * >(argp1);
 
14454
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
14455
  if (!SWIG_IsOK(ecode2)) {
 
14456
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_CombineBitlists" "', expected argument " "2"" of type '" "int""'");
 
14457
  } 
 
14458
  arg2 = static_cast< int >(val2);
 
14459
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
 
14460
  if (!SWIG_IsOK(res3)) {
 
14461
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TextAttr_CombineBitlists" "', expected argument " "3"" of type '" "int &""'"); 
 
14462
  }
 
14463
  if (!argp3) {
 
14464
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_CombineBitlists" "', expected argument " "3"" of type '" "int &""'"); 
 
14465
  }
 
14466
  arg3 = reinterpret_cast< int * >(argp3);
 
14467
  ecode4 = SWIG_AsVal_int(obj3, &val4);
 
14468
  if (!SWIG_IsOK(ecode4)) {
 
14469
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextAttr_CombineBitlists" "', expected argument " "4"" of type '" "int""'");
 
14470
  } 
 
14471
  arg4 = static_cast< int >(val4);
 
14472
  {
 
14473
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14474
    result = (bool)wxTextAttr::CombineBitlists(*arg1,arg2,*arg3,arg4);
 
14475
    wxPyEndAllowThreads(__tstate);
 
14476
    if (PyErr_Occurred()) SWIG_fail;
 
14477
  }
 
14478
  {
 
14479
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14480
  }
 
14481
  return resultobj;
 
14482
fail:
 
14483
  return NULL;
 
14484
}
 
14485
 
 
14486
 
 
14487
SWIGINTERN PyObject *_wrap_TextAttr_BitlistsEqPartial(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14488
  PyObject *resultobj = 0;
 
14489
  int arg1 ;
 
14490
  int arg2 ;
 
14491
  int arg3 ;
 
14492
  bool result;
 
14493
  int val1 ;
 
14494
  int ecode1 = 0 ;
 
14495
  int val2 ;
 
14496
  int ecode2 = 0 ;
 
14497
  int val3 ;
 
14498
  int ecode3 = 0 ;
 
14499
  PyObject * obj0 = 0 ;
 
14500
  PyObject * obj1 = 0 ;
 
14501
  PyObject * obj2 = 0 ;
 
14502
  char *  kwnames[] = {
 
14503
    (char *) "valueA",(char *) "valueB",(char *) "flags", NULL 
 
14504
  };
 
14505
  
 
14506
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextAttr_BitlistsEqPartial",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
14507
  ecode1 = SWIG_AsVal_int(obj0, &val1);
 
14508
  if (!SWIG_IsOK(ecode1)) {
 
14509
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TextAttr_BitlistsEqPartial" "', expected argument " "1"" of type '" "int""'");
 
14510
  } 
 
14511
  arg1 = static_cast< int >(val1);
 
14512
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
14513
  if (!SWIG_IsOK(ecode2)) {
 
14514
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttr_BitlistsEqPartial" "', expected argument " "2"" of type '" "int""'");
 
14515
  } 
 
14516
  arg2 = static_cast< int >(val2);
 
14517
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
14518
  if (!SWIG_IsOK(ecode3)) {
 
14519
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextAttr_BitlistsEqPartial" "', expected argument " "3"" of type '" "int""'");
 
14520
  } 
 
14521
  arg3 = static_cast< int >(val3);
 
14522
  {
 
14523
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14524
    result = (bool)wxTextAttr::BitlistsEqPartial(arg1,arg2,arg3);
 
14525
    wxPyEndAllowThreads(__tstate);
 
14526
    if (PyErr_Occurred()) SWIG_fail;
 
14527
  }
 
14528
  {
 
14529
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14530
  }
 
14531
  return resultobj;
 
14532
fail:
 
14533
  return NULL;
 
14534
}
 
14535
 
 
14536
 
 
14537
SWIGINTERN PyObject *_wrap_TextAttr_SplitParaCharStyles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14538
  PyObject *resultobj = 0;
 
14539
  wxTextAttr *arg1 = 0 ;
 
14540
  wxTextAttr *arg2 = 0 ;
 
14541
  wxTextAttr *arg3 = 0 ;
 
14542
  bool result;
 
14543
  void *argp1 = 0 ;
 
14544
  int res1 = 0 ;
 
14545
  void *argp2 = 0 ;
 
14546
  int res2 = 0 ;
 
14547
  void *argp3 = 0 ;
 
14548
  int res3 = 0 ;
 
14549
  PyObject * obj0 = 0 ;
 
14550
  PyObject * obj1 = 0 ;
 
14551
  PyObject * obj2 = 0 ;
 
14552
  char *  kwnames[] = {
 
14553
    (char *) "style",(char *) "parStyle",(char *) "charStyle", NULL 
 
14554
  };
 
14555
  
 
14556
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextAttr_SplitParaCharStyles",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
14557
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxTextAttr,  0  | 0);
 
14558
  if (!SWIG_IsOK(res1)) {
 
14559
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttr_SplitParaCharStyles" "', expected argument " "1"" of type '" "wxTextAttr const &""'"); 
 
14560
  }
 
14561
  if (!argp1) {
 
14562
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_SplitParaCharStyles" "', expected argument " "1"" of type '" "wxTextAttr const &""'"); 
 
14563
  }
 
14564
  arg1 = reinterpret_cast< wxTextAttr * >(argp1);
 
14565
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttr,  0 );
 
14566
  if (!SWIG_IsOK(res2)) {
 
14567
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextAttr_SplitParaCharStyles" "', expected argument " "2"" of type '" "wxTextAttr &""'"); 
 
14568
  }
 
14569
  if (!argp2) {
 
14570
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_SplitParaCharStyles" "', expected argument " "2"" of type '" "wxTextAttr &""'"); 
 
14571
  }
 
14572
  arg2 = reinterpret_cast< wxTextAttr * >(argp2);
 
14573
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttr,  0 );
 
14574
  if (!SWIG_IsOK(res3)) {
 
14575
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TextAttr_SplitParaCharStyles" "', expected argument " "3"" of type '" "wxTextAttr &""'"); 
 
14576
  }
 
14577
  if (!argp3) {
 
14578
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttr_SplitParaCharStyles" "', expected argument " "3"" of type '" "wxTextAttr &""'"); 
 
14579
  }
 
14580
  arg3 = reinterpret_cast< wxTextAttr * >(argp3);
 
14581
  {
 
14582
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14583
    result = (bool)wxTextAttr::SplitParaCharStyles((wxTextAttr const &)*arg1,*arg2,*arg3);
 
14584
    wxPyEndAllowThreads(__tstate);
 
14585
    if (PyErr_Occurred()) SWIG_fail;
 
14586
  }
 
14587
  {
 
14588
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14589
  }
 
14590
  return resultobj;
 
14591
fail:
 
14592
  return NULL;
 
14593
}
 
14594
 
 
14595
 
 
14596
SWIGINTERN PyObject *TextAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14597
  PyObject *obj;
 
14598
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
14599
  SWIG_TypeNewClientData(SWIGTYPE_p_wxTextAttr, SWIG_NewClientData(obj));
 
14600
  return SWIG_Py_Void();
 
14601
}
 
14602
 
 
14603
SWIGINTERN PyObject *TextAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14604
  return SWIG_Python_InitShadowInstance(args);
 
14605
}
 
14606
 
 
14607
SWIGINTERN PyObject *_wrap_new_TextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14608
  PyObject *resultobj = 0;
 
14609
  wxWindow *arg1 = (wxWindow *) 0 ;
 
14610
  int arg2 = (int) -1 ;
 
14611
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
14612
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
14613
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
14614
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
14615
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
14616
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
14617
  long arg6 = (long) 0 ;
 
14618
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
14619
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
14620
  wxString const &arg8_defvalue = wxPyTextCtrlNameStr ;
 
14621
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
14622
  wxTextCtrl *result = 0 ;
 
14623
  void *argp1 = 0 ;
 
14624
  int res1 = 0 ;
 
14625
  int val2 ;
 
14626
  int ecode2 = 0 ;
 
14627
  bool temp3 = false ;
 
14628
  wxPoint temp4 ;
 
14629
  wxSize temp5 ;
 
14630
  long val6 ;
 
14631
  int ecode6 = 0 ;
 
14632
  void *argp7 = 0 ;
 
14633
  int res7 = 0 ;
 
14634
  bool temp8 = false ;
 
14635
  PyObject * obj0 = 0 ;
 
14636
  PyObject * obj1 = 0 ;
 
14637
  PyObject * obj2 = 0 ;
 
14638
  PyObject * obj3 = 0 ;
 
14639
  PyObject * obj4 = 0 ;
 
14640
  PyObject * obj5 = 0 ;
 
14641
  PyObject * obj6 = 0 ;
 
14642
  PyObject * obj7 = 0 ;
 
14643
  char *  kwnames[] = {
 
14644
    (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
14645
  };
 
14646
  
 
14647
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_TextCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
14648
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
14649
  if (!SWIG_IsOK(res1)) {
 
14650
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TextCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
14651
  }
 
14652
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
14653
  if (obj1) {
 
14654
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
14655
    if (!SWIG_IsOK(ecode2)) {
 
14656
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TextCtrl" "', expected argument " "2"" of type '" "int""'");
 
14657
    } 
 
14658
    arg2 = static_cast< int >(val2);
 
14659
  }
 
14660
  if (obj2) {
 
14661
    {
 
14662
      arg3 = wxString_in_helper(obj2);
 
14663
      if (arg3 == NULL) SWIG_fail;
 
14664
      temp3 = true;
 
14665
    }
 
14666
  }
 
14667
  if (obj3) {
 
14668
    {
 
14669
      arg4 = &temp4;
 
14670
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
14671
    }
 
14672
  }
 
14673
  if (obj4) {
 
14674
    {
 
14675
      arg5 = &temp5;
 
14676
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
14677
    }
 
14678
  }
 
14679
  if (obj5) {
 
14680
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
14681
    if (!SWIG_IsOK(ecode6)) {
 
14682
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TextCtrl" "', expected argument " "6"" of type '" "long""'");
 
14683
    } 
 
14684
    arg6 = static_cast< long >(val6);
 
14685
  }
 
14686
  if (obj6) {
 
14687
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
14688
    if (!SWIG_IsOK(res7)) {
 
14689
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_TextCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
14690
    }
 
14691
    if (!argp7) {
 
14692
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
14693
    }
 
14694
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
14695
  }
 
14696
  if (obj7) {
 
14697
    {
 
14698
      arg8 = wxString_in_helper(obj7);
 
14699
      if (arg8 == NULL) SWIG_fail;
 
14700
      temp8 = true;
 
14701
    }
 
14702
  }
 
14703
  {
 
14704
    if (!wxPyCheckForApp()) SWIG_fail;
 
14705
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14706
    result = (wxTextCtrl *)new wxTextCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
14707
    wxPyEndAllowThreads(__tstate);
 
14708
    if (PyErr_Occurred()) SWIG_fail;
 
14709
  }
 
14710
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_NEW |  0 );
 
14711
  {
 
14712
    if (temp3)
 
14713
    delete arg3;
 
14714
  }
 
14715
  {
 
14716
    if (temp8)
 
14717
    delete arg8;
 
14718
  }
 
14719
  return resultobj;
 
14720
fail:
 
14721
  {
 
14722
    if (temp3)
 
14723
    delete arg3;
 
14724
  }
 
14725
  {
 
14726
    if (temp8)
 
14727
    delete arg8;
 
14728
  }
 
14729
  return NULL;
 
14730
}
 
14731
 
 
14732
 
 
14733
SWIGINTERN PyObject *_wrap_new_PreTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14734
  PyObject *resultobj = 0;
 
14735
  wxTextCtrl *result = 0 ;
 
14736
  
 
14737
  if (!SWIG_Python_UnpackTuple(args,"new_PreTextCtrl",0,0,0)) SWIG_fail;
 
14738
  {
 
14739
    if (!wxPyCheckForApp()) SWIG_fail;
 
14740
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14741
    result = (wxTextCtrl *)new wxTextCtrl();
 
14742
    wxPyEndAllowThreads(__tstate);
 
14743
    if (PyErr_Occurred()) SWIG_fail;
 
14744
  }
 
14745
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_OWN |  0 );
 
14746
  return resultobj;
 
14747
fail:
 
14748
  return NULL;
 
14749
}
 
14750
 
 
14751
 
 
14752
SWIGINTERN PyObject *_wrap_TextCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14753
  PyObject *resultobj = 0;
 
14754
  wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
 
14755
  wxWindow *arg2 = (wxWindow *) 0 ;
 
14756
  int arg3 = (int) -1 ;
 
14757
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
14758
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
14759
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
14760
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
14761
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
14762
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
14763
  long arg7 = (long) 0 ;
 
14764
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
14765
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
14766
  wxString const &arg9_defvalue = wxPyTextCtrlNameStr ;
 
14767
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
14768
  bool result;
 
14769
  void *argp1 = 0 ;
 
14770
  int res1 = 0 ;
 
14771
  void *argp2 = 0 ;
 
14772
  int res2 = 0 ;
 
14773
  int val3 ;
 
14774
  int ecode3 = 0 ;
 
14775
  bool temp4 = false ;
 
14776
  wxPoint temp5 ;
 
14777
  wxSize temp6 ;
 
14778
  long val7 ;
 
14779
  int ecode7 = 0 ;
 
14780
  void *argp8 = 0 ;
 
14781
  int res8 = 0 ;
 
14782
  bool temp9 = false ;
 
14783
  PyObject * obj0 = 0 ;
 
14784
  PyObject * obj1 = 0 ;
 
14785
  PyObject * obj2 = 0 ;
 
14786
  PyObject * obj3 = 0 ;
 
14787
  PyObject * obj4 = 0 ;
 
14788
  PyObject * obj5 = 0 ;
 
14789
  PyObject * obj6 = 0 ;
 
14790
  PyObject * obj7 = 0 ;
 
14791
  PyObject * obj8 = 0 ;
 
14792
  char *  kwnames[] = {
 
14793
    (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
14794
  };
 
14795
  
 
14796
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:TextCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
14797
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 |  0 );
 
14798
  if (!SWIG_IsOK(res1)) {
 
14799
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextCtrl_Create" "', expected argument " "1"" of type '" "wxTextCtrl *""'"); 
 
14800
  }
 
14801
  arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
 
14802
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
14803
  if (!SWIG_IsOK(res2)) {
 
14804
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
14805
  }
 
14806
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
14807
  if (obj2) {
 
14808
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
14809
    if (!SWIG_IsOK(ecode3)) {
 
14810
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
14811
    } 
 
14812
    arg3 = static_cast< int >(val3);
 
14813
  }
 
14814
  if (obj3) {
 
14815
    {
 
14816
      arg4 = wxString_in_helper(obj3);
 
14817
      if (arg4 == NULL) SWIG_fail;
 
14818
      temp4 = true;
 
14819
    }
 
14820
  }
 
14821
  if (obj4) {
 
14822
    {
 
14823
      arg5 = &temp5;
 
14824
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
14825
    }
 
14826
  }
 
14827
  if (obj5) {
 
14828
    {
 
14829
      arg6 = &temp6;
 
14830
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
14831
    }
 
14832
  }
 
14833
  if (obj6) {
 
14834
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
14835
    if (!SWIG_IsOK(ecode7)) {
 
14836
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "TextCtrl_Create" "', expected argument " "7"" of type '" "long""'");
 
14837
    } 
 
14838
    arg7 = static_cast< long >(val7);
 
14839
  }
 
14840
  if (obj7) {
 
14841
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
14842
    if (!SWIG_IsOK(res8)) {
 
14843
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "TextCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
14844
    }
 
14845
    if (!argp8) {
 
14846
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
14847
    }
 
14848
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
14849
  }
 
14850
  if (obj8) {
 
14851
    {
 
14852
      arg9 = wxString_in_helper(obj8);
 
14853
      if (arg9 == NULL) SWIG_fail;
 
14854
      temp9 = true;
 
14855
    }
 
14856
  }
 
14857
  {
 
14858
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14859
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
14860
    wxPyEndAllowThreads(__tstate);
 
14861
    if (PyErr_Occurred()) SWIG_fail;
 
14862
  }
 
14863
  {
 
14864
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14865
  }
 
14866
  {
 
14867
    if (temp4)
 
14868
    delete arg4;
 
14869
  }
 
14870
  {
 
14871
    if (temp9)
 
14872
    delete arg9;
 
14873
  }
 
14874
  return resultobj;
 
14875
fail:
 
14876
  {
 
14877
    if (temp4)
 
14878
    delete arg4;
 
14879
  }
 
14880
  {
 
14881
    if (temp9)
 
14882
    delete arg9;
 
14883
  }
 
14884
  return NULL;
 
14885
}
 
14886
 
 
14887
 
 
14888
SWIGINTERN PyObject *_wrap_TextCtrl_IsSingleLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14889
  PyObject *resultobj = 0;
 
14890
  wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
 
14891
  bool result;
 
14892
  void *argp1 = 0 ;
 
14893
  int res1 = 0 ;
 
14894
  PyObject *swig_obj[1] ;
 
14895
  
 
14896
  if (!args) SWIG_fail;
 
14897
  swig_obj[0] = args;
 
14898
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextCtrl, 0 |  0 );
 
14899
  if (!SWIG_IsOK(res1)) {
 
14900
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextCtrl_IsSingleLine" "', expected argument " "1"" of type '" "wxTextCtrl const *""'"); 
 
14901
  }
 
14902
  arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
 
14903
  {
 
14904
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14905
    result = (bool)((wxTextCtrl const *)arg1)->IsSingleLine();
 
14906
    wxPyEndAllowThreads(__tstate);
 
14907
    if (PyErr_Occurred()) SWIG_fail;
 
14908
  }
 
14909
  {
 
14910
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14911
  }
 
14912
  return resultobj;
 
14913
fail:
 
14914
  return NULL;
 
14915
}
 
14916
 
 
14917
 
 
14918
SWIGINTERN PyObject *_wrap_TextCtrl_IsMultiLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
14919
  PyObject *resultobj = 0;
 
14920
  wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
 
14921
  bool result;
 
14922
  void *argp1 = 0 ;
 
14923
  int res1 = 0 ;
 
14924
  PyObject *swig_obj[1] ;
 
14925
  
 
14926
  if (!args) SWIG_fail;
 
14927
  swig_obj[0] = args;
 
14928
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextCtrl, 0 |  0 );
 
14929
  if (!SWIG_IsOK(res1)) {
 
14930
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextCtrl_IsMultiLine" "', expected argument " "1"" of type '" "wxTextCtrl const *""'"); 
 
14931
  }
 
14932
  arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
 
14933
  {
 
14934
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14935
    result = (bool)((wxTextCtrl const *)arg1)->IsMultiLine();
 
14936
    wxPyEndAllowThreads(__tstate);
 
14937
    if (PyErr_Occurred()) SWIG_fail;
 
14938
  }
 
14939
  {
 
14940
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14941
  }
 
14942
  return resultobj;
 
14943
fail:
 
14944
  return NULL;
 
14945
}
 
14946
 
 
14947
 
 
14948
SWIGINTERN PyObject *_wrap_TextCtrl_EmulateKeyPress(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14949
  PyObject *resultobj = 0;
 
14950
  wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
 
14951
  wxKeyEvent *arg2 = 0 ;
 
14952
  bool result;
 
14953
  void *argp1 = 0 ;
 
14954
  int res1 = 0 ;
 
14955
  void *argp2 = 0 ;
 
14956
  int res2 = 0 ;
 
14957
  PyObject * obj0 = 0 ;
 
14958
  PyObject * obj1 = 0 ;
 
14959
  char *  kwnames[] = {
 
14960
    (char *) "self",(char *) "event", NULL 
 
14961
  };
 
14962
  
 
14963
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_EmulateKeyPress",kwnames,&obj0,&obj1)) SWIG_fail;
 
14964
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 |  0 );
 
14965
  if (!SWIG_IsOK(res1)) {
 
14966
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextCtrl_EmulateKeyPress" "', expected argument " "1"" of type '" "wxTextCtrl *""'"); 
 
14967
  }
 
14968
  arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
 
14969
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent,  0  | 0);
 
14970
  if (!SWIG_IsOK(res2)) {
 
14971
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextCtrl_EmulateKeyPress" "', expected argument " "2"" of type '" "wxKeyEvent const &""'"); 
 
14972
  }
 
14973
  if (!argp2) {
 
14974
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextCtrl_EmulateKeyPress" "', expected argument " "2"" of type '" "wxKeyEvent const &""'"); 
 
14975
  }
 
14976
  arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
 
14977
  {
 
14978
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
14979
    result = (bool)(arg1)->EmulateKeyPress((wxKeyEvent const &)*arg2);
 
14980
    wxPyEndAllowThreads(__tstate);
 
14981
    if (PyErr_Occurred()) SWIG_fail;
 
14982
  }
 
14983
  {
 
14984
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
14985
  }
 
14986
  return resultobj;
 
14987
fail:
 
14988
  return NULL;
 
14989
}
 
14990
 
 
14991
 
 
14992
SWIGINTERN PyObject *_wrap_TextCtrl_MacCheckSpelling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
14993
  PyObject *resultobj = 0;
 
14994
  wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
 
14995
  bool arg2 ;
 
14996
  void *argp1 = 0 ;
 
14997
  int res1 = 0 ;
 
14998
  bool val2 ;
 
14999
  int ecode2 = 0 ;
 
15000
  PyObject * obj0 = 0 ;
 
15001
  PyObject * obj1 = 0 ;
 
15002
  char *  kwnames[] = {
 
15003
    (char *) "self",(char *) "check", NULL 
 
15004
  };
 
15005
  
 
15006
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_MacCheckSpelling",kwnames,&obj0,&obj1)) SWIG_fail;
 
15007
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 |  0 );
 
15008
  if (!SWIG_IsOK(res1)) {
 
15009
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextCtrl_MacCheckSpelling" "', expected argument " "1"" of type '" "wxTextCtrl *""'"); 
 
15010
  }
 
15011
  arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
 
15012
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
15013
  if (!SWIG_IsOK(ecode2)) {
 
15014
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextCtrl_MacCheckSpelling" "', expected argument " "2"" of type '" "bool""'");
 
15015
  } 
 
15016
  arg2 = static_cast< bool >(val2);
 
15017
  {
 
15018
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15019
    wxTextCtrl_MacCheckSpelling(arg1,arg2);
 
15020
    wxPyEndAllowThreads(__tstate);
 
15021
    if (PyErr_Occurred()) SWIG_fail;
 
15022
  }
 
15023
  resultobj = SWIG_Py_Void();
 
15024
  return resultobj;
 
15025
fail:
 
15026
  return NULL;
 
15027
}
 
15028
 
 
15029
 
 
15030
SWIGINTERN PyObject *_wrap_TextCtrl_SendTextUpdatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15031
  PyObject *resultobj = 0;
 
15032
  wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
 
15033
  void *argp1 = 0 ;
 
15034
  int res1 = 0 ;
 
15035
  PyObject *swig_obj[1] ;
 
15036
  
 
15037
  if (!args) SWIG_fail;
 
15038
  swig_obj[0] = args;
 
15039
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextCtrl, 0 |  0 );
 
15040
  if (!SWIG_IsOK(res1)) {
 
15041
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextCtrl_SendTextUpdatedEvent" "', expected argument " "1"" of type '" "wxTextCtrl *""'"); 
 
15042
  }
 
15043
  arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
 
15044
  {
 
15045
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15046
    (arg1)->SendTextUpdatedEvent();
 
15047
    wxPyEndAllowThreads(__tstate);
 
15048
    if (PyErr_Occurred()) SWIG_fail;
 
15049
  }
 
15050
  resultobj = SWIG_Py_Void();
 
15051
  return resultobj;
 
15052
fail:
 
15053
  return NULL;
 
15054
}
 
15055
 
 
15056
 
 
15057
SWIGINTERN PyObject *_wrap_TextCtrl_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
15058
  PyObject *resultobj = 0;
 
15059
  wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
 
15060
  wxString *arg2 = 0 ;
 
15061
  void *argp1 = 0 ;
 
15062
  int res1 = 0 ;
 
15063
  bool temp2 = false ;
 
15064
  PyObject * obj0 = 0 ;
 
15065
  PyObject * obj1 = 0 ;
 
15066
  char *  kwnames[] = {
 
15067
    (char *) "self",(char *) "text", NULL 
 
15068
  };
 
15069
  
 
15070
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextCtrl_write",kwnames,&obj0,&obj1)) SWIG_fail;
 
15071
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 |  0 );
 
15072
  if (!SWIG_IsOK(res1)) {
 
15073
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextCtrl_write" "', expected argument " "1"" of type '" "wxTextCtrl *""'"); 
 
15074
  }
 
15075
  arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
 
15076
  {
 
15077
    arg2 = wxString_in_helper(obj1);
 
15078
    if (arg2 == NULL) SWIG_fail;
 
15079
    temp2 = true;
 
15080
  }
 
15081
  {
 
15082
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15083
    wxTextCtrl_write(arg1,(wxString const &)*arg2);
 
15084
    wxPyEndAllowThreads(__tstate);
 
15085
    if (PyErr_Occurred()) SWIG_fail;
 
15086
  }
 
15087
  resultobj = SWIG_Py_Void();
 
15088
  {
 
15089
    if (temp2)
 
15090
    delete arg2;
 
15091
  }
 
15092
  return resultobj;
 
15093
fail:
 
15094
  {
 
15095
    if (temp2)
 
15096
    delete arg2;
 
15097
  }
 
15098
  return NULL;
 
15099
}
 
15100
 
 
15101
 
 
15102
SWIGINTERN PyObject *_wrap_TextCtrl_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
15103
  PyObject *resultobj = 0;
 
15104
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
15105
  SwigValueWrapper<wxVisualAttributes > result;
 
15106
  int val1 ;
 
15107
  int ecode1 = 0 ;
 
15108
  PyObject * obj0 = 0 ;
 
15109
  char *  kwnames[] = {
 
15110
    (char *) "variant", NULL 
 
15111
  };
 
15112
  
 
15113
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:TextCtrl_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
15114
  if (obj0) {
 
15115
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
15116
    if (!SWIG_IsOK(ecode1)) {
 
15117
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TextCtrl_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
15118
    } 
 
15119
    arg1 = static_cast< wxWindowVariant >(val1);
 
15120
  }
 
15121
  {
 
15122
    if (!wxPyCheckForApp()) SWIG_fail;
 
15123
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15124
    result = wxTextCtrl::GetClassDefaultAttributes(arg1);
 
15125
    wxPyEndAllowThreads(__tstate);
 
15126
    if (PyErr_Occurred()) SWIG_fail;
 
15127
  }
 
15128
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
15129
  return resultobj;
 
15130
fail:
 
15131
  return NULL;
 
15132
}
 
15133
 
 
15134
 
 
15135
SWIGINTERN PyObject *TextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15136
  PyObject *obj;
 
15137
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
15138
  SWIG_TypeNewClientData(SWIGTYPE_p_wxTextCtrl, SWIG_NewClientData(obj));
 
15139
  return SWIG_Py_Void();
 
15140
}
 
15141
 
 
15142
SWIGINTERN PyObject *TextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15143
  return SWIG_Python_InitShadowInstance(args);
 
15144
}
 
15145
 
 
15146
SWIGINTERN PyObject *_wrap_new_TextUrlEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
15147
  PyObject *resultobj = 0;
 
15148
  int arg1 ;
 
15149
  wxMouseEvent *arg2 = 0 ;
 
15150
  long arg3 ;
 
15151
  long arg4 ;
 
15152
  wxTextUrlEvent *result = 0 ;
 
15153
  int val1 ;
 
15154
  int ecode1 = 0 ;
 
15155
  void *argp2 = 0 ;
 
15156
  int res2 = 0 ;
 
15157
  long val3 ;
 
15158
  int ecode3 = 0 ;
 
15159
  long val4 ;
 
15160
  int ecode4 = 0 ;
 
15161
  PyObject * obj0 = 0 ;
 
15162
  PyObject * obj1 = 0 ;
 
15163
  PyObject * obj2 = 0 ;
 
15164
  PyObject * obj3 = 0 ;
 
15165
  char *  kwnames[] = {
 
15166
    (char *) "winid",(char *) "evtMouse",(char *) "start",(char *) "end", NULL 
 
15167
  };
 
15168
  
 
15169
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_TextUrlEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
15170
  ecode1 = SWIG_AsVal_int(obj0, &val1);
 
15171
  if (!SWIG_IsOK(ecode1)) {
 
15172
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TextUrlEvent" "', expected argument " "1"" of type '" "int""'");
 
15173
  } 
 
15174
  arg1 = static_cast< int >(val1);
 
15175
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMouseEvent,  0  | 0);
 
15176
  if (!SWIG_IsOK(res2)) {
 
15177
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TextUrlEvent" "', expected argument " "2"" of type '" "wxMouseEvent const &""'"); 
 
15178
  }
 
15179
  if (!argp2) {
 
15180
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TextUrlEvent" "', expected argument " "2"" of type '" "wxMouseEvent const &""'"); 
 
15181
  }
 
15182
  arg2 = reinterpret_cast< wxMouseEvent * >(argp2);
 
15183
  ecode3 = SWIG_AsVal_long(obj2, &val3);
 
15184
  if (!SWIG_IsOK(ecode3)) {
 
15185
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TextUrlEvent" "', expected argument " "3"" of type '" "long""'");
 
15186
  } 
 
15187
  arg3 = static_cast< long >(val3);
 
15188
  ecode4 = SWIG_AsVal_long(obj3, &val4);
 
15189
  if (!SWIG_IsOK(ecode4)) {
 
15190
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TextUrlEvent" "', expected argument " "4"" of type '" "long""'");
 
15191
  } 
 
15192
  arg4 = static_cast< long >(val4);
 
15193
  {
 
15194
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15195
    result = (wxTextUrlEvent *)new wxTextUrlEvent(arg1,(wxMouseEvent const &)*arg2,arg3,arg4);
 
15196
    wxPyEndAllowThreads(__tstate);
 
15197
    if (PyErr_Occurred()) SWIG_fail;
 
15198
  }
 
15199
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextUrlEvent, SWIG_POINTER_NEW |  0 );
 
15200
  return resultobj;
 
15201
fail:
 
15202
  return NULL;
 
15203
}
 
15204
 
 
15205
 
 
15206
SWIGINTERN PyObject *_wrap_TextUrlEvent_GetMouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15207
  PyObject *resultobj = 0;
 
15208
  wxTextUrlEvent *arg1 = (wxTextUrlEvent *) 0 ;
 
15209
  wxMouseEvent *result = 0 ;
 
15210
  void *argp1 = 0 ;
 
15211
  int res1 = 0 ;
 
15212
  PyObject *swig_obj[1] ;
 
15213
  
 
15214
  if (!args) SWIG_fail;
 
15215
  swig_obj[0] = args;
 
15216
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextUrlEvent, 0 |  0 );
 
15217
  if (!SWIG_IsOK(res1)) {
 
15218
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextUrlEvent_GetMouseEvent" "', expected argument " "1"" of type '" "wxTextUrlEvent *""'"); 
 
15219
  }
 
15220
  arg1 = reinterpret_cast< wxTextUrlEvent * >(argp1);
 
15221
  {
 
15222
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15223
    {
 
15224
      wxMouseEvent const &_result_ref = (arg1)->GetMouseEvent();
 
15225
      result = (wxMouseEvent *) &_result_ref;
 
15226
    }
 
15227
    wxPyEndAllowThreads(__tstate);
 
15228
    if (PyErr_Occurred()) SWIG_fail;
 
15229
  }
 
15230
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, 0 |  0 );
 
15231
  return resultobj;
 
15232
fail:
 
15233
  return NULL;
 
15234
}
 
15235
 
 
15236
 
 
15237
SWIGINTERN PyObject *_wrap_TextUrlEvent_GetURLStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15238
  PyObject *resultobj = 0;
 
15239
  wxTextUrlEvent *arg1 = (wxTextUrlEvent *) 0 ;
 
15240
  long result;
 
15241
  void *argp1 = 0 ;
 
15242
  int res1 = 0 ;
 
15243
  PyObject *swig_obj[1] ;
 
15244
  
 
15245
  if (!args) SWIG_fail;
 
15246
  swig_obj[0] = args;
 
15247
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextUrlEvent, 0 |  0 );
 
15248
  if (!SWIG_IsOK(res1)) {
 
15249
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextUrlEvent_GetURLStart" "', expected argument " "1"" of type '" "wxTextUrlEvent const *""'"); 
 
15250
  }
 
15251
  arg1 = reinterpret_cast< wxTextUrlEvent * >(argp1);
 
15252
  {
 
15253
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15254
    result = (long)((wxTextUrlEvent const *)arg1)->GetURLStart();
 
15255
    wxPyEndAllowThreads(__tstate);
 
15256
    if (PyErr_Occurred()) SWIG_fail;
 
15257
  }
 
15258
  resultobj = SWIG_From_long(static_cast< long >(result));
 
15259
  return resultobj;
 
15260
fail:
 
15261
  return NULL;
 
15262
}
 
15263
 
 
15264
 
 
15265
SWIGINTERN PyObject *_wrap_TextUrlEvent_GetURLEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15266
  PyObject *resultobj = 0;
 
15267
  wxTextUrlEvent *arg1 = (wxTextUrlEvent *) 0 ;
 
15268
  long result;
 
15269
  void *argp1 = 0 ;
 
15270
  int res1 = 0 ;
 
15271
  PyObject *swig_obj[1] ;
 
15272
  
 
15273
  if (!args) SWIG_fail;
 
15274
  swig_obj[0] = args;
 
15275
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextUrlEvent, 0 |  0 );
 
15276
  if (!SWIG_IsOK(res1)) {
 
15277
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextUrlEvent_GetURLEnd" "', expected argument " "1"" of type '" "wxTextUrlEvent const *""'"); 
 
15278
  }
 
15279
  arg1 = reinterpret_cast< wxTextUrlEvent * >(argp1);
 
15280
  {
 
15281
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15282
    result = (long)((wxTextUrlEvent const *)arg1)->GetURLEnd();
 
15283
    wxPyEndAllowThreads(__tstate);
 
15284
    if (PyErr_Occurred()) SWIG_fail;
 
15285
  }
 
15286
  resultobj = SWIG_From_long(static_cast< long >(result));
 
15287
  return resultobj;
 
15288
fail:
 
15289
  return NULL;
 
15290
}
 
15291
 
 
15292
 
 
15293
SWIGINTERN PyObject *TextUrlEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15294
  PyObject *obj;
 
15295
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
15296
  SWIG_TypeNewClientData(SWIGTYPE_p_wxTextUrlEvent, SWIG_NewClientData(obj));
 
15297
  return SWIG_Py_Void();
 
15298
}
 
15299
 
 
15300
SWIGINTERN PyObject *TextUrlEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15301
  return SWIG_Python_InitShadowInstance(args);
 
15302
}
 
15303
 
 
15304
SWIGINTERN int ScrollBarNameStr_set(PyObject *) {
 
15305
  SWIG_Error(SWIG_AttributeError,"Variable ScrollBarNameStr is read-only.");
 
15306
  return 1;
 
15307
}
 
15308
 
 
15309
 
 
15310
SWIGINTERN PyObject *ScrollBarNameStr_get(void) {
 
15311
  PyObject *pyobj = 0;
 
15312
  
 
15313
  {
 
15314
#if wxUSE_UNICODE
 
15315
    pyobj = PyUnicode_FromWideChar((&wxPyScrollBarNameStr)->c_str(), (&wxPyScrollBarNameStr)->Len());
 
15316
#else
 
15317
    pyobj = PyString_FromStringAndSize((&wxPyScrollBarNameStr)->c_str(), (&wxPyScrollBarNameStr)->Len());
 
15318
#endif
 
15319
  }
 
15320
  return pyobj;
 
15321
}
 
15322
 
 
15323
 
 
15324
SWIGINTERN PyObject *_wrap_new_ScrollBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
15325
  PyObject *resultobj = 0;
 
15326
  wxWindow *arg1 = (wxWindow *) 0 ;
 
15327
  int arg2 = (int) -1 ;
 
15328
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
15329
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
15330
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
15331
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
15332
  long arg5 = (long) wxSB_HORIZONTAL ;
 
15333
  wxValidator const &arg6_defvalue = wxDefaultValidator ;
 
15334
  wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
 
15335
  wxString const &arg7_defvalue = wxPyScrollBarNameStr ;
 
15336
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
15337
  wxScrollBar *result = 0 ;
 
15338
  void *argp1 = 0 ;
 
15339
  int res1 = 0 ;
 
15340
  int val2 ;
 
15341
  int ecode2 = 0 ;
 
15342
  wxPoint temp3 ;
 
15343
  wxSize temp4 ;
 
15344
  long val5 ;
 
15345
  int ecode5 = 0 ;
 
15346
  void *argp6 = 0 ;
 
15347
  int res6 = 0 ;
 
15348
  bool temp7 = false ;
 
15349
  PyObject * obj0 = 0 ;
 
15350
  PyObject * obj1 = 0 ;
 
15351
  PyObject * obj2 = 0 ;
 
15352
  PyObject * obj3 = 0 ;
 
15353
  PyObject * obj4 = 0 ;
 
15354
  PyObject * obj5 = 0 ;
 
15355
  PyObject * obj6 = 0 ;
 
15356
  char *  kwnames[] = {
 
15357
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
15358
  };
 
15359
  
 
15360
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_ScrollBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
15361
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
15362
  if (!SWIG_IsOK(res1)) {
 
15363
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScrollBar" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
15364
  }
 
15365
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
15366
  if (obj1) {
 
15367
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
15368
    if (!SWIG_IsOK(ecode2)) {
 
15369
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollBar" "', expected argument " "2"" of type '" "int""'");
 
15370
    } 
 
15371
    arg2 = static_cast< int >(val2);
 
15372
  }
 
15373
  if (obj2) {
 
15374
    {
 
15375
      arg3 = &temp3;
 
15376
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
15377
    }
 
15378
  }
 
15379
  if (obj3) {
 
15380
    {
 
15381
      arg4 = &temp4;
 
15382
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
15383
    }
 
15384
  }
 
15385
  if (obj4) {
 
15386
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
15387
    if (!SWIG_IsOK(ecode5)) {
 
15388
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ScrollBar" "', expected argument " "5"" of type '" "long""'");
 
15389
    } 
 
15390
    arg5 = static_cast< long >(val5);
 
15391
  }
 
15392
  if (obj5) {
 
15393
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator,  0  | 0);
 
15394
    if (!SWIG_IsOK(res6)) {
 
15395
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ScrollBar" "', expected argument " "6"" of type '" "wxValidator const &""'"); 
 
15396
    }
 
15397
    if (!argp6) {
 
15398
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScrollBar" "', expected argument " "6"" of type '" "wxValidator const &""'"); 
 
15399
    }
 
15400
    arg6 = reinterpret_cast< wxValidator * >(argp6);
 
15401
  }
 
15402
  if (obj6) {
 
15403
    {
 
15404
      arg7 = wxString_in_helper(obj6);
 
15405
      if (arg7 == NULL) SWIG_fail;
 
15406
      temp7 = true;
 
15407
    }
 
15408
  }
 
15409
  {
 
15410
    if (!wxPyCheckForApp()) SWIG_fail;
 
15411
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15412
    result = (wxScrollBar *)new wxScrollBar(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
 
15413
    wxPyEndAllowThreads(__tstate);
 
15414
    if (PyErr_Occurred()) SWIG_fail;
 
15415
  }
 
15416
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollBar, SWIG_POINTER_NEW |  0 );
 
15417
  {
 
15418
    if (temp7)
 
15419
    delete arg7;
 
15420
  }
 
15421
  return resultobj;
 
15422
fail:
 
15423
  {
 
15424
    if (temp7)
 
15425
    delete arg7;
 
15426
  }
 
15427
  return NULL;
 
15428
}
 
15429
 
 
15430
 
 
15431
SWIGINTERN PyObject *_wrap_new_PreScrollBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15432
  PyObject *resultobj = 0;
 
15433
  wxScrollBar *result = 0 ;
 
15434
  
 
15435
  if (!SWIG_Python_UnpackTuple(args,"new_PreScrollBar",0,0,0)) SWIG_fail;
 
15436
  {
 
15437
    if (!wxPyCheckForApp()) SWIG_fail;
 
15438
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15439
    result = (wxScrollBar *)new wxScrollBar();
 
15440
    wxPyEndAllowThreads(__tstate);
 
15441
    if (PyErr_Occurred()) SWIG_fail;
 
15442
  }
 
15443
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollBar, SWIG_POINTER_OWN |  0 );
 
15444
  return resultobj;
 
15445
fail:
 
15446
  return NULL;
 
15447
}
 
15448
 
 
15449
 
 
15450
SWIGINTERN PyObject *_wrap_ScrollBar_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
15451
  PyObject *resultobj = 0;
 
15452
  wxScrollBar *arg1 = (wxScrollBar *) 0 ;
 
15453
  wxWindow *arg2 = (wxWindow *) 0 ;
 
15454
  int arg3 = (int) -1 ;
 
15455
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
15456
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
15457
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
15458
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
15459
  long arg6 = (long) wxSB_HORIZONTAL ;
 
15460
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
15461
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
15462
  wxString const &arg8_defvalue = wxPyScrollBarNameStr ;
 
15463
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
15464
  bool result;
 
15465
  void *argp1 = 0 ;
 
15466
  int res1 = 0 ;
 
15467
  void *argp2 = 0 ;
 
15468
  int res2 = 0 ;
 
15469
  int val3 ;
 
15470
  int ecode3 = 0 ;
 
15471
  wxPoint temp4 ;
 
15472
  wxSize temp5 ;
 
15473
  long val6 ;
 
15474
  int ecode6 = 0 ;
 
15475
  void *argp7 = 0 ;
 
15476
  int res7 = 0 ;
 
15477
  bool temp8 = false ;
 
15478
  PyObject * obj0 = 0 ;
 
15479
  PyObject * obj1 = 0 ;
 
15480
  PyObject * obj2 = 0 ;
 
15481
  PyObject * obj3 = 0 ;
 
15482
  PyObject * obj4 = 0 ;
 
15483
  PyObject * obj5 = 0 ;
 
15484
  PyObject * obj6 = 0 ;
 
15485
  PyObject * obj7 = 0 ;
 
15486
  char *  kwnames[] = {
 
15487
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
15488
  };
 
15489
  
 
15490
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:ScrollBar_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
15491
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollBar, 0 |  0 );
 
15492
  if (!SWIG_IsOK(res1)) {
 
15493
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollBar_Create" "', expected argument " "1"" of type '" "wxScrollBar *""'"); 
 
15494
  }
 
15495
  arg1 = reinterpret_cast< wxScrollBar * >(argp1);
 
15496
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
15497
  if (!SWIG_IsOK(res2)) {
 
15498
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScrollBar_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
15499
  }
 
15500
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
15501
  if (obj2) {
 
15502
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
15503
    if (!SWIG_IsOK(ecode3)) {
 
15504
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ScrollBar_Create" "', expected argument " "3"" of type '" "int""'");
 
15505
    } 
 
15506
    arg3 = static_cast< int >(val3);
 
15507
  }
 
15508
  if (obj3) {
 
15509
    {
 
15510
      arg4 = &temp4;
 
15511
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
15512
    }
 
15513
  }
 
15514
  if (obj4) {
 
15515
    {
 
15516
      arg5 = &temp5;
 
15517
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
15518
    }
 
15519
  }
 
15520
  if (obj5) {
 
15521
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
15522
    if (!SWIG_IsOK(ecode6)) {
 
15523
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ScrollBar_Create" "', expected argument " "6"" of type '" "long""'");
 
15524
    } 
 
15525
    arg6 = static_cast< long >(val6);
 
15526
  }
 
15527
  if (obj6) {
 
15528
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
15529
    if (!SWIG_IsOK(res7)) {
 
15530
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ScrollBar_Create" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
15531
    }
 
15532
    if (!argp7) {
 
15533
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScrollBar_Create" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
15534
    }
 
15535
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
15536
  }
 
15537
  if (obj7) {
 
15538
    {
 
15539
      arg8 = wxString_in_helper(obj7);
 
15540
      if (arg8 == NULL) SWIG_fail;
 
15541
      temp8 = true;
 
15542
    }
 
15543
  }
 
15544
  {
 
15545
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15546
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
15547
    wxPyEndAllowThreads(__tstate);
 
15548
    if (PyErr_Occurred()) SWIG_fail;
 
15549
  }
 
15550
  {
 
15551
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
15552
  }
 
15553
  {
 
15554
    if (temp8)
 
15555
    delete arg8;
 
15556
  }
 
15557
  return resultobj;
 
15558
fail:
 
15559
  {
 
15560
    if (temp8)
 
15561
    delete arg8;
 
15562
  }
 
15563
  return NULL;
 
15564
}
 
15565
 
 
15566
 
 
15567
SWIGINTERN PyObject *_wrap_ScrollBar_GetThumbPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15568
  PyObject *resultobj = 0;
 
15569
  wxScrollBar *arg1 = (wxScrollBar *) 0 ;
 
15570
  int result;
 
15571
  void *argp1 = 0 ;
 
15572
  int res1 = 0 ;
 
15573
  PyObject *swig_obj[1] ;
 
15574
  
 
15575
  if (!args) SWIG_fail;
 
15576
  swig_obj[0] = args;
 
15577
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollBar, 0 |  0 );
 
15578
  if (!SWIG_IsOK(res1)) {
 
15579
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollBar_GetThumbPosition" "', expected argument " "1"" of type '" "wxScrollBar const *""'"); 
 
15580
  }
 
15581
  arg1 = reinterpret_cast< wxScrollBar * >(argp1);
 
15582
  {
 
15583
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15584
    result = (int)((wxScrollBar const *)arg1)->GetThumbPosition();
 
15585
    wxPyEndAllowThreads(__tstate);
 
15586
    if (PyErr_Occurred()) SWIG_fail;
 
15587
  }
 
15588
  resultobj = SWIG_From_int(static_cast< int >(result));
 
15589
  return resultobj;
 
15590
fail:
 
15591
  return NULL;
 
15592
}
 
15593
 
 
15594
 
 
15595
SWIGINTERN PyObject *_wrap_ScrollBar_GetThumbSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15596
  PyObject *resultobj = 0;
 
15597
  wxScrollBar *arg1 = (wxScrollBar *) 0 ;
 
15598
  int result;
 
15599
  void *argp1 = 0 ;
 
15600
  int res1 = 0 ;
 
15601
  PyObject *swig_obj[1] ;
 
15602
  
 
15603
  if (!args) SWIG_fail;
 
15604
  swig_obj[0] = args;
 
15605
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollBar, 0 |  0 );
 
15606
  if (!SWIG_IsOK(res1)) {
 
15607
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollBar_GetThumbSize" "', expected argument " "1"" of type '" "wxScrollBar const *""'"); 
 
15608
  }
 
15609
  arg1 = reinterpret_cast< wxScrollBar * >(argp1);
 
15610
  {
 
15611
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15612
    result = (int)((wxScrollBar const *)arg1)->GetThumbSize();
 
15613
    wxPyEndAllowThreads(__tstate);
 
15614
    if (PyErr_Occurred()) SWIG_fail;
 
15615
  }
 
15616
  resultobj = SWIG_From_int(static_cast< int >(result));
 
15617
  return resultobj;
 
15618
fail:
 
15619
  return NULL;
 
15620
}
 
15621
 
 
15622
 
 
15623
SWIGINTERN PyObject *_wrap_ScrollBar_GetPageSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15624
  PyObject *resultobj = 0;
 
15625
  wxScrollBar *arg1 = (wxScrollBar *) 0 ;
 
15626
  int result;
 
15627
  void *argp1 = 0 ;
 
15628
  int res1 = 0 ;
 
15629
  PyObject *swig_obj[1] ;
 
15630
  
 
15631
  if (!args) SWIG_fail;
 
15632
  swig_obj[0] = args;
 
15633
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollBar, 0 |  0 );
 
15634
  if (!SWIG_IsOK(res1)) {
 
15635
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollBar_GetPageSize" "', expected argument " "1"" of type '" "wxScrollBar const *""'"); 
 
15636
  }
 
15637
  arg1 = reinterpret_cast< wxScrollBar * >(argp1);
 
15638
  {
 
15639
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15640
    result = (int)((wxScrollBar const *)arg1)->GetPageSize();
 
15641
    wxPyEndAllowThreads(__tstate);
 
15642
    if (PyErr_Occurred()) SWIG_fail;
 
15643
  }
 
15644
  resultobj = SWIG_From_int(static_cast< int >(result));
 
15645
  return resultobj;
 
15646
fail:
 
15647
  return NULL;
 
15648
}
 
15649
 
 
15650
 
 
15651
SWIGINTERN PyObject *_wrap_ScrollBar_GetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15652
  PyObject *resultobj = 0;
 
15653
  wxScrollBar *arg1 = (wxScrollBar *) 0 ;
 
15654
  int result;
 
15655
  void *argp1 = 0 ;
 
15656
  int res1 = 0 ;
 
15657
  PyObject *swig_obj[1] ;
 
15658
  
 
15659
  if (!args) SWIG_fail;
 
15660
  swig_obj[0] = args;
 
15661
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollBar, 0 |  0 );
 
15662
  if (!SWIG_IsOK(res1)) {
 
15663
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollBar_GetRange" "', expected argument " "1"" of type '" "wxScrollBar const *""'"); 
 
15664
  }
 
15665
  arg1 = reinterpret_cast< wxScrollBar * >(argp1);
 
15666
  {
 
15667
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15668
    result = (int)((wxScrollBar const *)arg1)->GetRange();
 
15669
    wxPyEndAllowThreads(__tstate);
 
15670
    if (PyErr_Occurred()) SWIG_fail;
 
15671
  }
 
15672
  resultobj = SWIG_From_int(static_cast< int >(result));
 
15673
  return resultobj;
 
15674
fail:
 
15675
  return NULL;
 
15676
}
 
15677
 
 
15678
 
 
15679
SWIGINTERN PyObject *_wrap_ScrollBar_IsVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15680
  PyObject *resultobj = 0;
 
15681
  wxScrollBar *arg1 = (wxScrollBar *) 0 ;
 
15682
  bool result;
 
15683
  void *argp1 = 0 ;
 
15684
  int res1 = 0 ;
 
15685
  PyObject *swig_obj[1] ;
 
15686
  
 
15687
  if (!args) SWIG_fail;
 
15688
  swig_obj[0] = args;
 
15689
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollBar, 0 |  0 );
 
15690
  if (!SWIG_IsOK(res1)) {
 
15691
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollBar_IsVertical" "', expected argument " "1"" of type '" "wxScrollBar const *""'"); 
 
15692
  }
 
15693
  arg1 = reinterpret_cast< wxScrollBar * >(argp1);
 
15694
  {
 
15695
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15696
    result = (bool)((wxScrollBar const *)arg1)->IsVertical();
 
15697
    wxPyEndAllowThreads(__tstate);
 
15698
    if (PyErr_Occurred()) SWIG_fail;
 
15699
  }
 
15700
  {
 
15701
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
15702
  }
 
15703
  return resultobj;
 
15704
fail:
 
15705
  return NULL;
 
15706
}
 
15707
 
 
15708
 
 
15709
SWIGINTERN PyObject *_wrap_ScrollBar_SetThumbPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
15710
  PyObject *resultobj = 0;
 
15711
  wxScrollBar *arg1 = (wxScrollBar *) 0 ;
 
15712
  int arg2 ;
 
15713
  void *argp1 = 0 ;
 
15714
  int res1 = 0 ;
 
15715
  int val2 ;
 
15716
  int ecode2 = 0 ;
 
15717
  PyObject * obj0 = 0 ;
 
15718
  PyObject * obj1 = 0 ;
 
15719
  char *  kwnames[] = {
 
15720
    (char *) "self",(char *) "viewStart", NULL 
 
15721
  };
 
15722
  
 
15723
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollBar_SetThumbPosition",kwnames,&obj0,&obj1)) SWIG_fail;
 
15724
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollBar, 0 |  0 );
 
15725
  if (!SWIG_IsOK(res1)) {
 
15726
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollBar_SetThumbPosition" "', expected argument " "1"" of type '" "wxScrollBar *""'"); 
 
15727
  }
 
15728
  arg1 = reinterpret_cast< wxScrollBar * >(argp1);
 
15729
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
15730
  if (!SWIG_IsOK(ecode2)) {
 
15731
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollBar_SetThumbPosition" "', expected argument " "2"" of type '" "int""'");
 
15732
  } 
 
15733
  arg2 = static_cast< int >(val2);
 
15734
  {
 
15735
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15736
    (arg1)->SetThumbPosition(arg2);
 
15737
    wxPyEndAllowThreads(__tstate);
 
15738
    if (PyErr_Occurred()) SWIG_fail;
 
15739
  }
 
15740
  resultobj = SWIG_Py_Void();
 
15741
  return resultobj;
 
15742
fail:
 
15743
  return NULL;
 
15744
}
 
15745
 
 
15746
 
 
15747
SWIGINTERN PyObject *_wrap_ScrollBar_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
15748
  PyObject *resultobj = 0;
 
15749
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
15750
  SwigValueWrapper<wxVisualAttributes > result;
 
15751
  int val1 ;
 
15752
  int ecode1 = 0 ;
 
15753
  PyObject * obj0 = 0 ;
 
15754
  char *  kwnames[] = {
 
15755
    (char *) "variant", NULL 
 
15756
  };
 
15757
  
 
15758
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ScrollBar_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
15759
  if (obj0) {
 
15760
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
15761
    if (!SWIG_IsOK(ecode1)) {
 
15762
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ScrollBar_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
15763
    } 
 
15764
    arg1 = static_cast< wxWindowVariant >(val1);
 
15765
  }
 
15766
  {
 
15767
    if (!wxPyCheckForApp()) SWIG_fail;
 
15768
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15769
    result = wxScrollBar::GetClassDefaultAttributes(arg1);
 
15770
    wxPyEndAllowThreads(__tstate);
 
15771
    if (PyErr_Occurred()) SWIG_fail;
 
15772
  }
 
15773
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
15774
  return resultobj;
 
15775
fail:
 
15776
  return NULL;
 
15777
}
 
15778
 
 
15779
 
 
15780
SWIGINTERN PyObject *ScrollBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15781
  PyObject *obj;
 
15782
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
15783
  SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollBar, SWIG_NewClientData(obj));
 
15784
  return SWIG_Py_Void();
 
15785
}
 
15786
 
 
15787
SWIGINTERN PyObject *ScrollBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15788
  return SWIG_Python_InitShadowInstance(args);
 
15789
}
 
15790
 
 
15791
SWIGINTERN int SPIN_BUTTON_NAME_set(PyObject *) {
 
15792
  SWIG_Error(SWIG_AttributeError,"Variable SPIN_BUTTON_NAME is read-only.");
 
15793
  return 1;
 
15794
}
 
15795
 
 
15796
 
 
15797
SWIGINTERN PyObject *SPIN_BUTTON_NAME_get(void) {
 
15798
  PyObject *pyobj = 0;
 
15799
  
 
15800
  {
 
15801
#if wxUSE_UNICODE
 
15802
    pyobj = PyUnicode_FromWideChar((&wxPySPIN_BUTTON_NAME)->c_str(), (&wxPySPIN_BUTTON_NAME)->Len());
 
15803
#else
 
15804
    pyobj = PyString_FromStringAndSize((&wxPySPIN_BUTTON_NAME)->c_str(), (&wxPySPIN_BUTTON_NAME)->Len());
 
15805
#endif
 
15806
  }
 
15807
  return pyobj;
 
15808
}
 
15809
 
 
15810
 
 
15811
SWIGINTERN int SpinCtrlNameStr_set(PyObject *) {
 
15812
  SWIG_Error(SWIG_AttributeError,"Variable SpinCtrlNameStr is read-only.");
 
15813
  return 1;
 
15814
}
 
15815
 
 
15816
 
 
15817
SWIGINTERN PyObject *SpinCtrlNameStr_get(void) {
 
15818
  PyObject *pyobj = 0;
 
15819
  
 
15820
  {
 
15821
#if wxUSE_UNICODE
 
15822
    pyobj = PyUnicode_FromWideChar((&wxPySpinCtrlNameStr)->c_str(), (&wxPySpinCtrlNameStr)->Len());
 
15823
#else
 
15824
    pyobj = PyString_FromStringAndSize((&wxPySpinCtrlNameStr)->c_str(), (&wxPySpinCtrlNameStr)->Len());
 
15825
#endif
 
15826
  }
 
15827
  return pyobj;
 
15828
}
 
15829
 
 
15830
 
 
15831
SWIGINTERN PyObject *_wrap_new_SpinButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
15832
  PyObject *resultobj = 0;
 
15833
  wxWindow *arg1 = (wxWindow *) 0 ;
 
15834
  int arg2 = (int) -1 ;
 
15835
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
15836
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
15837
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
15838
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
15839
  long arg5 = (long) wxSP_HORIZONTAL ;
 
15840
  wxString const &arg6_defvalue = wxPySPIN_BUTTON_NAME ;
 
15841
  wxString *arg6 = (wxString *) &arg6_defvalue ;
 
15842
  wxSpinButton *result = 0 ;
 
15843
  void *argp1 = 0 ;
 
15844
  int res1 = 0 ;
 
15845
  int val2 ;
 
15846
  int ecode2 = 0 ;
 
15847
  wxPoint temp3 ;
 
15848
  wxSize temp4 ;
 
15849
  long val5 ;
 
15850
  int ecode5 = 0 ;
 
15851
  bool temp6 = false ;
 
15852
  PyObject * obj0 = 0 ;
 
15853
  PyObject * obj1 = 0 ;
 
15854
  PyObject * obj2 = 0 ;
 
15855
  PyObject * obj3 = 0 ;
 
15856
  PyObject * obj4 = 0 ;
 
15857
  PyObject * obj5 = 0 ;
 
15858
  char *  kwnames[] = {
 
15859
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
15860
  };
 
15861
  
 
15862
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_SpinButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
15863
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
15864
  if (!SWIG_IsOK(res1)) {
 
15865
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpinButton" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
15866
  }
 
15867
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
15868
  if (obj1) {
 
15869
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
15870
    if (!SWIG_IsOK(ecode2)) {
 
15871
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpinButton" "', expected argument " "2"" of type '" "int""'");
 
15872
    } 
 
15873
    arg2 = static_cast< int >(val2);
 
15874
  }
 
15875
  if (obj2) {
 
15876
    {
 
15877
      arg3 = &temp3;
 
15878
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
15879
    }
 
15880
  }
 
15881
  if (obj3) {
 
15882
    {
 
15883
      arg4 = &temp4;
 
15884
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
15885
    }
 
15886
  }
 
15887
  if (obj4) {
 
15888
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
15889
    if (!SWIG_IsOK(ecode5)) {
 
15890
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpinButton" "', expected argument " "5"" of type '" "long""'");
 
15891
    } 
 
15892
    arg5 = static_cast< long >(val5);
 
15893
  }
 
15894
  if (obj5) {
 
15895
    {
 
15896
      arg6 = wxString_in_helper(obj5);
 
15897
      if (arg6 == NULL) SWIG_fail;
 
15898
      temp6 = true;
 
15899
    }
 
15900
  }
 
15901
  {
 
15902
    if (!wxPyCheckForApp()) SWIG_fail;
 
15903
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15904
    result = (wxSpinButton *)new wxSpinButton(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
 
15905
    wxPyEndAllowThreads(__tstate);
 
15906
    if (PyErr_Occurred()) SWIG_fail;
 
15907
  }
 
15908
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSpinButton, SWIG_POINTER_NEW |  0 );
 
15909
  {
 
15910
    if (temp6)
 
15911
    delete arg6;
 
15912
  }
 
15913
  return resultobj;
 
15914
fail:
 
15915
  {
 
15916
    if (temp6)
 
15917
    delete arg6;
 
15918
  }
 
15919
  return NULL;
 
15920
}
 
15921
 
 
15922
 
 
15923
SWIGINTERN PyObject *_wrap_new_PreSpinButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
15924
  PyObject *resultobj = 0;
 
15925
  wxSpinButton *result = 0 ;
 
15926
  
 
15927
  if (!SWIG_Python_UnpackTuple(args,"new_PreSpinButton",0,0,0)) SWIG_fail;
 
15928
  {
 
15929
    if (!wxPyCheckForApp()) SWIG_fail;
 
15930
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
15931
    result = (wxSpinButton *)new wxSpinButton();
 
15932
    wxPyEndAllowThreads(__tstate);
 
15933
    if (PyErr_Occurred()) SWIG_fail;
 
15934
  }
 
15935
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSpinButton, SWIG_POINTER_OWN |  0 );
 
15936
  return resultobj;
 
15937
fail:
 
15938
  return NULL;
 
15939
}
 
15940
 
 
15941
 
 
15942
SWIGINTERN PyObject *_wrap_SpinButton_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
15943
  PyObject *resultobj = 0;
 
15944
  wxSpinButton *arg1 = (wxSpinButton *) 0 ;
 
15945
  wxWindow *arg2 = (wxWindow *) 0 ;
 
15946
  int arg3 = (int) -1 ;
 
15947
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
15948
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
15949
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
15950
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
15951
  long arg6 = (long) wxSP_HORIZONTAL ;
 
15952
  wxString const &arg7_defvalue = wxPySPIN_BUTTON_NAME ;
 
15953
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
15954
  bool result;
 
15955
  void *argp1 = 0 ;
 
15956
  int res1 = 0 ;
 
15957
  void *argp2 = 0 ;
 
15958
  int res2 = 0 ;
 
15959
  int val3 ;
 
15960
  int ecode3 = 0 ;
 
15961
  wxPoint temp4 ;
 
15962
  wxSize temp5 ;
 
15963
  long val6 ;
 
15964
  int ecode6 = 0 ;
 
15965
  bool temp7 = false ;
 
15966
  PyObject * obj0 = 0 ;
 
15967
  PyObject * obj1 = 0 ;
 
15968
  PyObject * obj2 = 0 ;
 
15969
  PyObject * obj3 = 0 ;
 
15970
  PyObject * obj4 = 0 ;
 
15971
  PyObject * obj5 = 0 ;
 
15972
  PyObject * obj6 = 0 ;
 
15973
  char *  kwnames[] = {
 
15974
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
15975
  };
 
15976
  
 
15977
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:SpinButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
15978
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinButton, 0 |  0 );
 
15979
  if (!SWIG_IsOK(res1)) {
 
15980
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinButton_Create" "', expected argument " "1"" of type '" "wxSpinButton *""'"); 
 
15981
  }
 
15982
  arg1 = reinterpret_cast< wxSpinButton * >(argp1);
 
15983
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
15984
  if (!SWIG_IsOK(res2)) {
 
15985
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpinButton_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
15986
  }
 
15987
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
15988
  if (obj2) {
 
15989
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
15990
    if (!SWIG_IsOK(ecode3)) {
 
15991
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpinButton_Create" "', expected argument " "3"" of type '" "int""'");
 
15992
    } 
 
15993
    arg3 = static_cast< int >(val3);
 
15994
  }
 
15995
  if (obj3) {
 
15996
    {
 
15997
      arg4 = &temp4;
 
15998
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
15999
    }
 
16000
  }
 
16001
  if (obj4) {
 
16002
    {
 
16003
      arg5 = &temp5;
 
16004
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
16005
    }
 
16006
  }
 
16007
  if (obj5) {
 
16008
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
16009
    if (!SWIG_IsOK(ecode6)) {
 
16010
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpinButton_Create" "', expected argument " "6"" of type '" "long""'");
 
16011
    } 
 
16012
    arg6 = static_cast< long >(val6);
 
16013
  }
 
16014
  if (obj6) {
 
16015
    {
 
16016
      arg7 = wxString_in_helper(obj6);
 
16017
      if (arg7 == NULL) SWIG_fail;
 
16018
      temp7 = true;
 
16019
    }
 
16020
  }
 
16021
  {
 
16022
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16023
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
16024
    wxPyEndAllowThreads(__tstate);
 
16025
    if (PyErr_Occurred()) SWIG_fail;
 
16026
  }
 
16027
  {
 
16028
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
16029
  }
 
16030
  {
 
16031
    if (temp7)
 
16032
    delete arg7;
 
16033
  }
 
16034
  return resultobj;
 
16035
fail:
 
16036
  {
 
16037
    if (temp7)
 
16038
    delete arg7;
 
16039
  }
 
16040
  return NULL;
 
16041
}
 
16042
 
 
16043
 
 
16044
SWIGINTERN PyObject *_wrap_SpinButton_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16045
  PyObject *resultobj = 0;
 
16046
  wxSpinButton *arg1 = (wxSpinButton *) 0 ;
 
16047
  int result;
 
16048
  void *argp1 = 0 ;
 
16049
  int res1 = 0 ;
 
16050
  PyObject *swig_obj[1] ;
 
16051
  
 
16052
  if (!args) SWIG_fail;
 
16053
  swig_obj[0] = args;
 
16054
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinButton, 0 |  0 );
 
16055
  if (!SWIG_IsOK(res1)) {
 
16056
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinButton_GetValue" "', expected argument " "1"" of type '" "wxSpinButton const *""'"); 
 
16057
  }
 
16058
  arg1 = reinterpret_cast< wxSpinButton * >(argp1);
 
16059
  {
 
16060
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16061
    result = (int)((wxSpinButton const *)arg1)->GetValue();
 
16062
    wxPyEndAllowThreads(__tstate);
 
16063
    if (PyErr_Occurred()) SWIG_fail;
 
16064
  }
 
16065
  resultobj = SWIG_From_int(static_cast< int >(result));
 
16066
  return resultobj;
 
16067
fail:
 
16068
  return NULL;
 
16069
}
 
16070
 
 
16071
 
 
16072
SWIGINTERN PyObject *_wrap_SpinButton_GetMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16073
  PyObject *resultobj = 0;
 
16074
  wxSpinButton *arg1 = (wxSpinButton *) 0 ;
 
16075
  int result;
 
16076
  void *argp1 = 0 ;
 
16077
  int res1 = 0 ;
 
16078
  PyObject *swig_obj[1] ;
 
16079
  
 
16080
  if (!args) SWIG_fail;
 
16081
  swig_obj[0] = args;
 
16082
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinButton, 0 |  0 );
 
16083
  if (!SWIG_IsOK(res1)) {
 
16084
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinButton_GetMin" "', expected argument " "1"" of type '" "wxSpinButton const *""'"); 
 
16085
  }
 
16086
  arg1 = reinterpret_cast< wxSpinButton * >(argp1);
 
16087
  {
 
16088
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16089
    result = (int)((wxSpinButton const *)arg1)->GetMin();
 
16090
    wxPyEndAllowThreads(__tstate);
 
16091
    if (PyErr_Occurred()) SWIG_fail;
 
16092
  }
 
16093
  resultobj = SWIG_From_int(static_cast< int >(result));
 
16094
  return resultobj;
 
16095
fail:
 
16096
  return NULL;
 
16097
}
 
16098
 
 
16099
 
 
16100
SWIGINTERN PyObject *_wrap_SpinButton_GetMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16101
  PyObject *resultobj = 0;
 
16102
  wxSpinButton *arg1 = (wxSpinButton *) 0 ;
 
16103
  int result;
 
16104
  void *argp1 = 0 ;
 
16105
  int res1 = 0 ;
 
16106
  PyObject *swig_obj[1] ;
 
16107
  
 
16108
  if (!args) SWIG_fail;
 
16109
  swig_obj[0] = args;
 
16110
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinButton, 0 |  0 );
 
16111
  if (!SWIG_IsOK(res1)) {
 
16112
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinButton_GetMax" "', expected argument " "1"" of type '" "wxSpinButton const *""'"); 
 
16113
  }
 
16114
  arg1 = reinterpret_cast< wxSpinButton * >(argp1);
 
16115
  {
 
16116
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16117
    result = (int)((wxSpinButton const *)arg1)->GetMax();
 
16118
    wxPyEndAllowThreads(__tstate);
 
16119
    if (PyErr_Occurred()) SWIG_fail;
 
16120
  }
 
16121
  resultobj = SWIG_From_int(static_cast< int >(result));
 
16122
  return resultobj;
 
16123
fail:
 
16124
  return NULL;
 
16125
}
 
16126
 
 
16127
 
 
16128
SWIGINTERN PyObject *_wrap_SpinButton_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16129
  PyObject *resultobj = 0;
 
16130
  wxSpinButton *arg1 = (wxSpinButton *) 0 ;
 
16131
  int arg2 ;
 
16132
  void *argp1 = 0 ;
 
16133
  int res1 = 0 ;
 
16134
  int val2 ;
 
16135
  int ecode2 = 0 ;
 
16136
  PyObject * obj0 = 0 ;
 
16137
  PyObject * obj1 = 0 ;
 
16138
  char *  kwnames[] = {
 
16139
    (char *) "self",(char *) "val", NULL 
 
16140
  };
 
16141
  
 
16142
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinButton_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
16143
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinButton, 0 |  0 );
 
16144
  if (!SWIG_IsOK(res1)) {
 
16145
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinButton_SetValue" "', expected argument " "1"" of type '" "wxSpinButton *""'"); 
 
16146
  }
 
16147
  arg1 = reinterpret_cast< wxSpinButton * >(argp1);
 
16148
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
16149
  if (!SWIG_IsOK(ecode2)) {
 
16150
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinButton_SetValue" "', expected argument " "2"" of type '" "int""'");
 
16151
  } 
 
16152
  arg2 = static_cast< int >(val2);
 
16153
  {
 
16154
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16155
    (arg1)->SetValue(arg2);
 
16156
    wxPyEndAllowThreads(__tstate);
 
16157
    if (PyErr_Occurred()) SWIG_fail;
 
16158
  }
 
16159
  resultobj = SWIG_Py_Void();
 
16160
  return resultobj;
 
16161
fail:
 
16162
  return NULL;
 
16163
}
 
16164
 
 
16165
 
 
16166
SWIGINTERN PyObject *_wrap_SpinButton_SetMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16167
  PyObject *resultobj = 0;
 
16168
  wxSpinButton *arg1 = (wxSpinButton *) 0 ;
 
16169
  int arg2 ;
 
16170
  void *argp1 = 0 ;
 
16171
  int res1 = 0 ;
 
16172
  int val2 ;
 
16173
  int ecode2 = 0 ;
 
16174
  PyObject * obj0 = 0 ;
 
16175
  PyObject * obj1 = 0 ;
 
16176
  char *  kwnames[] = {
 
16177
    (char *) "self",(char *) "minVal", NULL 
 
16178
  };
 
16179
  
 
16180
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinButton_SetMin",kwnames,&obj0,&obj1)) SWIG_fail;
 
16181
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinButton, 0 |  0 );
 
16182
  if (!SWIG_IsOK(res1)) {
 
16183
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinButton_SetMin" "', expected argument " "1"" of type '" "wxSpinButton *""'"); 
 
16184
  }
 
16185
  arg1 = reinterpret_cast< wxSpinButton * >(argp1);
 
16186
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
16187
  if (!SWIG_IsOK(ecode2)) {
 
16188
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinButton_SetMin" "', expected argument " "2"" of type '" "int""'");
 
16189
  } 
 
16190
  arg2 = static_cast< int >(val2);
 
16191
  {
 
16192
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16193
    (arg1)->SetMin(arg2);
 
16194
    wxPyEndAllowThreads(__tstate);
 
16195
    if (PyErr_Occurred()) SWIG_fail;
 
16196
  }
 
16197
  resultobj = SWIG_Py_Void();
 
16198
  return resultobj;
 
16199
fail:
 
16200
  return NULL;
 
16201
}
 
16202
 
 
16203
 
 
16204
SWIGINTERN PyObject *_wrap_SpinButton_SetMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16205
  PyObject *resultobj = 0;
 
16206
  wxSpinButton *arg1 = (wxSpinButton *) 0 ;
 
16207
  int arg2 ;
 
16208
  void *argp1 = 0 ;
 
16209
  int res1 = 0 ;
 
16210
  int val2 ;
 
16211
  int ecode2 = 0 ;
 
16212
  PyObject * obj0 = 0 ;
 
16213
  PyObject * obj1 = 0 ;
 
16214
  char *  kwnames[] = {
 
16215
    (char *) "self",(char *) "maxVal", NULL 
 
16216
  };
 
16217
  
 
16218
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinButton_SetMax",kwnames,&obj0,&obj1)) SWIG_fail;
 
16219
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinButton, 0 |  0 );
 
16220
  if (!SWIG_IsOK(res1)) {
 
16221
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinButton_SetMax" "', expected argument " "1"" of type '" "wxSpinButton *""'"); 
 
16222
  }
 
16223
  arg1 = reinterpret_cast< wxSpinButton * >(argp1);
 
16224
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
16225
  if (!SWIG_IsOK(ecode2)) {
 
16226
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinButton_SetMax" "', expected argument " "2"" of type '" "int""'");
 
16227
  } 
 
16228
  arg2 = static_cast< int >(val2);
 
16229
  {
 
16230
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16231
    (arg1)->SetMax(arg2);
 
16232
    wxPyEndAllowThreads(__tstate);
 
16233
    if (PyErr_Occurred()) SWIG_fail;
 
16234
  }
 
16235
  resultobj = SWIG_Py_Void();
 
16236
  return resultobj;
 
16237
fail:
 
16238
  return NULL;
 
16239
}
 
16240
 
 
16241
 
 
16242
SWIGINTERN PyObject *_wrap_SpinButton_SetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16243
  PyObject *resultobj = 0;
 
16244
  wxSpinButton *arg1 = (wxSpinButton *) 0 ;
 
16245
  int arg2 ;
 
16246
  int arg3 ;
 
16247
  void *argp1 = 0 ;
 
16248
  int res1 = 0 ;
 
16249
  int val2 ;
 
16250
  int ecode2 = 0 ;
 
16251
  int val3 ;
 
16252
  int ecode3 = 0 ;
 
16253
  PyObject * obj0 = 0 ;
 
16254
  PyObject * obj1 = 0 ;
 
16255
  PyObject * obj2 = 0 ;
 
16256
  char *  kwnames[] = {
 
16257
    (char *) "self",(char *) "minVal",(char *) "maxVal", NULL 
 
16258
  };
 
16259
  
 
16260
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SpinButton_SetRange",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
16261
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinButton, 0 |  0 );
 
16262
  if (!SWIG_IsOK(res1)) {
 
16263
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinButton_SetRange" "', expected argument " "1"" of type '" "wxSpinButton *""'"); 
 
16264
  }
 
16265
  arg1 = reinterpret_cast< wxSpinButton * >(argp1);
 
16266
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
16267
  if (!SWIG_IsOK(ecode2)) {
 
16268
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinButton_SetRange" "', expected argument " "2"" of type '" "int""'");
 
16269
  } 
 
16270
  arg2 = static_cast< int >(val2);
 
16271
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
16272
  if (!SWIG_IsOK(ecode3)) {
 
16273
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpinButton_SetRange" "', expected argument " "3"" of type '" "int""'");
 
16274
  } 
 
16275
  arg3 = static_cast< int >(val3);
 
16276
  {
 
16277
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16278
    (arg1)->SetRange(arg2,arg3);
 
16279
    wxPyEndAllowThreads(__tstate);
 
16280
    if (PyErr_Occurred()) SWIG_fail;
 
16281
  }
 
16282
  resultobj = SWIG_Py_Void();
 
16283
  return resultobj;
 
16284
fail:
 
16285
  return NULL;
 
16286
}
 
16287
 
 
16288
 
 
16289
SWIGINTERN PyObject *_wrap_SpinButton_IsVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16290
  PyObject *resultobj = 0;
 
16291
  wxSpinButton *arg1 = (wxSpinButton *) 0 ;
 
16292
  bool result;
 
16293
  void *argp1 = 0 ;
 
16294
  int res1 = 0 ;
 
16295
  PyObject *swig_obj[1] ;
 
16296
  
 
16297
  if (!args) SWIG_fail;
 
16298
  swig_obj[0] = args;
 
16299
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinButton, 0 |  0 );
 
16300
  if (!SWIG_IsOK(res1)) {
 
16301
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinButton_IsVertical" "', expected argument " "1"" of type '" "wxSpinButton const *""'"); 
 
16302
  }
 
16303
  arg1 = reinterpret_cast< wxSpinButton * >(argp1);
 
16304
  {
 
16305
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16306
    result = (bool)((wxSpinButton const *)arg1)->IsVertical();
 
16307
    wxPyEndAllowThreads(__tstate);
 
16308
    if (PyErr_Occurred()) SWIG_fail;
 
16309
  }
 
16310
  {
 
16311
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
16312
  }
 
16313
  return resultobj;
 
16314
fail:
 
16315
  return NULL;
 
16316
}
 
16317
 
 
16318
 
 
16319
SWIGINTERN PyObject *_wrap_SpinButton_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16320
  PyObject *resultobj = 0;
 
16321
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
16322
  SwigValueWrapper<wxVisualAttributes > result;
 
16323
  int val1 ;
 
16324
  int ecode1 = 0 ;
 
16325
  PyObject * obj0 = 0 ;
 
16326
  char *  kwnames[] = {
 
16327
    (char *) "variant", NULL 
 
16328
  };
 
16329
  
 
16330
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SpinButton_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
16331
  if (obj0) {
 
16332
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
16333
    if (!SWIG_IsOK(ecode1)) {
 
16334
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SpinButton_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
16335
    } 
 
16336
    arg1 = static_cast< wxWindowVariant >(val1);
 
16337
  }
 
16338
  {
 
16339
    if (!wxPyCheckForApp()) SWIG_fail;
 
16340
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16341
    result = wxSpinButton::GetClassDefaultAttributes(arg1);
 
16342
    wxPyEndAllowThreads(__tstate);
 
16343
    if (PyErr_Occurred()) SWIG_fail;
 
16344
  }
 
16345
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
16346
  return resultobj;
 
16347
fail:
 
16348
  return NULL;
 
16349
}
 
16350
 
 
16351
 
 
16352
SWIGINTERN PyObject *SpinButton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16353
  PyObject *obj;
 
16354
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
16355
  SWIG_TypeNewClientData(SWIGTYPE_p_wxSpinButton, SWIG_NewClientData(obj));
 
16356
  return SWIG_Py_Void();
 
16357
}
 
16358
 
 
16359
SWIGINTERN PyObject *SpinButton_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16360
  return SWIG_Python_InitShadowInstance(args);
 
16361
}
 
16362
 
 
16363
SWIGINTERN PyObject *_wrap_new_SpinCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16364
  PyObject *resultobj = 0;
 
16365
  wxWindow *arg1 = (wxWindow *) 0 ;
 
16366
  int arg2 = (int) -1 ;
 
16367
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
16368
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
16369
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
16370
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
16371
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
16372
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
16373
  long arg6 = (long) wxSP_ARROW_KEYS|wxALIGN_RIGHT ;
 
16374
  int arg7 = (int) 0 ;
 
16375
  int arg8 = (int) 100 ;
 
16376
  int arg9 = (int) 0 ;
 
16377
  wxString const &arg10_defvalue = wxPySpinCtrlNameStr ;
 
16378
  wxString *arg10 = (wxString *) &arg10_defvalue ;
 
16379
  wxSpinCtrl *result = 0 ;
 
16380
  void *argp1 = 0 ;
 
16381
  int res1 = 0 ;
 
16382
  int val2 ;
 
16383
  int ecode2 = 0 ;
 
16384
  bool temp3 = false ;
 
16385
  wxPoint temp4 ;
 
16386
  wxSize temp5 ;
 
16387
  long val6 ;
 
16388
  int ecode6 = 0 ;
 
16389
  int val7 ;
 
16390
  int ecode7 = 0 ;
 
16391
  int val8 ;
 
16392
  int ecode8 = 0 ;
 
16393
  int val9 ;
 
16394
  int ecode9 = 0 ;
 
16395
  bool temp10 = false ;
 
16396
  PyObject * obj0 = 0 ;
 
16397
  PyObject * obj1 = 0 ;
 
16398
  PyObject * obj2 = 0 ;
 
16399
  PyObject * obj3 = 0 ;
 
16400
  PyObject * obj4 = 0 ;
 
16401
  PyObject * obj5 = 0 ;
 
16402
  PyObject * obj6 = 0 ;
 
16403
  PyObject * obj7 = 0 ;
 
16404
  PyObject * obj8 = 0 ;
 
16405
  PyObject * obj9 = 0 ;
 
16406
  char *  kwnames[] = {
 
16407
    (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "min",(char *) "max",(char *) "initial",(char *) "name", NULL 
 
16408
  };
 
16409
  
 
16410
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOO:new_SpinCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
 
16411
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
16412
  if (!SWIG_IsOK(res1)) {
 
16413
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpinCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
16414
  }
 
16415
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
16416
  if (obj1) {
 
16417
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
16418
    if (!SWIG_IsOK(ecode2)) {
 
16419
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpinCtrl" "', expected argument " "2"" of type '" "int""'");
 
16420
    } 
 
16421
    arg2 = static_cast< int >(val2);
 
16422
  }
 
16423
  if (obj2) {
 
16424
    {
 
16425
      arg3 = wxString_in_helper(obj2);
 
16426
      if (arg3 == NULL) SWIG_fail;
 
16427
      temp3 = true;
 
16428
    }
 
16429
  }
 
16430
  if (obj3) {
 
16431
    {
 
16432
      arg4 = &temp4;
 
16433
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
16434
    }
 
16435
  }
 
16436
  if (obj4) {
 
16437
    {
 
16438
      arg5 = &temp5;
 
16439
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
16440
    }
 
16441
  }
 
16442
  if (obj5) {
 
16443
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
16444
    if (!SWIG_IsOK(ecode6)) {
 
16445
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpinCtrl" "', expected argument " "6"" of type '" "long""'");
 
16446
    } 
 
16447
    arg6 = static_cast< long >(val6);
 
16448
  }
 
16449
  if (obj6) {
 
16450
    ecode7 = SWIG_AsVal_int(obj6, &val7);
 
16451
    if (!SWIG_IsOK(ecode7)) {
 
16452
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpinCtrl" "', expected argument " "7"" of type '" "int""'");
 
16453
    } 
 
16454
    arg7 = static_cast< int >(val7);
 
16455
  }
 
16456
  if (obj7) {
 
16457
    ecode8 = SWIG_AsVal_int(obj7, &val8);
 
16458
    if (!SWIG_IsOK(ecode8)) {
 
16459
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SpinCtrl" "', expected argument " "8"" of type '" "int""'");
 
16460
    } 
 
16461
    arg8 = static_cast< int >(val8);
 
16462
  }
 
16463
  if (obj8) {
 
16464
    ecode9 = SWIG_AsVal_int(obj8, &val9);
 
16465
    if (!SWIG_IsOK(ecode9)) {
 
16466
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpinCtrl" "', expected argument " "9"" of type '" "int""'");
 
16467
    } 
 
16468
    arg9 = static_cast< int >(val9);
 
16469
  }
 
16470
  if (obj9) {
 
16471
    {
 
16472
      arg10 = wxString_in_helper(obj9);
 
16473
      if (arg10 == NULL) SWIG_fail;
 
16474
      temp10 = true;
 
16475
    }
 
16476
  }
 
16477
  {
 
16478
    if (!wxPyCheckForApp()) SWIG_fail;
 
16479
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16480
    result = (wxSpinCtrl *)new wxSpinCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,arg7,arg8,arg9,(wxString const &)*arg10);
 
16481
    wxPyEndAllowThreads(__tstate);
 
16482
    if (PyErr_Occurred()) SWIG_fail;
 
16483
  }
 
16484
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_NEW |  0 );
 
16485
  {
 
16486
    if (temp3)
 
16487
    delete arg3;
 
16488
  }
 
16489
  {
 
16490
    if (temp10)
 
16491
    delete arg10;
 
16492
  }
 
16493
  return resultobj;
 
16494
fail:
 
16495
  {
 
16496
    if (temp3)
 
16497
    delete arg3;
 
16498
  }
 
16499
  {
 
16500
    if (temp10)
 
16501
    delete arg10;
 
16502
  }
 
16503
  return NULL;
 
16504
}
 
16505
 
 
16506
 
 
16507
SWIGINTERN PyObject *_wrap_new_PreSpinCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16508
  PyObject *resultobj = 0;
 
16509
  wxSpinCtrl *result = 0 ;
 
16510
  
 
16511
  if (!SWIG_Python_UnpackTuple(args,"new_PreSpinCtrl",0,0,0)) SWIG_fail;
 
16512
  {
 
16513
    if (!wxPyCheckForApp()) SWIG_fail;
 
16514
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16515
    result = (wxSpinCtrl *)new wxSpinCtrl();
 
16516
    wxPyEndAllowThreads(__tstate);
 
16517
    if (PyErr_Occurred()) SWIG_fail;
 
16518
  }
 
16519
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSpinCtrl, SWIG_POINTER_OWN |  0 );
 
16520
  return resultobj;
 
16521
fail:
 
16522
  return NULL;
 
16523
}
 
16524
 
 
16525
 
 
16526
SWIGINTERN PyObject *_wrap_SpinCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16527
  PyObject *resultobj = 0;
 
16528
  wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
 
16529
  wxWindow *arg2 = (wxWindow *) 0 ;
 
16530
  int arg3 = (int) -1 ;
 
16531
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
16532
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
16533
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
16534
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
16535
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
16536
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
16537
  long arg7 = (long) wxSP_ARROW_KEYS ;
 
16538
  int arg8 = (int) 0 ;
 
16539
  int arg9 = (int) 100 ;
 
16540
  int arg10 = (int) 0 ;
 
16541
  wxString const &arg11_defvalue = wxPySpinCtrlNameStr ;
 
16542
  wxString *arg11 = (wxString *) &arg11_defvalue ;
 
16543
  bool result;
 
16544
  void *argp1 = 0 ;
 
16545
  int res1 = 0 ;
 
16546
  void *argp2 = 0 ;
 
16547
  int res2 = 0 ;
 
16548
  int val3 ;
 
16549
  int ecode3 = 0 ;
 
16550
  bool temp4 = false ;
 
16551
  wxPoint temp5 ;
 
16552
  wxSize temp6 ;
 
16553
  long val7 ;
 
16554
  int ecode7 = 0 ;
 
16555
  int val8 ;
 
16556
  int ecode8 = 0 ;
 
16557
  int val9 ;
 
16558
  int ecode9 = 0 ;
 
16559
  int val10 ;
 
16560
  int ecode10 = 0 ;
 
16561
  bool temp11 = false ;
 
16562
  PyObject * obj0 = 0 ;
 
16563
  PyObject * obj1 = 0 ;
 
16564
  PyObject * obj2 = 0 ;
 
16565
  PyObject * obj3 = 0 ;
 
16566
  PyObject * obj4 = 0 ;
 
16567
  PyObject * obj5 = 0 ;
 
16568
  PyObject * obj6 = 0 ;
 
16569
  PyObject * obj7 = 0 ;
 
16570
  PyObject * obj8 = 0 ;
 
16571
  PyObject * obj9 = 0 ;
 
16572
  PyObject * obj10 = 0 ;
 
16573
  char *  kwnames[] = {
 
16574
    (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "min",(char *) "max",(char *) "initial",(char *) "name", NULL 
 
16575
  };
 
16576
  
 
16577
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOO:SpinCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
 
16578
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinCtrl, 0 |  0 );
 
16579
  if (!SWIG_IsOK(res1)) {
 
16580
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrl_Create" "', expected argument " "1"" of type '" "wxSpinCtrl *""'"); 
 
16581
  }
 
16582
  arg1 = reinterpret_cast< wxSpinCtrl * >(argp1);
 
16583
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
16584
  if (!SWIG_IsOK(res2)) {
 
16585
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpinCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
16586
  }
 
16587
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
16588
  if (obj2) {
 
16589
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
16590
    if (!SWIG_IsOK(ecode3)) {
 
16591
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpinCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
16592
    } 
 
16593
    arg3 = static_cast< int >(val3);
 
16594
  }
 
16595
  if (obj3) {
 
16596
    {
 
16597
      arg4 = wxString_in_helper(obj3);
 
16598
      if (arg4 == NULL) SWIG_fail;
 
16599
      temp4 = true;
 
16600
    }
 
16601
  }
 
16602
  if (obj4) {
 
16603
    {
 
16604
      arg5 = &temp5;
 
16605
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
16606
    }
 
16607
  }
 
16608
  if (obj5) {
 
16609
    {
 
16610
      arg6 = &temp6;
 
16611
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
16612
    }
 
16613
  }
 
16614
  if (obj6) {
 
16615
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
16616
    if (!SWIG_IsOK(ecode7)) {
 
16617
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpinCtrl_Create" "', expected argument " "7"" of type '" "long""'");
 
16618
    } 
 
16619
    arg7 = static_cast< long >(val7);
 
16620
  }
 
16621
  if (obj7) {
 
16622
    ecode8 = SWIG_AsVal_int(obj7, &val8);
 
16623
    if (!SWIG_IsOK(ecode8)) {
 
16624
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SpinCtrl_Create" "', expected argument " "8"" of type '" "int""'");
 
16625
    } 
 
16626
    arg8 = static_cast< int >(val8);
 
16627
  }
 
16628
  if (obj8) {
 
16629
    ecode9 = SWIG_AsVal_int(obj8, &val9);
 
16630
    if (!SWIG_IsOK(ecode9)) {
 
16631
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SpinCtrl_Create" "', expected argument " "9"" of type '" "int""'");
 
16632
    } 
 
16633
    arg9 = static_cast< int >(val9);
 
16634
  }
 
16635
  if (obj9) {
 
16636
    ecode10 = SWIG_AsVal_int(obj9, &val10);
 
16637
    if (!SWIG_IsOK(ecode10)) {
 
16638
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SpinCtrl_Create" "', expected argument " "10"" of type '" "int""'");
 
16639
    } 
 
16640
    arg10 = static_cast< int >(val10);
 
16641
  }
 
16642
  if (obj10) {
 
16643
    {
 
16644
      arg11 = wxString_in_helper(obj10);
 
16645
      if (arg11 == NULL) SWIG_fail;
 
16646
      temp11 = true;
 
16647
    }
 
16648
  }
 
16649
  {
 
16650
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16651
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,arg8,arg9,arg10,(wxString const &)*arg11);
 
16652
    wxPyEndAllowThreads(__tstate);
 
16653
    if (PyErr_Occurred()) SWIG_fail;
 
16654
  }
 
16655
  {
 
16656
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
16657
  }
 
16658
  {
 
16659
    if (temp4)
 
16660
    delete arg4;
 
16661
  }
 
16662
  {
 
16663
    if (temp11)
 
16664
    delete arg11;
 
16665
  }
 
16666
  return resultobj;
 
16667
fail:
 
16668
  {
 
16669
    if (temp4)
 
16670
    delete arg4;
 
16671
  }
 
16672
  {
 
16673
    if (temp11)
 
16674
    delete arg11;
 
16675
  }
 
16676
  return NULL;
 
16677
}
 
16678
 
 
16679
 
 
16680
SWIGINTERN PyObject *_wrap_SpinCtrl_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16681
  PyObject *resultobj = 0;
 
16682
  wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
 
16683
  int result;
 
16684
  void *argp1 = 0 ;
 
16685
  int res1 = 0 ;
 
16686
  PyObject *swig_obj[1] ;
 
16687
  
 
16688
  if (!args) SWIG_fail;
 
16689
  swig_obj[0] = args;
 
16690
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinCtrl, 0 |  0 );
 
16691
  if (!SWIG_IsOK(res1)) {
 
16692
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrl_GetValue" "', expected argument " "1"" of type '" "wxSpinCtrl const *""'"); 
 
16693
  }
 
16694
  arg1 = reinterpret_cast< wxSpinCtrl * >(argp1);
 
16695
  {
 
16696
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16697
    result = (int)((wxSpinCtrl const *)arg1)->GetValue();
 
16698
    wxPyEndAllowThreads(__tstate);
 
16699
    if (PyErr_Occurred()) SWIG_fail;
 
16700
  }
 
16701
  resultobj = SWIG_From_int(static_cast< int >(result));
 
16702
  return resultobj;
 
16703
fail:
 
16704
  return NULL;
 
16705
}
 
16706
 
 
16707
 
 
16708
SWIGINTERN PyObject *_wrap_SpinCtrl_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16709
  PyObject *resultobj = 0;
 
16710
  wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
 
16711
  int arg2 ;
 
16712
  void *argp1 = 0 ;
 
16713
  int res1 = 0 ;
 
16714
  int val2 ;
 
16715
  int ecode2 = 0 ;
 
16716
  PyObject * obj0 = 0 ;
 
16717
  PyObject * obj1 = 0 ;
 
16718
  char *  kwnames[] = {
 
16719
    (char *) "self",(char *) "value", NULL 
 
16720
  };
 
16721
  
 
16722
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinCtrl_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
16723
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinCtrl, 0 |  0 );
 
16724
  if (!SWIG_IsOK(res1)) {
 
16725
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrl_SetValue" "', expected argument " "1"" of type '" "wxSpinCtrl *""'"); 
 
16726
  }
 
16727
  arg1 = reinterpret_cast< wxSpinCtrl * >(argp1);
 
16728
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
16729
  if (!SWIG_IsOK(ecode2)) {
 
16730
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinCtrl_SetValue" "', expected argument " "2"" of type '" "int""'");
 
16731
  } 
 
16732
  arg2 = static_cast< int >(val2);
 
16733
  {
 
16734
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16735
    (arg1)->SetValue(arg2);
 
16736
    wxPyEndAllowThreads(__tstate);
 
16737
    if (PyErr_Occurred()) SWIG_fail;
 
16738
  }
 
16739
  resultobj = SWIG_Py_Void();
 
16740
  return resultobj;
 
16741
fail:
 
16742
  return NULL;
 
16743
}
 
16744
 
 
16745
 
 
16746
SWIGINTERN PyObject *_wrap_SpinCtrl_SetValueString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16747
  PyObject *resultobj = 0;
 
16748
  wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
 
16749
  wxString *arg2 = 0 ;
 
16750
  void *argp1 = 0 ;
 
16751
  int res1 = 0 ;
 
16752
  bool temp2 = false ;
 
16753
  PyObject * obj0 = 0 ;
 
16754
  PyObject * obj1 = 0 ;
 
16755
  char *  kwnames[] = {
 
16756
    (char *) "self",(char *) "text", NULL 
 
16757
  };
 
16758
  
 
16759
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinCtrl_SetValueString",kwnames,&obj0,&obj1)) SWIG_fail;
 
16760
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinCtrl, 0 |  0 );
 
16761
  if (!SWIG_IsOK(res1)) {
 
16762
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrl_SetValueString" "', expected argument " "1"" of type '" "wxSpinCtrl *""'"); 
 
16763
  }
 
16764
  arg1 = reinterpret_cast< wxSpinCtrl * >(argp1);
 
16765
  {
 
16766
    arg2 = wxString_in_helper(obj1);
 
16767
    if (arg2 == NULL) SWIG_fail;
 
16768
    temp2 = true;
 
16769
  }
 
16770
  {
 
16771
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16772
    (arg1)->SetValue((wxString const &)*arg2);
 
16773
    wxPyEndAllowThreads(__tstate);
 
16774
    if (PyErr_Occurred()) SWIG_fail;
 
16775
  }
 
16776
  resultobj = SWIG_Py_Void();
 
16777
  {
 
16778
    if (temp2)
 
16779
    delete arg2;
 
16780
  }
 
16781
  return resultobj;
 
16782
fail:
 
16783
  {
 
16784
    if (temp2)
 
16785
    delete arg2;
 
16786
  }
 
16787
  return NULL;
 
16788
}
 
16789
 
 
16790
 
 
16791
SWIGINTERN PyObject *_wrap_SpinCtrl_SetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16792
  PyObject *resultobj = 0;
 
16793
  wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
 
16794
  int arg2 ;
 
16795
  int arg3 ;
 
16796
  void *argp1 = 0 ;
 
16797
  int res1 = 0 ;
 
16798
  int val2 ;
 
16799
  int ecode2 = 0 ;
 
16800
  int val3 ;
 
16801
  int ecode3 = 0 ;
 
16802
  PyObject * obj0 = 0 ;
 
16803
  PyObject * obj1 = 0 ;
 
16804
  PyObject * obj2 = 0 ;
 
16805
  char *  kwnames[] = {
 
16806
    (char *) "self",(char *) "minVal",(char *) "maxVal", NULL 
 
16807
  };
 
16808
  
 
16809
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SpinCtrl_SetRange",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
16810
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinCtrl, 0 |  0 );
 
16811
  if (!SWIG_IsOK(res1)) {
 
16812
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrl_SetRange" "', expected argument " "1"" of type '" "wxSpinCtrl *""'"); 
 
16813
  }
 
16814
  arg1 = reinterpret_cast< wxSpinCtrl * >(argp1);
 
16815
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
16816
  if (!SWIG_IsOK(ecode2)) {
 
16817
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinCtrl_SetRange" "', expected argument " "2"" of type '" "int""'");
 
16818
  } 
 
16819
  arg2 = static_cast< int >(val2);
 
16820
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
16821
  if (!SWIG_IsOK(ecode3)) {
 
16822
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpinCtrl_SetRange" "', expected argument " "3"" of type '" "int""'");
 
16823
  } 
 
16824
  arg3 = static_cast< int >(val3);
 
16825
  {
 
16826
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16827
    (arg1)->SetRange(arg2,arg3);
 
16828
    wxPyEndAllowThreads(__tstate);
 
16829
    if (PyErr_Occurred()) SWIG_fail;
 
16830
  }
 
16831
  resultobj = SWIG_Py_Void();
 
16832
  return resultobj;
 
16833
fail:
 
16834
  return NULL;
 
16835
}
 
16836
 
 
16837
 
 
16838
SWIGINTERN PyObject *_wrap_SpinCtrl_GetMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16839
  PyObject *resultobj = 0;
 
16840
  wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
 
16841
  int result;
 
16842
  void *argp1 = 0 ;
 
16843
  int res1 = 0 ;
 
16844
  PyObject *swig_obj[1] ;
 
16845
  
 
16846
  if (!args) SWIG_fail;
 
16847
  swig_obj[0] = args;
 
16848
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinCtrl, 0 |  0 );
 
16849
  if (!SWIG_IsOK(res1)) {
 
16850
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrl_GetMin" "', expected argument " "1"" of type '" "wxSpinCtrl const *""'"); 
 
16851
  }
 
16852
  arg1 = reinterpret_cast< wxSpinCtrl * >(argp1);
 
16853
  {
 
16854
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16855
    result = (int)((wxSpinCtrl const *)arg1)->GetMin();
 
16856
    wxPyEndAllowThreads(__tstate);
 
16857
    if (PyErr_Occurred()) SWIG_fail;
 
16858
  }
 
16859
  resultobj = SWIG_From_int(static_cast< int >(result));
 
16860
  return resultobj;
 
16861
fail:
 
16862
  return NULL;
 
16863
}
 
16864
 
 
16865
 
 
16866
SWIGINTERN PyObject *_wrap_SpinCtrl_GetMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16867
  PyObject *resultobj = 0;
 
16868
  wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
 
16869
  int result;
 
16870
  void *argp1 = 0 ;
 
16871
  int res1 = 0 ;
 
16872
  PyObject *swig_obj[1] ;
 
16873
  
 
16874
  if (!args) SWIG_fail;
 
16875
  swig_obj[0] = args;
 
16876
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinCtrl, 0 |  0 );
 
16877
  if (!SWIG_IsOK(res1)) {
 
16878
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrl_GetMax" "', expected argument " "1"" of type '" "wxSpinCtrl const *""'"); 
 
16879
  }
 
16880
  arg1 = reinterpret_cast< wxSpinCtrl * >(argp1);
 
16881
  {
 
16882
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16883
    result = (int)((wxSpinCtrl const *)arg1)->GetMax();
 
16884
    wxPyEndAllowThreads(__tstate);
 
16885
    if (PyErr_Occurred()) SWIG_fail;
 
16886
  }
 
16887
  resultobj = SWIG_From_int(static_cast< int >(result));
 
16888
  return resultobj;
 
16889
fail:
 
16890
  return NULL;
 
16891
}
 
16892
 
 
16893
 
 
16894
SWIGINTERN PyObject *_wrap_SpinCtrl_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16895
  PyObject *resultobj = 0;
 
16896
  wxSpinCtrl *arg1 = (wxSpinCtrl *) 0 ;
 
16897
  long arg2 ;
 
16898
  long arg3 ;
 
16899
  void *argp1 = 0 ;
 
16900
  int res1 = 0 ;
 
16901
  long val2 ;
 
16902
  int ecode2 = 0 ;
 
16903
  long val3 ;
 
16904
  int ecode3 = 0 ;
 
16905
  PyObject * obj0 = 0 ;
 
16906
  PyObject * obj1 = 0 ;
 
16907
  PyObject * obj2 = 0 ;
 
16908
  char *  kwnames[] = {
 
16909
    (char *) "self",(char *) "from",(char *) "to", NULL 
 
16910
  };
 
16911
  
 
16912
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SpinCtrl_SetSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
16913
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinCtrl, 0 |  0 );
 
16914
  if (!SWIG_IsOK(res1)) {
 
16915
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrl_SetSelection" "', expected argument " "1"" of type '" "wxSpinCtrl *""'"); 
 
16916
  }
 
16917
  arg1 = reinterpret_cast< wxSpinCtrl * >(argp1);
 
16918
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
16919
  if (!SWIG_IsOK(ecode2)) {
 
16920
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinCtrl_SetSelection" "', expected argument " "2"" of type '" "long""'");
 
16921
  } 
 
16922
  arg2 = static_cast< long >(val2);
 
16923
  ecode3 = SWIG_AsVal_long(obj2, &val3);
 
16924
  if (!SWIG_IsOK(ecode3)) {
 
16925
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpinCtrl_SetSelection" "', expected argument " "3"" of type '" "long""'");
 
16926
  } 
 
16927
  arg3 = static_cast< long >(val3);
 
16928
  {
 
16929
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16930
    (arg1)->SetSelection(arg2,arg3);
 
16931
    wxPyEndAllowThreads(__tstate);
 
16932
    if (PyErr_Occurred()) SWIG_fail;
 
16933
  }
 
16934
  resultobj = SWIG_Py_Void();
 
16935
  return resultobj;
 
16936
fail:
 
16937
  return NULL;
 
16938
}
 
16939
 
 
16940
 
 
16941
SWIGINTERN PyObject *_wrap_SpinCtrl_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16942
  PyObject *resultobj = 0;
 
16943
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
16944
  SwigValueWrapper<wxVisualAttributes > result;
 
16945
  int val1 ;
 
16946
  int ecode1 = 0 ;
 
16947
  PyObject * obj0 = 0 ;
 
16948
  char *  kwnames[] = {
 
16949
    (char *) "variant", NULL 
 
16950
  };
 
16951
  
 
16952
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SpinCtrl_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
16953
  if (obj0) {
 
16954
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
16955
    if (!SWIG_IsOK(ecode1)) {
 
16956
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SpinCtrl_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
16957
    } 
 
16958
    arg1 = static_cast< wxWindowVariant >(val1);
 
16959
  }
 
16960
  {
 
16961
    if (!wxPyCheckForApp()) SWIG_fail;
 
16962
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
16963
    result = wxSpinCtrl::GetClassDefaultAttributes(arg1);
 
16964
    wxPyEndAllowThreads(__tstate);
 
16965
    if (PyErr_Occurred()) SWIG_fail;
 
16966
  }
 
16967
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
16968
  return resultobj;
 
16969
fail:
 
16970
  return NULL;
 
16971
}
 
16972
 
 
16973
 
 
16974
SWIGINTERN PyObject *SpinCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16975
  PyObject *obj;
 
16976
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
16977
  SWIG_TypeNewClientData(SWIGTYPE_p_wxSpinCtrl, SWIG_NewClientData(obj));
 
16978
  return SWIG_Py_Void();
 
16979
}
 
16980
 
 
16981
SWIGINTERN PyObject *SpinCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
16982
  return SWIG_Python_InitShadowInstance(args);
 
16983
}
 
16984
 
 
16985
SWIGINTERN PyObject *_wrap_new_SpinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
16986
  PyObject *resultobj = 0;
 
16987
  wxEventType arg1 = (wxEventType) wxEVT_NULL ;
 
16988
  int arg2 = (int) 0 ;
 
16989
  wxSpinEvent *result = 0 ;
 
16990
  int val1 ;
 
16991
  int ecode1 = 0 ;
 
16992
  int val2 ;
 
16993
  int ecode2 = 0 ;
 
16994
  PyObject * obj0 = 0 ;
 
16995
  PyObject * obj1 = 0 ;
 
16996
  char *  kwnames[] = {
 
16997
    (char *) "commandType",(char *) "winid", NULL 
 
16998
  };
 
16999
  
 
17000
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SpinEvent",kwnames,&obj0,&obj1)) SWIG_fail;
 
17001
  if (obj0) {
 
17002
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
17003
    if (!SWIG_IsOK(ecode1)) {
 
17004
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
 
17005
    } 
 
17006
    arg1 = static_cast< wxEventType >(val1);
 
17007
  }
 
17008
  if (obj1) {
 
17009
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
17010
    if (!SWIG_IsOK(ecode2)) {
 
17011
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpinEvent" "', expected argument " "2"" of type '" "int""'");
 
17012
    } 
 
17013
    arg2 = static_cast< int >(val2);
 
17014
  }
 
17015
  {
 
17016
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17017
    result = (wxSpinEvent *)new wxSpinEvent(arg1,arg2);
 
17018
    wxPyEndAllowThreads(__tstate);
 
17019
    if (PyErr_Occurred()) SWIG_fail;
 
17020
  }
 
17021
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSpinEvent, SWIG_POINTER_NEW |  0 );
 
17022
  return resultobj;
 
17023
fail:
 
17024
  return NULL;
 
17025
}
 
17026
 
 
17027
 
 
17028
SWIGINTERN PyObject *_wrap_SpinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17029
  PyObject *resultobj = 0;
 
17030
  wxSpinEvent *arg1 = (wxSpinEvent *) 0 ;
 
17031
  int result;
 
17032
  void *argp1 = 0 ;
 
17033
  int res1 = 0 ;
 
17034
  PyObject *swig_obj[1] ;
 
17035
  
 
17036
  if (!args) SWIG_fail;
 
17037
  swig_obj[0] = args;
 
17038
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinEvent, 0 |  0 );
 
17039
  if (!SWIG_IsOK(res1)) {
 
17040
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinEvent_GetPosition" "', expected argument " "1"" of type '" "wxSpinEvent const *""'"); 
 
17041
  }
 
17042
  arg1 = reinterpret_cast< wxSpinEvent * >(argp1);
 
17043
  {
 
17044
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17045
    result = (int)((wxSpinEvent const *)arg1)->GetPosition();
 
17046
    wxPyEndAllowThreads(__tstate);
 
17047
    if (PyErr_Occurred()) SWIG_fail;
 
17048
  }
 
17049
  resultobj = SWIG_From_int(static_cast< int >(result));
 
17050
  return resultobj;
 
17051
fail:
 
17052
  return NULL;
 
17053
}
 
17054
 
 
17055
 
 
17056
SWIGINTERN PyObject *_wrap_SpinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17057
  PyObject *resultobj = 0;
 
17058
  wxSpinEvent *arg1 = (wxSpinEvent *) 0 ;
 
17059
  int arg2 ;
 
17060
  void *argp1 = 0 ;
 
17061
  int res1 = 0 ;
 
17062
  int val2 ;
 
17063
  int ecode2 = 0 ;
 
17064
  PyObject * obj0 = 0 ;
 
17065
  PyObject * obj1 = 0 ;
 
17066
  char *  kwnames[] = {
 
17067
    (char *) "self",(char *) "pos", NULL 
 
17068
  };
 
17069
  
 
17070
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
 
17071
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinEvent, 0 |  0 );
 
17072
  if (!SWIG_IsOK(res1)) {
 
17073
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinEvent_SetPosition" "', expected argument " "1"" of type '" "wxSpinEvent *""'"); 
 
17074
  }
 
17075
  arg1 = reinterpret_cast< wxSpinEvent * >(argp1);
 
17076
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
17077
  if (!SWIG_IsOK(ecode2)) {
 
17078
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
 
17079
  } 
 
17080
  arg2 = static_cast< int >(val2);
 
17081
  {
 
17082
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17083
    (arg1)->SetPosition(arg2);
 
17084
    wxPyEndAllowThreads(__tstate);
 
17085
    if (PyErr_Occurred()) SWIG_fail;
 
17086
  }
 
17087
  resultobj = SWIG_Py_Void();
 
17088
  return resultobj;
 
17089
fail:
 
17090
  return NULL;
 
17091
}
 
17092
 
 
17093
 
 
17094
SWIGINTERN PyObject *_wrap_SpinEvent_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17095
  PyObject *resultobj = 0;
 
17096
  wxSpinEvent *arg1 = (wxSpinEvent *) 0 ;
 
17097
  int result;
 
17098
  void *argp1 = 0 ;
 
17099
  int res1 = 0 ;
 
17100
  PyObject *swig_obj[1] ;
 
17101
  
 
17102
  if (!args) SWIG_fail;
 
17103
  swig_obj[0] = args;
 
17104
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinEvent, 0 |  0 );
 
17105
  if (!SWIG_IsOK(res1)) {
 
17106
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinEvent_GetValue" "', expected argument " "1"" of type '" "wxSpinEvent const *""'"); 
 
17107
  }
 
17108
  arg1 = reinterpret_cast< wxSpinEvent * >(argp1);
 
17109
  {
 
17110
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17111
    result = (int)((wxSpinEvent const *)arg1)->GetValue();
 
17112
    wxPyEndAllowThreads(__tstate);
 
17113
    if (PyErr_Occurred()) SWIG_fail;
 
17114
  }
 
17115
  resultobj = SWIG_From_int(static_cast< int >(result));
 
17116
  return resultobj;
 
17117
fail:
 
17118
  return NULL;
 
17119
}
 
17120
 
 
17121
 
 
17122
SWIGINTERN PyObject *_wrap_SpinEvent_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17123
  PyObject *resultobj = 0;
 
17124
  wxSpinEvent *arg1 = (wxSpinEvent *) 0 ;
 
17125
  int arg2 ;
 
17126
  void *argp1 = 0 ;
 
17127
  int res1 = 0 ;
 
17128
  int val2 ;
 
17129
  int ecode2 = 0 ;
 
17130
  PyObject * obj0 = 0 ;
 
17131
  PyObject * obj1 = 0 ;
 
17132
  char *  kwnames[] = {
 
17133
    (char *) "self",(char *) "value", NULL 
 
17134
  };
 
17135
  
 
17136
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinEvent_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
17137
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinEvent, 0 |  0 );
 
17138
  if (!SWIG_IsOK(res1)) {
 
17139
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinEvent_SetValue" "', expected argument " "1"" of type '" "wxSpinEvent *""'"); 
 
17140
  }
 
17141
  arg1 = reinterpret_cast< wxSpinEvent * >(argp1);
 
17142
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
17143
  if (!SWIG_IsOK(ecode2)) {
 
17144
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinEvent_SetValue" "', expected argument " "2"" of type '" "int""'");
 
17145
  } 
 
17146
  arg2 = static_cast< int >(val2);
 
17147
  {
 
17148
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17149
    (arg1)->SetValue(arg2);
 
17150
    wxPyEndAllowThreads(__tstate);
 
17151
    if (PyErr_Occurred()) SWIG_fail;
 
17152
  }
 
17153
  resultobj = SWIG_Py_Void();
 
17154
  return resultobj;
 
17155
fail:
 
17156
  return NULL;
 
17157
}
 
17158
 
 
17159
 
 
17160
SWIGINTERN PyObject *SpinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17161
  PyObject *obj;
 
17162
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
17163
  SWIG_TypeNewClientData(SWIGTYPE_p_wxSpinEvent, SWIG_NewClientData(obj));
 
17164
  return SWIG_Py_Void();
 
17165
}
 
17166
 
 
17167
SWIGINTERN PyObject *SpinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17168
  return SWIG_Python_InitShadowInstance(args);
 
17169
}
 
17170
 
 
17171
SWIGINTERN PyObject *_wrap_new_SpinCtrlDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17172
  PyObject *resultobj = 0;
 
17173
  wxWindow *arg1 = (wxWindow *) 0 ;
 
17174
  int arg2 = (int) wxID_ANY ;
 
17175
  wxString const &arg3_defvalue = wxEmptyString ;
 
17176
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
17177
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
17178
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
17179
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
17180
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
17181
  long arg6 = (long) wxSP_ARROW_KEYS|wxALIGN_RIGHT ;
 
17182
  double arg7 = (double) 0 ;
 
17183
  double arg8 = (double) 100 ;
 
17184
  double arg9 = (double) 0 ;
 
17185
  double arg10 = (double) 1 ;
 
17186
  wxString const &arg11_defvalue = "wxSpinCtrlDouble" ;
 
17187
  wxString *arg11 = (wxString *) &arg11_defvalue ;
 
17188
  wxSpinCtrlDouble *result = 0 ;
 
17189
  void *argp1 = 0 ;
 
17190
  int res1 = 0 ;
 
17191
  int val2 ;
 
17192
  int ecode2 = 0 ;
 
17193
  bool temp3 = false ;
 
17194
  wxPoint temp4 ;
 
17195
  wxSize temp5 ;
 
17196
  long val6 ;
 
17197
  int ecode6 = 0 ;
 
17198
  double val7 ;
 
17199
  int ecode7 = 0 ;
 
17200
  double val8 ;
 
17201
  int ecode8 = 0 ;
 
17202
  double val9 ;
 
17203
  int ecode9 = 0 ;
 
17204
  double val10 ;
 
17205
  int ecode10 = 0 ;
 
17206
  bool temp11 = false ;
 
17207
  PyObject * obj0 = 0 ;
 
17208
  PyObject * obj1 = 0 ;
 
17209
  PyObject * obj2 = 0 ;
 
17210
  PyObject * obj3 = 0 ;
 
17211
  PyObject * obj4 = 0 ;
 
17212
  PyObject * obj5 = 0 ;
 
17213
  PyObject * obj6 = 0 ;
 
17214
  PyObject * obj7 = 0 ;
 
17215
  PyObject * obj8 = 0 ;
 
17216
  PyObject * obj9 = 0 ;
 
17217
  PyObject * obj10 = 0 ;
 
17218
  char *  kwnames[] = {
 
17219
    (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "min",(char *) "max",(char *) "initial",(char *) "inc",(char *) "name", NULL 
 
17220
  };
 
17221
  
 
17222
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOOO:new_SpinCtrlDouble",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
 
17223
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
17224
  if (!SWIG_IsOK(res1)) {
 
17225
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpinCtrlDouble" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
17226
  }
 
17227
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
17228
  if (obj1) {
 
17229
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
17230
    if (!SWIG_IsOK(ecode2)) {
 
17231
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpinCtrlDouble" "', expected argument " "2"" of type '" "int""'");
 
17232
    } 
 
17233
    arg2 = static_cast< int >(val2);
 
17234
  }
 
17235
  if (obj2) {
 
17236
    {
 
17237
      arg3 = wxString_in_helper(obj2);
 
17238
      if (arg3 == NULL) SWIG_fail;
 
17239
      temp3 = true;
 
17240
    }
 
17241
  }
 
17242
  if (obj3) {
 
17243
    {
 
17244
      arg4 = &temp4;
 
17245
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
17246
    }
 
17247
  }
 
17248
  if (obj4) {
 
17249
    {
 
17250
      arg5 = &temp5;
 
17251
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
17252
    }
 
17253
  }
 
17254
  if (obj5) {
 
17255
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
17256
    if (!SWIG_IsOK(ecode6)) {
 
17257
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpinCtrlDouble" "', expected argument " "6"" of type '" "long""'");
 
17258
    } 
 
17259
    arg6 = static_cast< long >(val6);
 
17260
  }
 
17261
  if (obj6) {
 
17262
    ecode7 = SWIG_AsVal_double(obj6, &val7);
 
17263
    if (!SWIG_IsOK(ecode7)) {
 
17264
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpinCtrlDouble" "', expected argument " "7"" of type '" "double""'");
 
17265
    } 
 
17266
    arg7 = static_cast< double >(val7);
 
17267
  }
 
17268
  if (obj7) {
 
17269
    ecode8 = SWIG_AsVal_double(obj7, &val8);
 
17270
    if (!SWIG_IsOK(ecode8)) {
 
17271
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SpinCtrlDouble" "', expected argument " "8"" of type '" "double""'");
 
17272
    } 
 
17273
    arg8 = static_cast< double >(val8);
 
17274
  }
 
17275
  if (obj8) {
 
17276
    ecode9 = SWIG_AsVal_double(obj8, &val9);
 
17277
    if (!SWIG_IsOK(ecode9)) {
 
17278
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpinCtrlDouble" "', expected argument " "9"" of type '" "double""'");
 
17279
    } 
 
17280
    arg9 = static_cast< double >(val9);
 
17281
  }
 
17282
  if (obj9) {
 
17283
    ecode10 = SWIG_AsVal_double(obj9, &val10);
 
17284
    if (!SWIG_IsOK(ecode10)) {
 
17285
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SpinCtrlDouble" "', expected argument " "10"" of type '" "double""'");
 
17286
    } 
 
17287
    arg10 = static_cast< double >(val10);
 
17288
  }
 
17289
  if (obj10) {
 
17290
    {
 
17291
      arg11 = wxString_in_helper(obj10);
 
17292
      if (arg11 == NULL) SWIG_fail;
 
17293
      temp11 = true;
 
17294
    }
 
17295
  }
 
17296
  {
 
17297
    if (!wxPyCheckForApp()) SWIG_fail;
 
17298
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17299
    result = (wxSpinCtrlDouble *)new wxSpinCtrlDouble(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,arg7,arg8,arg9,arg10,(wxString const &)*arg11);
 
17300
    wxPyEndAllowThreads(__tstate);
 
17301
    if (PyErr_Occurred()) SWIG_fail;
 
17302
  }
 
17303
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSpinCtrlDouble, SWIG_POINTER_NEW |  0 );
 
17304
  {
 
17305
    if (temp3)
 
17306
    delete arg3;
 
17307
  }
 
17308
  {
 
17309
    if (temp11)
 
17310
    delete arg11;
 
17311
  }
 
17312
  return resultobj;
 
17313
fail:
 
17314
  {
 
17315
    if (temp3)
 
17316
    delete arg3;
 
17317
  }
 
17318
  {
 
17319
    if (temp11)
 
17320
    delete arg11;
 
17321
  }
 
17322
  return NULL;
 
17323
}
 
17324
 
 
17325
 
 
17326
SWIGINTERN PyObject *_wrap_new_PreSpinCtrlDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17327
  PyObject *resultobj = 0;
 
17328
  wxSpinCtrlDouble *result = 0 ;
 
17329
  
 
17330
  if (!SWIG_Python_UnpackTuple(args,"new_PreSpinCtrlDouble",0,0,0)) SWIG_fail;
 
17331
  {
 
17332
    if (!wxPyCheckForApp()) SWIG_fail;
 
17333
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17334
    result = (wxSpinCtrlDouble *)new wxSpinCtrlDouble();
 
17335
    wxPyEndAllowThreads(__tstate);
 
17336
    if (PyErr_Occurred()) SWIG_fail;
 
17337
  }
 
17338
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSpinCtrlDouble, SWIG_POINTER_OWN |  0 );
 
17339
  return resultobj;
 
17340
fail:
 
17341
  return NULL;
 
17342
}
 
17343
 
 
17344
 
 
17345
SWIGINTERN PyObject *_wrap_SpinCtrlDouble_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17346
  PyObject *resultobj = 0;
 
17347
  wxSpinCtrlDouble *arg1 = (wxSpinCtrlDouble *) 0 ;
 
17348
  wxWindow *arg2 = (wxWindow *) 0 ;
 
17349
  int arg3 = (int) wxID_ANY ;
 
17350
  wxString const &arg4_defvalue = wxEmptyString ;
 
17351
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
17352
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
17353
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
17354
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
17355
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
17356
  long arg7 = (long) wxSP_ARROW_KEYS ;
 
17357
  double arg8 = (double) 0 ;
 
17358
  double arg9 = (double) 100 ;
 
17359
  double arg10 = (double) 0 ;
 
17360
  double arg11 = (double) 1 ;
 
17361
  wxString const &arg12_defvalue = "wxSpinCtrlDouble" ;
 
17362
  wxString *arg12 = (wxString *) &arg12_defvalue ;
 
17363
  bool result;
 
17364
  void *argp1 = 0 ;
 
17365
  int res1 = 0 ;
 
17366
  void *argp2 = 0 ;
 
17367
  int res2 = 0 ;
 
17368
  int val3 ;
 
17369
  int ecode3 = 0 ;
 
17370
  bool temp4 = false ;
 
17371
  wxPoint temp5 ;
 
17372
  wxSize temp6 ;
 
17373
  long val7 ;
 
17374
  int ecode7 = 0 ;
 
17375
  double val8 ;
 
17376
  int ecode8 = 0 ;
 
17377
  double val9 ;
 
17378
  int ecode9 = 0 ;
 
17379
  double val10 ;
 
17380
  int ecode10 = 0 ;
 
17381
  double val11 ;
 
17382
  int ecode11 = 0 ;
 
17383
  bool temp12 = false ;
 
17384
  PyObject * obj0 = 0 ;
 
17385
  PyObject * obj1 = 0 ;
 
17386
  PyObject * obj2 = 0 ;
 
17387
  PyObject * obj3 = 0 ;
 
17388
  PyObject * obj4 = 0 ;
 
17389
  PyObject * obj5 = 0 ;
 
17390
  PyObject * obj6 = 0 ;
 
17391
  PyObject * obj7 = 0 ;
 
17392
  PyObject * obj8 = 0 ;
 
17393
  PyObject * obj9 = 0 ;
 
17394
  PyObject * obj10 = 0 ;
 
17395
  PyObject * obj11 = 0 ;
 
17396
  char *  kwnames[] = {
 
17397
    (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "min",(char *) "max",(char *) "initial",(char *) "inc",(char *) "name", NULL 
 
17398
  };
 
17399
  
 
17400
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOOO:SpinCtrlDouble_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
 
17401
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinCtrlDouble, 0 |  0 );
 
17402
  if (!SWIG_IsOK(res1)) {
 
17403
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrlDouble_Create" "', expected argument " "1"" of type '" "wxSpinCtrlDouble *""'"); 
 
17404
  }
 
17405
  arg1 = reinterpret_cast< wxSpinCtrlDouble * >(argp1);
 
17406
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
17407
  if (!SWIG_IsOK(res2)) {
 
17408
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpinCtrlDouble_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
17409
  }
 
17410
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
17411
  if (obj2) {
 
17412
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
17413
    if (!SWIG_IsOK(ecode3)) {
 
17414
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpinCtrlDouble_Create" "', expected argument " "3"" of type '" "int""'");
 
17415
    } 
 
17416
    arg3 = static_cast< int >(val3);
 
17417
  }
 
17418
  if (obj3) {
 
17419
    {
 
17420
      arg4 = wxString_in_helper(obj3);
 
17421
      if (arg4 == NULL) SWIG_fail;
 
17422
      temp4 = true;
 
17423
    }
 
17424
  }
 
17425
  if (obj4) {
 
17426
    {
 
17427
      arg5 = &temp5;
 
17428
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
17429
    }
 
17430
  }
 
17431
  if (obj5) {
 
17432
    {
 
17433
      arg6 = &temp6;
 
17434
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
17435
    }
 
17436
  }
 
17437
  if (obj6) {
 
17438
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
17439
    if (!SWIG_IsOK(ecode7)) {
 
17440
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpinCtrlDouble_Create" "', expected argument " "7"" of type '" "long""'");
 
17441
    } 
 
17442
    arg7 = static_cast< long >(val7);
 
17443
  }
 
17444
  if (obj7) {
 
17445
    ecode8 = SWIG_AsVal_double(obj7, &val8);
 
17446
    if (!SWIG_IsOK(ecode8)) {
 
17447
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SpinCtrlDouble_Create" "', expected argument " "8"" of type '" "double""'");
 
17448
    } 
 
17449
    arg8 = static_cast< double >(val8);
 
17450
  }
 
17451
  if (obj8) {
 
17452
    ecode9 = SWIG_AsVal_double(obj8, &val9);
 
17453
    if (!SWIG_IsOK(ecode9)) {
 
17454
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SpinCtrlDouble_Create" "', expected argument " "9"" of type '" "double""'");
 
17455
    } 
 
17456
    arg9 = static_cast< double >(val9);
 
17457
  }
 
17458
  if (obj9) {
 
17459
    ecode10 = SWIG_AsVal_double(obj9, &val10);
 
17460
    if (!SWIG_IsOK(ecode10)) {
 
17461
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SpinCtrlDouble_Create" "', expected argument " "10"" of type '" "double""'");
 
17462
    } 
 
17463
    arg10 = static_cast< double >(val10);
 
17464
  }
 
17465
  if (obj10) {
 
17466
    ecode11 = SWIG_AsVal_double(obj10, &val11);
 
17467
    if (!SWIG_IsOK(ecode11)) {
 
17468
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SpinCtrlDouble_Create" "', expected argument " "11"" of type '" "double""'");
 
17469
    } 
 
17470
    arg11 = static_cast< double >(val11);
 
17471
  }
 
17472
  if (obj11) {
 
17473
    {
 
17474
      arg12 = wxString_in_helper(obj11);
 
17475
      if (arg12 == NULL) SWIG_fail;
 
17476
      temp12 = true;
 
17477
    }
 
17478
  }
 
17479
  {
 
17480
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17481
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,arg8,arg9,arg10,arg11,(wxString const &)*arg12);
 
17482
    wxPyEndAllowThreads(__tstate);
 
17483
    if (PyErr_Occurred()) SWIG_fail;
 
17484
  }
 
17485
  {
 
17486
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
17487
  }
 
17488
  {
 
17489
    if (temp4)
 
17490
    delete arg4;
 
17491
  }
 
17492
  {
 
17493
    if (temp12)
 
17494
    delete arg12;
 
17495
  }
 
17496
  return resultobj;
 
17497
fail:
 
17498
  {
 
17499
    if (temp4)
 
17500
    delete arg4;
 
17501
  }
 
17502
  {
 
17503
    if (temp12)
 
17504
    delete arg12;
 
17505
  }
 
17506
  return NULL;
 
17507
}
 
17508
 
 
17509
 
 
17510
SWIGINTERN PyObject *_wrap_SpinCtrlDouble_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17511
  PyObject *resultobj = 0;
 
17512
  wxSpinCtrlDouble *arg1 = (wxSpinCtrlDouble *) 0 ;
 
17513
  double result;
 
17514
  void *argp1 = 0 ;
 
17515
  int res1 = 0 ;
 
17516
  PyObject *swig_obj[1] ;
 
17517
  
 
17518
  if (!args) SWIG_fail;
 
17519
  swig_obj[0] = args;
 
17520
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinCtrlDouble, 0 |  0 );
 
17521
  if (!SWIG_IsOK(res1)) {
 
17522
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrlDouble_GetValue" "', expected argument " "1"" of type '" "wxSpinCtrlDouble const *""'"); 
 
17523
  }
 
17524
  arg1 = reinterpret_cast< wxSpinCtrlDouble * >(argp1);
 
17525
  {
 
17526
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17527
    result = (double)((wxSpinCtrlDouble const *)arg1)->GetValue();
 
17528
    wxPyEndAllowThreads(__tstate);
 
17529
    if (PyErr_Occurred()) SWIG_fail;
 
17530
  }
 
17531
  resultobj = SWIG_From_double(static_cast< double >(result));
 
17532
  return resultobj;
 
17533
fail:
 
17534
  return NULL;
 
17535
}
 
17536
 
 
17537
 
 
17538
SWIGINTERN PyObject *_wrap_SpinCtrlDouble_GetMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17539
  PyObject *resultobj = 0;
 
17540
  wxSpinCtrlDouble *arg1 = (wxSpinCtrlDouble *) 0 ;
 
17541
  double result;
 
17542
  void *argp1 = 0 ;
 
17543
  int res1 = 0 ;
 
17544
  PyObject *swig_obj[1] ;
 
17545
  
 
17546
  if (!args) SWIG_fail;
 
17547
  swig_obj[0] = args;
 
17548
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinCtrlDouble, 0 |  0 );
 
17549
  if (!SWIG_IsOK(res1)) {
 
17550
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrlDouble_GetMin" "', expected argument " "1"" of type '" "wxSpinCtrlDouble const *""'"); 
 
17551
  }
 
17552
  arg1 = reinterpret_cast< wxSpinCtrlDouble * >(argp1);
 
17553
  {
 
17554
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17555
    result = (double)((wxSpinCtrlDouble const *)arg1)->GetMin();
 
17556
    wxPyEndAllowThreads(__tstate);
 
17557
    if (PyErr_Occurred()) SWIG_fail;
 
17558
  }
 
17559
  resultobj = SWIG_From_double(static_cast< double >(result));
 
17560
  return resultobj;
 
17561
fail:
 
17562
  return NULL;
 
17563
}
 
17564
 
 
17565
 
 
17566
SWIGINTERN PyObject *_wrap_SpinCtrlDouble_GetMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17567
  PyObject *resultobj = 0;
 
17568
  wxSpinCtrlDouble *arg1 = (wxSpinCtrlDouble *) 0 ;
 
17569
  double result;
 
17570
  void *argp1 = 0 ;
 
17571
  int res1 = 0 ;
 
17572
  PyObject *swig_obj[1] ;
 
17573
  
 
17574
  if (!args) SWIG_fail;
 
17575
  swig_obj[0] = args;
 
17576
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinCtrlDouble, 0 |  0 );
 
17577
  if (!SWIG_IsOK(res1)) {
 
17578
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrlDouble_GetMax" "', expected argument " "1"" of type '" "wxSpinCtrlDouble const *""'"); 
 
17579
  }
 
17580
  arg1 = reinterpret_cast< wxSpinCtrlDouble * >(argp1);
 
17581
  {
 
17582
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17583
    result = (double)((wxSpinCtrlDouble const *)arg1)->GetMax();
 
17584
    wxPyEndAllowThreads(__tstate);
 
17585
    if (PyErr_Occurred()) SWIG_fail;
 
17586
  }
 
17587
  resultobj = SWIG_From_double(static_cast< double >(result));
 
17588
  return resultobj;
 
17589
fail:
 
17590
  return NULL;
 
17591
}
 
17592
 
 
17593
 
 
17594
SWIGINTERN PyObject *_wrap_SpinCtrlDouble_GetIncrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17595
  PyObject *resultobj = 0;
 
17596
  wxSpinCtrlDouble *arg1 = (wxSpinCtrlDouble *) 0 ;
 
17597
  double result;
 
17598
  void *argp1 = 0 ;
 
17599
  int res1 = 0 ;
 
17600
  PyObject *swig_obj[1] ;
 
17601
  
 
17602
  if (!args) SWIG_fail;
 
17603
  swig_obj[0] = args;
 
17604
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinCtrlDouble, 0 |  0 );
 
17605
  if (!SWIG_IsOK(res1)) {
 
17606
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrlDouble_GetIncrement" "', expected argument " "1"" of type '" "wxSpinCtrlDouble const *""'"); 
 
17607
  }
 
17608
  arg1 = reinterpret_cast< wxSpinCtrlDouble * >(argp1);
 
17609
  {
 
17610
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17611
    result = (double)((wxSpinCtrlDouble const *)arg1)->GetIncrement();
 
17612
    wxPyEndAllowThreads(__tstate);
 
17613
    if (PyErr_Occurred()) SWIG_fail;
 
17614
  }
 
17615
  resultobj = SWIG_From_double(static_cast< double >(result));
 
17616
  return resultobj;
 
17617
fail:
 
17618
  return NULL;
 
17619
}
 
17620
 
 
17621
 
 
17622
SWIGINTERN PyObject *_wrap_SpinCtrlDouble_GetDigits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17623
  PyObject *resultobj = 0;
 
17624
  wxSpinCtrlDouble *arg1 = (wxSpinCtrlDouble *) 0 ;
 
17625
  unsigned int result;
 
17626
  void *argp1 = 0 ;
 
17627
  int res1 = 0 ;
 
17628
  PyObject *swig_obj[1] ;
 
17629
  
 
17630
  if (!args) SWIG_fail;
 
17631
  swig_obj[0] = args;
 
17632
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinCtrlDouble, 0 |  0 );
 
17633
  if (!SWIG_IsOK(res1)) {
 
17634
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrlDouble_GetDigits" "', expected argument " "1"" of type '" "wxSpinCtrlDouble const *""'"); 
 
17635
  }
 
17636
  arg1 = reinterpret_cast< wxSpinCtrlDouble * >(argp1);
 
17637
  {
 
17638
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17639
    result = (unsigned int)((wxSpinCtrlDouble const *)arg1)->GetDigits();
 
17640
    wxPyEndAllowThreads(__tstate);
 
17641
    if (PyErr_Occurred()) SWIG_fail;
 
17642
  }
 
17643
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
 
17644
  return resultobj;
 
17645
fail:
 
17646
  return NULL;
 
17647
}
 
17648
 
 
17649
 
 
17650
SWIGINTERN PyObject *_wrap_SpinCtrlDouble_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17651
  PyObject *resultobj = 0;
 
17652
  wxSpinCtrlDouble *arg1 = (wxSpinCtrlDouble *) 0 ;
 
17653
  double arg2 ;
 
17654
  void *argp1 = 0 ;
 
17655
  int res1 = 0 ;
 
17656
  double val2 ;
 
17657
  int ecode2 = 0 ;
 
17658
  PyObject * obj0 = 0 ;
 
17659
  PyObject * obj1 = 0 ;
 
17660
  char *  kwnames[] = {
 
17661
    (char *) "self",(char *) "value", NULL 
 
17662
  };
 
17663
  
 
17664
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinCtrlDouble_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
17665
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinCtrlDouble, 0 |  0 );
 
17666
  if (!SWIG_IsOK(res1)) {
 
17667
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrlDouble_SetValue" "', expected argument " "1"" of type '" "wxSpinCtrlDouble *""'"); 
 
17668
  }
 
17669
  arg1 = reinterpret_cast< wxSpinCtrlDouble * >(argp1);
 
17670
  ecode2 = SWIG_AsVal_double(obj1, &val2);
 
17671
  if (!SWIG_IsOK(ecode2)) {
 
17672
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinCtrlDouble_SetValue" "', expected argument " "2"" of type '" "double""'");
 
17673
  } 
 
17674
  arg2 = static_cast< double >(val2);
 
17675
  {
 
17676
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17677
    (arg1)->SetValue(arg2);
 
17678
    wxPyEndAllowThreads(__tstate);
 
17679
    if (PyErr_Occurred()) SWIG_fail;
 
17680
  }
 
17681
  resultobj = SWIG_Py_Void();
 
17682
  return resultobj;
 
17683
fail:
 
17684
  return NULL;
 
17685
}
 
17686
 
 
17687
 
 
17688
SWIGINTERN PyObject *_wrap_SpinCtrlDouble_SetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17689
  PyObject *resultobj = 0;
 
17690
  wxSpinCtrlDouble *arg1 = (wxSpinCtrlDouble *) 0 ;
 
17691
  double arg2 ;
 
17692
  double arg3 ;
 
17693
  void *argp1 = 0 ;
 
17694
  int res1 = 0 ;
 
17695
  double val2 ;
 
17696
  int ecode2 = 0 ;
 
17697
  double val3 ;
 
17698
  int ecode3 = 0 ;
 
17699
  PyObject * obj0 = 0 ;
 
17700
  PyObject * obj1 = 0 ;
 
17701
  PyObject * obj2 = 0 ;
 
17702
  char *  kwnames[] = {
 
17703
    (char *) "self",(char *) "minVal",(char *) "maxVal", NULL 
 
17704
  };
 
17705
  
 
17706
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SpinCtrlDouble_SetRange",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
17707
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinCtrlDouble, 0 |  0 );
 
17708
  if (!SWIG_IsOK(res1)) {
 
17709
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrlDouble_SetRange" "', expected argument " "1"" of type '" "wxSpinCtrlDouble *""'"); 
 
17710
  }
 
17711
  arg1 = reinterpret_cast< wxSpinCtrlDouble * >(argp1);
 
17712
  ecode2 = SWIG_AsVal_double(obj1, &val2);
 
17713
  if (!SWIG_IsOK(ecode2)) {
 
17714
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinCtrlDouble_SetRange" "', expected argument " "2"" of type '" "double""'");
 
17715
  } 
 
17716
  arg2 = static_cast< double >(val2);
 
17717
  ecode3 = SWIG_AsVal_double(obj2, &val3);
 
17718
  if (!SWIG_IsOK(ecode3)) {
 
17719
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpinCtrlDouble_SetRange" "', expected argument " "3"" of type '" "double""'");
 
17720
  } 
 
17721
  arg3 = static_cast< double >(val3);
 
17722
  {
 
17723
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17724
    (arg1)->SetRange(arg2,arg3);
 
17725
    wxPyEndAllowThreads(__tstate);
 
17726
    if (PyErr_Occurred()) SWIG_fail;
 
17727
  }
 
17728
  resultobj = SWIG_Py_Void();
 
17729
  return resultobj;
 
17730
fail:
 
17731
  return NULL;
 
17732
}
 
17733
 
 
17734
 
 
17735
SWIGINTERN PyObject *_wrap_SpinCtrlDouble_SetIncrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17736
  PyObject *resultobj = 0;
 
17737
  wxSpinCtrlDouble *arg1 = (wxSpinCtrlDouble *) 0 ;
 
17738
  double arg2 ;
 
17739
  void *argp1 = 0 ;
 
17740
  int res1 = 0 ;
 
17741
  double val2 ;
 
17742
  int ecode2 = 0 ;
 
17743
  PyObject * obj0 = 0 ;
 
17744
  PyObject * obj1 = 0 ;
 
17745
  char *  kwnames[] = {
 
17746
    (char *) "self",(char *) "inc", NULL 
 
17747
  };
 
17748
  
 
17749
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinCtrlDouble_SetIncrement",kwnames,&obj0,&obj1)) SWIG_fail;
 
17750
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinCtrlDouble, 0 |  0 );
 
17751
  if (!SWIG_IsOK(res1)) {
 
17752
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrlDouble_SetIncrement" "', expected argument " "1"" of type '" "wxSpinCtrlDouble *""'"); 
 
17753
  }
 
17754
  arg1 = reinterpret_cast< wxSpinCtrlDouble * >(argp1);
 
17755
  ecode2 = SWIG_AsVal_double(obj1, &val2);
 
17756
  if (!SWIG_IsOK(ecode2)) {
 
17757
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinCtrlDouble_SetIncrement" "', expected argument " "2"" of type '" "double""'");
 
17758
  } 
 
17759
  arg2 = static_cast< double >(val2);
 
17760
  {
 
17761
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17762
    (arg1)->SetIncrement(arg2);
 
17763
    wxPyEndAllowThreads(__tstate);
 
17764
    if (PyErr_Occurred()) SWIG_fail;
 
17765
  }
 
17766
  resultobj = SWIG_Py_Void();
 
17767
  return resultobj;
 
17768
fail:
 
17769
  return NULL;
 
17770
}
 
17771
 
 
17772
 
 
17773
SWIGINTERN PyObject *_wrap_SpinCtrlDouble_SetDigits(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17774
  PyObject *resultobj = 0;
 
17775
  wxSpinCtrlDouble *arg1 = (wxSpinCtrlDouble *) 0 ;
 
17776
  unsigned int arg2 ;
 
17777
  void *argp1 = 0 ;
 
17778
  int res1 = 0 ;
 
17779
  unsigned int val2 ;
 
17780
  int ecode2 = 0 ;
 
17781
  PyObject * obj0 = 0 ;
 
17782
  PyObject * obj1 = 0 ;
 
17783
  char *  kwnames[] = {
 
17784
    (char *) "self",(char *) "digits", NULL 
 
17785
  };
 
17786
  
 
17787
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinCtrlDouble_SetDigits",kwnames,&obj0,&obj1)) SWIG_fail;
 
17788
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinCtrlDouble, 0 |  0 );
 
17789
  if (!SWIG_IsOK(res1)) {
 
17790
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinCtrlDouble_SetDigits" "', expected argument " "1"" of type '" "wxSpinCtrlDouble *""'"); 
 
17791
  }
 
17792
  arg1 = reinterpret_cast< wxSpinCtrlDouble * >(argp1);
 
17793
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
17794
  if (!SWIG_IsOK(ecode2)) {
 
17795
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinCtrlDouble_SetDigits" "', expected argument " "2"" of type '" "unsigned int""'");
 
17796
  } 
 
17797
  arg2 = static_cast< unsigned int >(val2);
 
17798
  {
 
17799
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17800
    (arg1)->SetDigits(arg2);
 
17801
    wxPyEndAllowThreads(__tstate);
 
17802
    if (PyErr_Occurred()) SWIG_fail;
 
17803
  }
 
17804
  resultobj = SWIG_Py_Void();
 
17805
  return resultobj;
 
17806
fail:
 
17807
  return NULL;
 
17808
}
 
17809
 
 
17810
 
 
17811
SWIGINTERN PyObject *SpinCtrlDouble_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17812
  PyObject *obj;
 
17813
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
17814
  SWIG_TypeNewClientData(SWIGTYPE_p_wxSpinCtrlDouble, SWIG_NewClientData(obj));
 
17815
  return SWIG_Py_Void();
 
17816
}
 
17817
 
 
17818
SWIGINTERN PyObject *SpinCtrlDouble_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17819
  return SWIG_Python_InitShadowInstance(args);
 
17820
}
 
17821
 
 
17822
SWIGINTERN PyObject *_wrap_new_SpinDoubleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17823
  PyObject *resultobj = 0;
 
17824
  wxEventType arg1 = (wxEventType) wxEVT_NULL ;
 
17825
  int arg2 = (int) 0 ;
 
17826
  double arg3 = (double) 0 ;
 
17827
  wxSpinDoubleEvent *result = 0 ;
 
17828
  int val1 ;
 
17829
  int ecode1 = 0 ;
 
17830
  int val2 ;
 
17831
  int ecode2 = 0 ;
 
17832
  double val3 ;
 
17833
  int ecode3 = 0 ;
 
17834
  PyObject * obj0 = 0 ;
 
17835
  PyObject * obj1 = 0 ;
 
17836
  PyObject * obj2 = 0 ;
 
17837
  char *  kwnames[] = {
 
17838
    (char *) "commandType",(char *) "winid",(char *) "value", NULL 
 
17839
  };
 
17840
  
 
17841
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_SpinDoubleEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
17842
  if (obj0) {
 
17843
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
17844
    if (!SWIG_IsOK(ecode1)) {
 
17845
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpinDoubleEvent" "', expected argument " "1"" of type '" "wxEventType""'");
 
17846
    } 
 
17847
    arg1 = static_cast< wxEventType >(val1);
 
17848
  }
 
17849
  if (obj1) {
 
17850
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
17851
    if (!SWIG_IsOK(ecode2)) {
 
17852
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpinDoubleEvent" "', expected argument " "2"" of type '" "int""'");
 
17853
    } 
 
17854
    arg2 = static_cast< int >(val2);
 
17855
  }
 
17856
  if (obj2) {
 
17857
    ecode3 = SWIG_AsVal_double(obj2, &val3);
 
17858
    if (!SWIG_IsOK(ecode3)) {
 
17859
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpinDoubleEvent" "', expected argument " "3"" of type '" "double""'");
 
17860
    } 
 
17861
    arg3 = static_cast< double >(val3);
 
17862
  }
 
17863
  {
 
17864
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17865
    result = (wxSpinDoubleEvent *)new wxSpinDoubleEvent(arg1,arg2,arg3);
 
17866
    wxPyEndAllowThreads(__tstate);
 
17867
    if (PyErr_Occurred()) SWIG_fail;
 
17868
  }
 
17869
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSpinDoubleEvent, SWIG_POINTER_NEW |  0 );
 
17870
  return resultobj;
 
17871
fail:
 
17872
  return NULL;
 
17873
}
 
17874
 
 
17875
 
 
17876
SWIGINTERN PyObject *_wrap_SpinDoubleEvent_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17877
  PyObject *resultobj = 0;
 
17878
  wxSpinDoubleEvent *arg1 = (wxSpinDoubleEvent *) 0 ;
 
17879
  double result;
 
17880
  void *argp1 = 0 ;
 
17881
  int res1 = 0 ;
 
17882
  PyObject *swig_obj[1] ;
 
17883
  
 
17884
  if (!args) SWIG_fail;
 
17885
  swig_obj[0] = args;
 
17886
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSpinDoubleEvent, 0 |  0 );
 
17887
  if (!SWIG_IsOK(res1)) {
 
17888
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinDoubleEvent_GetValue" "', expected argument " "1"" of type '" "wxSpinDoubleEvent const *""'"); 
 
17889
  }
 
17890
  arg1 = reinterpret_cast< wxSpinDoubleEvent * >(argp1);
 
17891
  {
 
17892
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17893
    result = (double)((wxSpinDoubleEvent const *)arg1)->GetValue();
 
17894
    wxPyEndAllowThreads(__tstate);
 
17895
    if (PyErr_Occurred()) SWIG_fail;
 
17896
  }
 
17897
  resultobj = SWIG_From_double(static_cast< double >(result));
 
17898
  return resultobj;
 
17899
fail:
 
17900
  return NULL;
 
17901
}
 
17902
 
 
17903
 
 
17904
SWIGINTERN PyObject *_wrap_SpinDoubleEvent_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17905
  PyObject *resultobj = 0;
 
17906
  wxSpinDoubleEvent *arg1 = (wxSpinDoubleEvent *) 0 ;
 
17907
  double arg2 ;
 
17908
  void *argp1 = 0 ;
 
17909
  int res1 = 0 ;
 
17910
  double val2 ;
 
17911
  int ecode2 = 0 ;
 
17912
  PyObject * obj0 = 0 ;
 
17913
  PyObject * obj1 = 0 ;
 
17914
  char *  kwnames[] = {
 
17915
    (char *) "self",(char *) "value", NULL 
 
17916
  };
 
17917
  
 
17918
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SpinDoubleEvent_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
17919
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSpinDoubleEvent, 0 |  0 );
 
17920
  if (!SWIG_IsOK(res1)) {
 
17921
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpinDoubleEvent_SetValue" "', expected argument " "1"" of type '" "wxSpinDoubleEvent *""'"); 
 
17922
  }
 
17923
  arg1 = reinterpret_cast< wxSpinDoubleEvent * >(argp1);
 
17924
  ecode2 = SWIG_AsVal_double(obj1, &val2);
 
17925
  if (!SWIG_IsOK(ecode2)) {
 
17926
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpinDoubleEvent_SetValue" "', expected argument " "2"" of type '" "double""'");
 
17927
  } 
 
17928
  arg2 = static_cast< double >(val2);
 
17929
  {
 
17930
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
17931
    (arg1)->SetValue(arg2);
 
17932
    wxPyEndAllowThreads(__tstate);
 
17933
    if (PyErr_Occurred()) SWIG_fail;
 
17934
  }
 
17935
  resultobj = SWIG_Py_Void();
 
17936
  return resultobj;
 
17937
fail:
 
17938
  return NULL;
 
17939
}
 
17940
 
 
17941
 
 
17942
SWIGINTERN PyObject *SpinDoubleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17943
  PyObject *obj;
 
17944
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
17945
  SWIG_TypeNewClientData(SWIGTYPE_p_wxSpinDoubleEvent, SWIG_NewClientData(obj));
 
17946
  return SWIG_Py_Void();
 
17947
}
 
17948
 
 
17949
SWIGINTERN PyObject *SpinDoubleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
17950
  return SWIG_Python_InitShadowInstance(args);
 
17951
}
 
17952
 
 
17953
SWIGINTERN int RadioBoxNameStr_set(PyObject *) {
 
17954
  SWIG_Error(SWIG_AttributeError,"Variable RadioBoxNameStr is read-only.");
 
17955
  return 1;
 
17956
}
 
17957
 
 
17958
 
 
17959
SWIGINTERN PyObject *RadioBoxNameStr_get(void) {
 
17960
  PyObject *pyobj = 0;
 
17961
  
 
17962
  {
 
17963
#if wxUSE_UNICODE
 
17964
    pyobj = PyUnicode_FromWideChar((&wxPyRadioBoxNameStr)->c_str(), (&wxPyRadioBoxNameStr)->Len());
 
17965
#else
 
17966
    pyobj = PyString_FromStringAndSize((&wxPyRadioBoxNameStr)->c_str(), (&wxPyRadioBoxNameStr)->Len());
 
17967
#endif
 
17968
  }
 
17969
  return pyobj;
 
17970
}
 
17971
 
 
17972
 
 
17973
SWIGINTERN int RadioButtonNameStr_set(PyObject *) {
 
17974
  SWIG_Error(SWIG_AttributeError,"Variable RadioButtonNameStr is read-only.");
 
17975
  return 1;
 
17976
}
 
17977
 
 
17978
 
 
17979
SWIGINTERN PyObject *RadioButtonNameStr_get(void) {
 
17980
  PyObject *pyobj = 0;
 
17981
  
 
17982
  {
 
17983
#if wxUSE_UNICODE
 
17984
    pyobj = PyUnicode_FromWideChar((&wxPyRadioButtonNameStr)->c_str(), (&wxPyRadioButtonNameStr)->Len());
 
17985
#else
 
17986
    pyobj = PyString_FromStringAndSize((&wxPyRadioButtonNameStr)->c_str(), (&wxPyRadioButtonNameStr)->Len());
 
17987
#endif
 
17988
  }
 
17989
  return pyobj;
 
17990
}
 
17991
 
 
17992
 
 
17993
SWIGINTERN PyObject *_wrap_new_RadioBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
17994
  PyObject *resultobj = 0;
 
17995
  wxWindow *arg1 = (wxWindow *) 0 ;
 
17996
  int arg2 = (int) -1 ;
 
17997
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
17998
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
17999
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
18000
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
18001
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
18002
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
18003
  wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;
 
18004
  wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;
 
18005
  int arg7 = (int) 0 ;
 
18006
  long arg8 = (long) wxRA_HORIZONTAL ;
 
18007
  wxValidator const &arg9_defvalue = wxDefaultValidator ;
 
18008
  wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
 
18009
  wxString const &arg10_defvalue = wxPyRadioBoxNameStr ;
 
18010
  wxString *arg10 = (wxString *) &arg10_defvalue ;
 
18011
  wxRadioBox *result = 0 ;
 
18012
  void *argp1 = 0 ;
 
18013
  int res1 = 0 ;
 
18014
  int val2 ;
 
18015
  int ecode2 = 0 ;
 
18016
  bool temp3 = false ;
 
18017
  wxPoint temp4 ;
 
18018
  wxSize temp5 ;
 
18019
  bool temp6 = false ;
 
18020
  int val7 ;
 
18021
  int ecode7 = 0 ;
 
18022
  long val8 ;
 
18023
  int ecode8 = 0 ;
 
18024
  void *argp9 = 0 ;
 
18025
  int res9 = 0 ;
 
18026
  bool temp10 = false ;
 
18027
  PyObject * obj0 = 0 ;
 
18028
  PyObject * obj1 = 0 ;
 
18029
  PyObject * obj2 = 0 ;
 
18030
  PyObject * obj3 = 0 ;
 
18031
  PyObject * obj4 = 0 ;
 
18032
  PyObject * obj5 = 0 ;
 
18033
  PyObject * obj6 = 0 ;
 
18034
  PyObject * obj7 = 0 ;
 
18035
  PyObject * obj8 = 0 ;
 
18036
  PyObject * obj9 = 0 ;
 
18037
  char *  kwnames[] = {
 
18038
    (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "choices",(char *) "majorDimension",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
18039
  };
 
18040
  
 
18041
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOO:new_RadioBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
 
18042
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
18043
  if (!SWIG_IsOK(res1)) {
 
18044
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RadioBox" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
18045
  }
 
18046
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
18047
  if (obj1) {
 
18048
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
18049
    if (!SWIG_IsOK(ecode2)) {
 
18050
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RadioBox" "', expected argument " "2"" of type '" "int""'");
 
18051
    } 
 
18052
    arg2 = static_cast< int >(val2);
 
18053
  }
 
18054
  if (obj2) {
 
18055
    {
 
18056
      arg3 = wxString_in_helper(obj2);
 
18057
      if (arg3 == NULL) SWIG_fail;
 
18058
      temp3 = true;
 
18059
    }
 
18060
  }
 
18061
  if (obj3) {
 
18062
    {
 
18063
      arg4 = &temp4;
 
18064
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
18065
    }
 
18066
  }
 
18067
  if (obj4) {
 
18068
    {
 
18069
      arg5 = &temp5;
 
18070
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
18071
    }
 
18072
  }
 
18073
  if (obj5) {
 
18074
    {
 
18075
      if (! PySequence_Check(obj5)) {
 
18076
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
18077
        SWIG_fail;
 
18078
      }
 
18079
      arg6 = new wxArrayString;
 
18080
      temp6 = true;
 
18081
      int i, len=PySequence_Length(obj5);
 
18082
      for (i=0; i<len; i++) {
 
18083
        PyObject* item = PySequence_GetItem(obj5, i);
 
18084
        wxString* s = wxString_in_helper(item);
 
18085
        if (PyErr_Occurred())  SWIG_fail;
 
18086
        arg6->Add(*s);
 
18087
        delete s;
 
18088
        Py_DECREF(item);
 
18089
      }
 
18090
    }
 
18091
  }
 
18092
  if (obj6) {
 
18093
    ecode7 = SWIG_AsVal_int(obj6, &val7);
 
18094
    if (!SWIG_IsOK(ecode7)) {
 
18095
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RadioBox" "', expected argument " "7"" of type '" "int""'");
 
18096
    } 
 
18097
    arg7 = static_cast< int >(val7);
 
18098
  }
 
18099
  if (obj7) {
 
18100
    ecode8 = SWIG_AsVal_long(obj7, &val8);
 
18101
    if (!SWIG_IsOK(ecode8)) {
 
18102
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_RadioBox" "', expected argument " "8"" of type '" "long""'");
 
18103
    } 
 
18104
    arg8 = static_cast< long >(val8);
 
18105
  }
 
18106
  if (obj8) {
 
18107
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_wxValidator,  0  | 0);
 
18108
    if (!SWIG_IsOK(res9)) {
 
18109
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_RadioBox" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
18110
    }
 
18111
    if (!argp9) {
 
18112
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RadioBox" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
18113
    }
 
18114
    arg9 = reinterpret_cast< wxValidator * >(argp9);
 
18115
  }
 
18116
  if (obj9) {
 
18117
    {
 
18118
      arg10 = wxString_in_helper(obj9);
 
18119
      if (arg10 == NULL) SWIG_fail;
 
18120
      temp10 = true;
 
18121
    }
 
18122
  }
 
18123
  {
 
18124
    if (!wxPyCheckForApp()) SWIG_fail;
 
18125
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18126
    result = (wxRadioBox *)new wxRadioBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);
 
18127
    wxPyEndAllowThreads(__tstate);
 
18128
    if (PyErr_Occurred()) SWIG_fail;
 
18129
  }
 
18130
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRadioBox, SWIG_POINTER_NEW |  0 );
 
18131
  {
 
18132
    if (temp3)
 
18133
    delete arg3;
 
18134
  }
 
18135
  {
 
18136
    if (temp6) delete arg6;
 
18137
  }
 
18138
  {
 
18139
    if (temp10)
 
18140
    delete arg10;
 
18141
  }
 
18142
  return resultobj;
 
18143
fail:
 
18144
  {
 
18145
    if (temp3)
 
18146
    delete arg3;
 
18147
  }
 
18148
  {
 
18149
    if (temp6) delete arg6;
 
18150
  }
 
18151
  {
 
18152
    if (temp10)
 
18153
    delete arg10;
 
18154
  }
 
18155
  return NULL;
 
18156
}
 
18157
 
 
18158
 
 
18159
SWIGINTERN PyObject *_wrap_new_PreRadioBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
18160
  PyObject *resultobj = 0;
 
18161
  wxRadioBox *result = 0 ;
 
18162
  
 
18163
  if (!SWIG_Python_UnpackTuple(args,"new_PreRadioBox",0,0,0)) SWIG_fail;
 
18164
  {
 
18165
    if (!wxPyCheckForApp()) SWIG_fail;
 
18166
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18167
    result = (wxRadioBox *)new wxRadioBox();
 
18168
    wxPyEndAllowThreads(__tstate);
 
18169
    if (PyErr_Occurred()) SWIG_fail;
 
18170
  }
 
18171
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRadioBox, SWIG_POINTER_OWN |  0 );
 
18172
  return resultobj;
 
18173
fail:
 
18174
  return NULL;
 
18175
}
 
18176
 
 
18177
 
 
18178
SWIGINTERN PyObject *_wrap_RadioBox_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18179
  PyObject *resultobj = 0;
 
18180
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18181
  wxWindow *arg2 = (wxWindow *) 0 ;
 
18182
  int arg3 = (int) -1 ;
 
18183
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
18184
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
18185
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
18186
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
18187
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
18188
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
18189
  wxArrayString const &arg7_defvalue = wxPyEmptyStringArray ;
 
18190
  wxArrayString *arg7 = (wxArrayString *) &arg7_defvalue ;
 
18191
  int arg8 = (int) 0 ;
 
18192
  long arg9 = (long) wxRA_HORIZONTAL ;
 
18193
  wxValidator const &arg10_defvalue = wxDefaultValidator ;
 
18194
  wxValidator *arg10 = (wxValidator *) &arg10_defvalue ;
 
18195
  wxString const &arg11_defvalue = wxPyRadioBoxNameStr ;
 
18196
  wxString *arg11 = (wxString *) &arg11_defvalue ;
 
18197
  bool result;
 
18198
  void *argp1 = 0 ;
 
18199
  int res1 = 0 ;
 
18200
  void *argp2 = 0 ;
 
18201
  int res2 = 0 ;
 
18202
  int val3 ;
 
18203
  int ecode3 = 0 ;
 
18204
  bool temp4 = false ;
 
18205
  wxPoint temp5 ;
 
18206
  wxSize temp6 ;
 
18207
  bool temp7 = false ;
 
18208
  int val8 ;
 
18209
  int ecode8 = 0 ;
 
18210
  long val9 ;
 
18211
  int ecode9 = 0 ;
 
18212
  void *argp10 = 0 ;
 
18213
  int res10 = 0 ;
 
18214
  bool temp11 = false ;
 
18215
  PyObject * obj0 = 0 ;
 
18216
  PyObject * obj1 = 0 ;
 
18217
  PyObject * obj2 = 0 ;
 
18218
  PyObject * obj3 = 0 ;
 
18219
  PyObject * obj4 = 0 ;
 
18220
  PyObject * obj5 = 0 ;
 
18221
  PyObject * obj6 = 0 ;
 
18222
  PyObject * obj7 = 0 ;
 
18223
  PyObject * obj8 = 0 ;
 
18224
  PyObject * obj9 = 0 ;
 
18225
  PyObject * obj10 = 0 ;
 
18226
  char *  kwnames[] = {
 
18227
    (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "choices",(char *) "majorDimension",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
18228
  };
 
18229
  
 
18230
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOO:RadioBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
 
18231
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18232
  if (!SWIG_IsOK(res1)) {
 
18233
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_Create" "', expected argument " "1"" of type '" "wxRadioBox *""'"); 
 
18234
  }
 
18235
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18236
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
18237
  if (!SWIG_IsOK(res2)) {
 
18238
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RadioBox_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
18239
  }
 
18240
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
18241
  if (obj2) {
 
18242
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
18243
    if (!SWIG_IsOK(ecode3)) {
 
18244
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RadioBox_Create" "', expected argument " "3"" of type '" "int""'");
 
18245
    } 
 
18246
    arg3 = static_cast< int >(val3);
 
18247
  }
 
18248
  if (obj3) {
 
18249
    {
 
18250
      arg4 = wxString_in_helper(obj3);
 
18251
      if (arg4 == NULL) SWIG_fail;
 
18252
      temp4 = true;
 
18253
    }
 
18254
  }
 
18255
  if (obj4) {
 
18256
    {
 
18257
      arg5 = &temp5;
 
18258
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
18259
    }
 
18260
  }
 
18261
  if (obj5) {
 
18262
    {
 
18263
      arg6 = &temp6;
 
18264
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
18265
    }
 
18266
  }
 
18267
  if (obj6) {
 
18268
    {
 
18269
      if (! PySequence_Check(obj6)) {
 
18270
        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
18271
        SWIG_fail;
 
18272
      }
 
18273
      arg7 = new wxArrayString;
 
18274
      temp7 = true;
 
18275
      int i, len=PySequence_Length(obj6);
 
18276
      for (i=0; i<len; i++) {
 
18277
        PyObject* item = PySequence_GetItem(obj6, i);
 
18278
        wxString* s = wxString_in_helper(item);
 
18279
        if (PyErr_Occurred())  SWIG_fail;
 
18280
        arg7->Add(*s);
 
18281
        delete s;
 
18282
        Py_DECREF(item);
 
18283
      }
 
18284
    }
 
18285
  }
 
18286
  if (obj7) {
 
18287
    ecode8 = SWIG_AsVal_int(obj7, &val8);
 
18288
    if (!SWIG_IsOK(ecode8)) {
 
18289
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "RadioBox_Create" "', expected argument " "8"" of type '" "int""'");
 
18290
    } 
 
18291
    arg8 = static_cast< int >(val8);
 
18292
  }
 
18293
  if (obj8) {
 
18294
    ecode9 = SWIG_AsVal_long(obj8, &val9);
 
18295
    if (!SWIG_IsOK(ecode9)) {
 
18296
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "RadioBox_Create" "', expected argument " "9"" of type '" "long""'");
 
18297
    } 
 
18298
    arg9 = static_cast< long >(val9);
 
18299
  }
 
18300
  if (obj9) {
 
18301
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_wxValidator,  0  | 0);
 
18302
    if (!SWIG_IsOK(res10)) {
 
18303
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "RadioBox_Create" "', expected argument " "10"" of type '" "wxValidator const &""'"); 
 
18304
    }
 
18305
    if (!argp10) {
 
18306
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RadioBox_Create" "', expected argument " "10"" of type '" "wxValidator const &""'"); 
 
18307
    }
 
18308
    arg10 = reinterpret_cast< wxValidator * >(argp10);
 
18309
  }
 
18310
  if (obj10) {
 
18311
    {
 
18312
      arg11 = wxString_in_helper(obj10);
 
18313
      if (arg11 == NULL) SWIG_fail;
 
18314
      temp11 = true;
 
18315
    }
 
18316
  }
 
18317
  {
 
18318
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18319
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,(wxArrayString const &)*arg7,arg8,arg9,(wxValidator const &)*arg10,(wxString const &)*arg11);
 
18320
    wxPyEndAllowThreads(__tstate);
 
18321
    if (PyErr_Occurred()) SWIG_fail;
 
18322
  }
 
18323
  {
 
18324
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
18325
  }
 
18326
  {
 
18327
    if (temp4)
 
18328
    delete arg4;
 
18329
  }
 
18330
  {
 
18331
    if (temp7) delete arg7;
 
18332
  }
 
18333
  {
 
18334
    if (temp11)
 
18335
    delete arg11;
 
18336
  }
 
18337
  return resultobj;
 
18338
fail:
 
18339
  {
 
18340
    if (temp4)
 
18341
    delete arg4;
 
18342
  }
 
18343
  {
 
18344
    if (temp7) delete arg7;
 
18345
  }
 
18346
  {
 
18347
    if (temp11)
 
18348
    delete arg11;
 
18349
  }
 
18350
  return NULL;
 
18351
}
 
18352
 
 
18353
 
 
18354
SWIGINTERN PyObject *_wrap_RadioBox_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18355
  PyObject *resultobj = 0;
 
18356
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18357
  int arg2 ;
 
18358
  void *argp1 = 0 ;
 
18359
  int res1 = 0 ;
 
18360
  int val2 ;
 
18361
  int ecode2 = 0 ;
 
18362
  PyObject * obj0 = 0 ;
 
18363
  PyObject * obj1 = 0 ;
 
18364
  char *  kwnames[] = {
 
18365
    (char *) "self",(char *) "n", NULL 
 
18366
  };
 
18367
  
 
18368
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
 
18369
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18370
  if (!SWIG_IsOK(res1)) {
 
18371
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_SetSelection" "', expected argument " "1"" of type '" "wxRadioBox *""'"); 
 
18372
  }
 
18373
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18374
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
18375
  if (!SWIG_IsOK(ecode2)) {
 
18376
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_SetSelection" "', expected argument " "2"" of type '" "int""'");
 
18377
  } 
 
18378
  arg2 = static_cast< int >(val2);
 
18379
  {
 
18380
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18381
    (arg1)->SetSelection(arg2);
 
18382
    wxPyEndAllowThreads(__tstate);
 
18383
    if (PyErr_Occurred()) SWIG_fail;
 
18384
  }
 
18385
  resultobj = SWIG_Py_Void();
 
18386
  return resultobj;
 
18387
fail:
 
18388
  return NULL;
 
18389
}
 
18390
 
 
18391
 
 
18392
SWIGINTERN PyObject *_wrap_RadioBox_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
18393
  PyObject *resultobj = 0;
 
18394
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18395
  int result;
 
18396
  void *argp1 = 0 ;
 
18397
  int res1 = 0 ;
 
18398
  PyObject *swig_obj[1] ;
 
18399
  
 
18400
  if (!args) SWIG_fail;
 
18401
  swig_obj[0] = args;
 
18402
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18403
  if (!SWIG_IsOK(res1)) {
 
18404
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_GetSelection" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
18405
  }
 
18406
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18407
  {
 
18408
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18409
    result = (int)((wxRadioBox const *)arg1)->GetSelection();
 
18410
    wxPyEndAllowThreads(__tstate);
 
18411
    if (PyErr_Occurred()) SWIG_fail;
 
18412
  }
 
18413
  resultobj = SWIG_From_int(static_cast< int >(result));
 
18414
  return resultobj;
 
18415
fail:
 
18416
  return NULL;
 
18417
}
 
18418
 
 
18419
 
 
18420
SWIGINTERN PyObject *_wrap_RadioBox_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
18421
  PyObject *resultobj = 0;
 
18422
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18423
  wxString result;
 
18424
  void *argp1 = 0 ;
 
18425
  int res1 = 0 ;
 
18426
  PyObject *swig_obj[1] ;
 
18427
  
 
18428
  if (!args) SWIG_fail;
 
18429
  swig_obj[0] = args;
 
18430
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18431
  if (!SWIG_IsOK(res1)) {
 
18432
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_GetStringSelection" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
18433
  }
 
18434
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18435
  {
 
18436
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18437
    result = ((wxRadioBox const *)arg1)->GetStringSelection();
 
18438
    wxPyEndAllowThreads(__tstate);
 
18439
    if (PyErr_Occurred()) SWIG_fail;
 
18440
  }
 
18441
  {
 
18442
#if wxUSE_UNICODE
 
18443
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
18444
#else
 
18445
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
18446
#endif
 
18447
  }
 
18448
  return resultobj;
 
18449
fail:
 
18450
  return NULL;
 
18451
}
 
18452
 
 
18453
 
 
18454
SWIGINTERN PyObject *_wrap_RadioBox_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18455
  PyObject *resultobj = 0;
 
18456
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18457
  wxString *arg2 = 0 ;
 
18458
  bool result;
 
18459
  void *argp1 = 0 ;
 
18460
  int res1 = 0 ;
 
18461
  bool temp2 = false ;
 
18462
  PyObject * obj0 = 0 ;
 
18463
  PyObject * obj1 = 0 ;
 
18464
  char *  kwnames[] = {
 
18465
    (char *) "self",(char *) "s", NULL 
 
18466
  };
 
18467
  
 
18468
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
 
18469
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18470
  if (!SWIG_IsOK(res1)) {
 
18471
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_SetStringSelection" "', expected argument " "1"" of type '" "wxRadioBox *""'"); 
 
18472
  }
 
18473
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18474
  {
 
18475
    arg2 = wxString_in_helper(obj1);
 
18476
    if (arg2 == NULL) SWIG_fail;
 
18477
    temp2 = true;
 
18478
  }
 
18479
  {
 
18480
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18481
    result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
 
18482
    wxPyEndAllowThreads(__tstate);
 
18483
    if (PyErr_Occurred()) SWIG_fail;
 
18484
  }
 
18485
  {
 
18486
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
18487
  }
 
18488
  {
 
18489
    if (temp2)
 
18490
    delete arg2;
 
18491
  }
 
18492
  return resultobj;
 
18493
fail:
 
18494
  {
 
18495
    if (temp2)
 
18496
    delete arg2;
 
18497
  }
 
18498
  return NULL;
 
18499
}
 
18500
 
 
18501
 
 
18502
SWIGINTERN PyObject *_wrap_RadioBox_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
18503
  PyObject *resultobj = 0;
 
18504
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18505
  size_t result;
 
18506
  void *argp1 = 0 ;
 
18507
  int res1 = 0 ;
 
18508
  PyObject *swig_obj[1] ;
 
18509
  
 
18510
  if (!args) SWIG_fail;
 
18511
  swig_obj[0] = args;
 
18512
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18513
  if (!SWIG_IsOK(res1)) {
 
18514
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_GetCount" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
18515
  }
 
18516
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18517
  {
 
18518
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18519
    result = (size_t)((wxRadioBox const *)arg1)->GetCount();
 
18520
    wxPyEndAllowThreads(__tstate);
 
18521
    if (PyErr_Occurred()) SWIG_fail;
 
18522
  }
 
18523
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
 
18524
  return resultobj;
 
18525
fail:
 
18526
  return NULL;
 
18527
}
 
18528
 
 
18529
 
 
18530
SWIGINTERN PyObject *_wrap_RadioBox_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18531
  PyObject *resultobj = 0;
 
18532
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18533
  wxString *arg2 = 0 ;
 
18534
  int result;
 
18535
  void *argp1 = 0 ;
 
18536
  int res1 = 0 ;
 
18537
  bool temp2 = false ;
 
18538
  PyObject * obj0 = 0 ;
 
18539
  PyObject * obj1 = 0 ;
 
18540
  char *  kwnames[] = {
 
18541
    (char *) "self",(char *) "s", NULL 
 
18542
  };
 
18543
  
 
18544
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
 
18545
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18546
  if (!SWIG_IsOK(res1)) {
 
18547
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_FindString" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
18548
  }
 
18549
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18550
  {
 
18551
    arg2 = wxString_in_helper(obj1);
 
18552
    if (arg2 == NULL) SWIG_fail;
 
18553
    temp2 = true;
 
18554
  }
 
18555
  {
 
18556
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18557
    result = (int)((wxRadioBox const *)arg1)->FindString((wxString const &)*arg2);
 
18558
    wxPyEndAllowThreads(__tstate);
 
18559
    if (PyErr_Occurred()) SWIG_fail;
 
18560
  }
 
18561
  resultobj = SWIG_From_int(static_cast< int >(result));
 
18562
  {
 
18563
    if (temp2)
 
18564
    delete arg2;
 
18565
  }
 
18566
  return resultobj;
 
18567
fail:
 
18568
  {
 
18569
    if (temp2)
 
18570
    delete arg2;
 
18571
  }
 
18572
  return NULL;
 
18573
}
 
18574
 
 
18575
 
 
18576
SWIGINTERN PyObject *_wrap_RadioBox_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18577
  PyObject *resultobj = 0;
 
18578
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18579
  int arg2 ;
 
18580
  wxString result;
 
18581
  void *argp1 = 0 ;
 
18582
  int res1 = 0 ;
 
18583
  int val2 ;
 
18584
  int ecode2 = 0 ;
 
18585
  PyObject * obj0 = 0 ;
 
18586
  PyObject * obj1 = 0 ;
 
18587
  char *  kwnames[] = {
 
18588
    (char *) "self",(char *) "n", NULL 
 
18589
  };
 
18590
  
 
18591
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
 
18592
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18593
  if (!SWIG_IsOK(res1)) {
 
18594
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_GetString" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
18595
  }
 
18596
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18597
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
18598
  if (!SWIG_IsOK(ecode2)) {
 
18599
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_GetString" "', expected argument " "2"" of type '" "int""'");
 
18600
  } 
 
18601
  arg2 = static_cast< int >(val2);
 
18602
  {
 
18603
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18604
    result = ((wxRadioBox const *)arg1)->GetString(arg2);
 
18605
    wxPyEndAllowThreads(__tstate);
 
18606
    if (PyErr_Occurred()) SWIG_fail;
 
18607
  }
 
18608
  {
 
18609
#if wxUSE_UNICODE
 
18610
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
18611
#else
 
18612
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
18613
#endif
 
18614
  }
 
18615
  return resultobj;
 
18616
fail:
 
18617
  return NULL;
 
18618
}
 
18619
 
 
18620
 
 
18621
SWIGINTERN PyObject *_wrap_RadioBox_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18622
  PyObject *resultobj = 0;
 
18623
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18624
  int arg2 ;
 
18625
  wxString *arg3 = 0 ;
 
18626
  void *argp1 = 0 ;
 
18627
  int res1 = 0 ;
 
18628
  int val2 ;
 
18629
  int ecode2 = 0 ;
 
18630
  bool temp3 = false ;
 
18631
  PyObject * obj0 = 0 ;
 
18632
  PyObject * obj1 = 0 ;
 
18633
  PyObject * obj2 = 0 ;
 
18634
  char *  kwnames[] = {
 
18635
    (char *) "self",(char *) "n",(char *) "label", NULL 
 
18636
  };
 
18637
  
 
18638
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RadioBox_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
18639
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18640
  if (!SWIG_IsOK(res1)) {
 
18641
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_SetString" "', expected argument " "1"" of type '" "wxRadioBox *""'"); 
 
18642
  }
 
18643
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18644
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
18645
  if (!SWIG_IsOK(ecode2)) {
 
18646
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_SetString" "', expected argument " "2"" of type '" "int""'");
 
18647
  } 
 
18648
  arg2 = static_cast< int >(val2);
 
18649
  {
 
18650
    arg3 = wxString_in_helper(obj2);
 
18651
    if (arg3 == NULL) SWIG_fail;
 
18652
    temp3 = true;
 
18653
  }
 
18654
  {
 
18655
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18656
    (arg1)->SetString(arg2,(wxString const &)*arg3);
 
18657
    wxPyEndAllowThreads(__tstate);
 
18658
    if (PyErr_Occurred()) SWIG_fail;
 
18659
  }
 
18660
  resultobj = SWIG_Py_Void();
 
18661
  {
 
18662
    if (temp3)
 
18663
    delete arg3;
 
18664
  }
 
18665
  return resultobj;
 
18666
fail:
 
18667
  {
 
18668
    if (temp3)
 
18669
    delete arg3;
 
18670
  }
 
18671
  return NULL;
 
18672
}
 
18673
 
 
18674
 
 
18675
SWIGINTERN PyObject *_wrap_RadioBox_EnableItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18676
  PyObject *resultobj = 0;
 
18677
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18678
  unsigned int arg2 ;
 
18679
  bool arg3 = (bool) true ;
 
18680
  void *argp1 = 0 ;
 
18681
  int res1 = 0 ;
 
18682
  unsigned int val2 ;
 
18683
  int ecode2 = 0 ;
 
18684
  bool val3 ;
 
18685
  int ecode3 = 0 ;
 
18686
  PyObject * obj0 = 0 ;
 
18687
  PyObject * obj1 = 0 ;
 
18688
  PyObject * obj2 = 0 ;
 
18689
  char *  kwnames[] = {
 
18690
    (char *) "self",(char *) "n",(char *) "enable", NULL 
 
18691
  };
 
18692
  
 
18693
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RadioBox_EnableItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
18694
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18695
  if (!SWIG_IsOK(res1)) {
 
18696
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_EnableItem" "', expected argument " "1"" of type '" "wxRadioBox *""'"); 
 
18697
  }
 
18698
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18699
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
18700
  if (!SWIG_IsOK(ecode2)) {
 
18701
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_EnableItem" "', expected argument " "2"" of type '" "unsigned int""'");
 
18702
  } 
 
18703
  arg2 = static_cast< unsigned int >(val2);
 
18704
  if (obj2) {
 
18705
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
18706
    if (!SWIG_IsOK(ecode3)) {
 
18707
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RadioBox_EnableItem" "', expected argument " "3"" of type '" "bool""'");
 
18708
    } 
 
18709
    arg3 = static_cast< bool >(val3);
 
18710
  }
 
18711
  {
 
18712
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18713
    (arg1)->Enable(arg2,arg3);
 
18714
    wxPyEndAllowThreads(__tstate);
 
18715
    if (PyErr_Occurred()) SWIG_fail;
 
18716
  }
 
18717
  resultobj = SWIG_Py_Void();
 
18718
  return resultobj;
 
18719
fail:
 
18720
  return NULL;
 
18721
}
 
18722
 
 
18723
 
 
18724
SWIGINTERN PyObject *_wrap_RadioBox_ShowItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18725
  PyObject *resultobj = 0;
 
18726
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18727
  unsigned int arg2 ;
 
18728
  bool arg3 = (bool) true ;
 
18729
  void *argp1 = 0 ;
 
18730
  int res1 = 0 ;
 
18731
  unsigned int val2 ;
 
18732
  int ecode2 = 0 ;
 
18733
  bool val3 ;
 
18734
  int ecode3 = 0 ;
 
18735
  PyObject * obj0 = 0 ;
 
18736
  PyObject * obj1 = 0 ;
 
18737
  PyObject * obj2 = 0 ;
 
18738
  char *  kwnames[] = {
 
18739
    (char *) "self",(char *) "n",(char *) "show", NULL 
 
18740
  };
 
18741
  
 
18742
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RadioBox_ShowItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
18743
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18744
  if (!SWIG_IsOK(res1)) {
 
18745
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_ShowItem" "', expected argument " "1"" of type '" "wxRadioBox *""'"); 
 
18746
  }
 
18747
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18748
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
18749
  if (!SWIG_IsOK(ecode2)) {
 
18750
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_ShowItem" "', expected argument " "2"" of type '" "unsigned int""'");
 
18751
  } 
 
18752
  arg2 = static_cast< unsigned int >(val2);
 
18753
  if (obj2) {
 
18754
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
18755
    if (!SWIG_IsOK(ecode3)) {
 
18756
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RadioBox_ShowItem" "', expected argument " "3"" of type '" "bool""'");
 
18757
    } 
 
18758
    arg3 = static_cast< bool >(val3);
 
18759
  }
 
18760
  {
 
18761
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18762
    (arg1)->Show(arg2,arg3);
 
18763
    wxPyEndAllowThreads(__tstate);
 
18764
    if (PyErr_Occurred()) SWIG_fail;
 
18765
  }
 
18766
  resultobj = SWIG_Py_Void();
 
18767
  return resultobj;
 
18768
fail:
 
18769
  return NULL;
 
18770
}
 
18771
 
 
18772
 
 
18773
SWIGINTERN PyObject *_wrap_RadioBox_IsItemEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18774
  PyObject *resultobj = 0;
 
18775
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18776
  unsigned int arg2 ;
 
18777
  bool result;
 
18778
  void *argp1 = 0 ;
 
18779
  int res1 = 0 ;
 
18780
  unsigned int val2 ;
 
18781
  int ecode2 = 0 ;
 
18782
  PyObject * obj0 = 0 ;
 
18783
  PyObject * obj1 = 0 ;
 
18784
  char *  kwnames[] = {
 
18785
    (char *) "self",(char *) "n", NULL 
 
18786
  };
 
18787
  
 
18788
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_IsItemEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
 
18789
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18790
  if (!SWIG_IsOK(res1)) {
 
18791
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_IsItemEnabled" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
18792
  }
 
18793
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18794
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
18795
  if (!SWIG_IsOK(ecode2)) {
 
18796
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_IsItemEnabled" "', expected argument " "2"" of type '" "unsigned int""'");
 
18797
  } 
 
18798
  arg2 = static_cast< unsigned int >(val2);
 
18799
  {
 
18800
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18801
    result = (bool)((wxRadioBox const *)arg1)->IsItemEnabled(arg2);
 
18802
    wxPyEndAllowThreads(__tstate);
 
18803
    if (PyErr_Occurred()) SWIG_fail;
 
18804
  }
 
18805
  {
 
18806
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
18807
  }
 
18808
  return resultobj;
 
18809
fail:
 
18810
  return NULL;
 
18811
}
 
18812
 
 
18813
 
 
18814
SWIGINTERN PyObject *_wrap_RadioBox_IsItemShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18815
  PyObject *resultobj = 0;
 
18816
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18817
  unsigned int arg2 ;
 
18818
  bool result;
 
18819
  void *argp1 = 0 ;
 
18820
  int res1 = 0 ;
 
18821
  unsigned int val2 ;
 
18822
  int ecode2 = 0 ;
 
18823
  PyObject * obj0 = 0 ;
 
18824
  PyObject * obj1 = 0 ;
 
18825
  char *  kwnames[] = {
 
18826
    (char *) "self",(char *) "n", NULL 
 
18827
  };
 
18828
  
 
18829
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_IsItemShown",kwnames,&obj0,&obj1)) SWIG_fail;
 
18830
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18831
  if (!SWIG_IsOK(res1)) {
 
18832
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_IsItemShown" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
18833
  }
 
18834
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18835
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
18836
  if (!SWIG_IsOK(ecode2)) {
 
18837
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_IsItemShown" "', expected argument " "2"" of type '" "unsigned int""'");
 
18838
  } 
 
18839
  arg2 = static_cast< unsigned int >(val2);
 
18840
  {
 
18841
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18842
    result = (bool)((wxRadioBox const *)arg1)->IsItemShown(arg2);
 
18843
    wxPyEndAllowThreads(__tstate);
 
18844
    if (PyErr_Occurred()) SWIG_fail;
 
18845
  }
 
18846
  {
 
18847
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
18848
  }
 
18849
  return resultobj;
 
18850
fail:
 
18851
  return NULL;
 
18852
}
 
18853
 
 
18854
 
 
18855
SWIGINTERN PyObject *_wrap_RadioBox_GetColumnCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
18856
  PyObject *resultobj = 0;
 
18857
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18858
  unsigned int result;
 
18859
  void *argp1 = 0 ;
 
18860
  int res1 = 0 ;
 
18861
  PyObject *swig_obj[1] ;
 
18862
  
 
18863
  if (!args) SWIG_fail;
 
18864
  swig_obj[0] = args;
 
18865
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18866
  if (!SWIG_IsOK(res1)) {
 
18867
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_GetColumnCount" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
18868
  }
 
18869
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18870
  {
 
18871
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18872
    result = (unsigned int)((wxRadioBox const *)arg1)->GetColumnCount();
 
18873
    wxPyEndAllowThreads(__tstate);
 
18874
    if (PyErr_Occurred()) SWIG_fail;
 
18875
  }
 
18876
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
 
18877
  return resultobj;
 
18878
fail:
 
18879
  return NULL;
 
18880
}
 
18881
 
 
18882
 
 
18883
SWIGINTERN PyObject *_wrap_RadioBox_GetRowCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
18884
  PyObject *resultobj = 0;
 
18885
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18886
  unsigned int result;
 
18887
  void *argp1 = 0 ;
 
18888
  int res1 = 0 ;
 
18889
  PyObject *swig_obj[1] ;
 
18890
  
 
18891
  if (!args) SWIG_fail;
 
18892
  swig_obj[0] = args;
 
18893
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18894
  if (!SWIG_IsOK(res1)) {
 
18895
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_GetRowCount" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
18896
  }
 
18897
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18898
  {
 
18899
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18900
    result = (unsigned int)((wxRadioBox const *)arg1)->GetRowCount();
 
18901
    wxPyEndAllowThreads(__tstate);
 
18902
    if (PyErr_Occurred()) SWIG_fail;
 
18903
  }
 
18904
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
 
18905
  return resultobj;
 
18906
fail:
 
18907
  return NULL;
 
18908
}
 
18909
 
 
18910
 
 
18911
SWIGINTERN PyObject *_wrap_RadioBox_GetNextItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18912
  PyObject *resultobj = 0;
 
18913
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18914
  int arg2 ;
 
18915
  wxDirection arg3 ;
 
18916
  long arg4 ;
 
18917
  int result;
 
18918
  void *argp1 = 0 ;
 
18919
  int res1 = 0 ;
 
18920
  int val2 ;
 
18921
  int ecode2 = 0 ;
 
18922
  int val3 ;
 
18923
  int ecode3 = 0 ;
 
18924
  long val4 ;
 
18925
  int ecode4 = 0 ;
 
18926
  PyObject * obj0 = 0 ;
 
18927
  PyObject * obj1 = 0 ;
 
18928
  PyObject * obj2 = 0 ;
 
18929
  PyObject * obj3 = 0 ;
 
18930
  char *  kwnames[] = {
 
18931
    (char *) "self",(char *) "item",(char *) "dir",(char *) "style", NULL 
 
18932
  };
 
18933
  
 
18934
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:RadioBox_GetNextItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
18935
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18936
  if (!SWIG_IsOK(res1)) {
 
18937
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_GetNextItem" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
18938
  }
 
18939
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18940
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
18941
  if (!SWIG_IsOK(ecode2)) {
 
18942
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_GetNextItem" "', expected argument " "2"" of type '" "int""'");
 
18943
  } 
 
18944
  arg2 = static_cast< int >(val2);
 
18945
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
18946
  if (!SWIG_IsOK(ecode3)) {
 
18947
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RadioBox_GetNextItem" "', expected argument " "3"" of type '" "wxDirection""'");
 
18948
  } 
 
18949
  arg3 = static_cast< wxDirection >(val3);
 
18950
  ecode4 = SWIG_AsVal_long(obj3, &val4);
 
18951
  if (!SWIG_IsOK(ecode4)) {
 
18952
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RadioBox_GetNextItem" "', expected argument " "4"" of type '" "long""'");
 
18953
  } 
 
18954
  arg4 = static_cast< long >(val4);
 
18955
  {
 
18956
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
18957
    result = (int)((wxRadioBox const *)arg1)->GetNextItem(arg2,arg3,arg4);
 
18958
    wxPyEndAllowThreads(__tstate);
 
18959
    if (PyErr_Occurred()) SWIG_fail;
 
18960
  }
 
18961
  resultobj = SWIG_From_int(static_cast< int >(result));
 
18962
  return resultobj;
 
18963
fail:
 
18964
  return NULL;
 
18965
}
 
18966
 
 
18967
 
 
18968
SWIGINTERN PyObject *_wrap_RadioBox_SetItemToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
18969
  PyObject *resultobj = 0;
 
18970
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
18971
  unsigned int arg2 ;
 
18972
  wxString *arg3 = 0 ;
 
18973
  void *argp1 = 0 ;
 
18974
  int res1 = 0 ;
 
18975
  unsigned int val2 ;
 
18976
  int ecode2 = 0 ;
 
18977
  bool temp3 = false ;
 
18978
  PyObject * obj0 = 0 ;
 
18979
  PyObject * obj1 = 0 ;
 
18980
  PyObject * obj2 = 0 ;
 
18981
  char *  kwnames[] = {
 
18982
    (char *) "self",(char *) "item",(char *) "text", NULL 
 
18983
  };
 
18984
  
 
18985
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RadioBox_SetItemToolTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
18986
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
18987
  if (!SWIG_IsOK(res1)) {
 
18988
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_SetItemToolTip" "', expected argument " "1"" of type '" "wxRadioBox *""'"); 
 
18989
  }
 
18990
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
18991
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
18992
  if (!SWIG_IsOK(ecode2)) {
 
18993
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_SetItemToolTip" "', expected argument " "2"" of type '" "unsigned int""'");
 
18994
  } 
 
18995
  arg2 = static_cast< unsigned int >(val2);
 
18996
  {
 
18997
    arg3 = wxString_in_helper(obj2);
 
18998
    if (arg3 == NULL) SWIG_fail;
 
18999
    temp3 = true;
 
19000
  }
 
19001
  {
 
19002
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19003
    (arg1)->SetItemToolTip(arg2,(wxString const &)*arg3);
 
19004
    wxPyEndAllowThreads(__tstate);
 
19005
    if (PyErr_Occurred()) SWIG_fail;
 
19006
  }
 
19007
  resultobj = SWIG_Py_Void();
 
19008
  {
 
19009
    if (temp3)
 
19010
    delete arg3;
 
19011
  }
 
19012
  return resultobj;
 
19013
fail:
 
19014
  {
 
19015
    if (temp3)
 
19016
    delete arg3;
 
19017
  }
 
19018
  return NULL;
 
19019
}
 
19020
 
 
19021
 
 
19022
SWIGINTERN PyObject *_wrap_RadioBox_GetItemToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19023
  PyObject *resultobj = 0;
 
19024
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
19025
  unsigned int arg2 ;
 
19026
  wxToolTip *result = 0 ;
 
19027
  void *argp1 = 0 ;
 
19028
  int res1 = 0 ;
 
19029
  unsigned int val2 ;
 
19030
  int ecode2 = 0 ;
 
19031
  PyObject * obj0 = 0 ;
 
19032
  PyObject * obj1 = 0 ;
 
19033
  char *  kwnames[] = {
 
19034
    (char *) "self",(char *) "item", NULL 
 
19035
  };
 
19036
  
 
19037
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_GetItemToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
 
19038
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
19039
  if (!SWIG_IsOK(res1)) {
 
19040
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_GetItemToolTip" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
19041
  }
 
19042
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
19043
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
19044
  if (!SWIG_IsOK(ecode2)) {
 
19045
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_GetItemToolTip" "', expected argument " "2"" of type '" "unsigned int""'");
 
19046
  } 
 
19047
  arg2 = static_cast< unsigned int >(val2);
 
19048
  {
 
19049
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19050
    result = (wxToolTip *)((wxRadioBox const *)arg1)->GetItemToolTip(arg2);
 
19051
    wxPyEndAllowThreads(__tstate);
 
19052
    if (PyErr_Occurred()) SWIG_fail;
 
19053
  }
 
19054
  {
 
19055
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
19056
  }
 
19057
  return resultobj;
 
19058
fail:
 
19059
  return NULL;
 
19060
}
 
19061
 
 
19062
 
 
19063
SWIGINTERN PyObject *_wrap_RadioBox_SetItemHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19064
  PyObject *resultobj = 0;
 
19065
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
19066
  unsigned int arg2 ;
 
19067
  wxString *arg3 = 0 ;
 
19068
  void *argp1 = 0 ;
 
19069
  int res1 = 0 ;
 
19070
  unsigned int val2 ;
 
19071
  int ecode2 = 0 ;
 
19072
  bool temp3 = false ;
 
19073
  PyObject * obj0 = 0 ;
 
19074
  PyObject * obj1 = 0 ;
 
19075
  PyObject * obj2 = 0 ;
 
19076
  char *  kwnames[] = {
 
19077
    (char *) "self",(char *) "n",(char *) "helpText", NULL 
 
19078
  };
 
19079
  
 
19080
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RadioBox_SetItemHelpText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
19081
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
19082
  if (!SWIG_IsOK(res1)) {
 
19083
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_SetItemHelpText" "', expected argument " "1"" of type '" "wxRadioBox *""'"); 
 
19084
  }
 
19085
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
19086
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
19087
  if (!SWIG_IsOK(ecode2)) {
 
19088
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_SetItemHelpText" "', expected argument " "2"" of type '" "unsigned int""'");
 
19089
  } 
 
19090
  arg2 = static_cast< unsigned int >(val2);
 
19091
  {
 
19092
    arg3 = wxString_in_helper(obj2);
 
19093
    if (arg3 == NULL) SWIG_fail;
 
19094
    temp3 = true;
 
19095
  }
 
19096
  {
 
19097
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19098
    (arg1)->SetItemHelpText(arg2,(wxString const &)*arg3);
 
19099
    wxPyEndAllowThreads(__tstate);
 
19100
    if (PyErr_Occurred()) SWIG_fail;
 
19101
  }
 
19102
  resultobj = SWIG_Py_Void();
 
19103
  {
 
19104
    if (temp3)
 
19105
    delete arg3;
 
19106
  }
 
19107
  return resultobj;
 
19108
fail:
 
19109
  {
 
19110
    if (temp3)
 
19111
    delete arg3;
 
19112
  }
 
19113
  return NULL;
 
19114
}
 
19115
 
 
19116
 
 
19117
SWIGINTERN PyObject *_wrap_RadioBox_GetItemHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19118
  PyObject *resultobj = 0;
 
19119
  wxRadioBox *arg1 = (wxRadioBox *) 0 ;
 
19120
  unsigned int arg2 ;
 
19121
  wxString result;
 
19122
  void *argp1 = 0 ;
 
19123
  int res1 = 0 ;
 
19124
  unsigned int val2 ;
 
19125
  int ecode2 = 0 ;
 
19126
  PyObject * obj0 = 0 ;
 
19127
  PyObject * obj1 = 0 ;
 
19128
  char *  kwnames[] = {
 
19129
    (char *) "self",(char *) "n", NULL 
 
19130
  };
 
19131
  
 
19132
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioBox_GetItemHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
 
19133
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioBox, 0 |  0 );
 
19134
  if (!SWIG_IsOK(res1)) {
 
19135
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioBox_GetItemHelpText" "', expected argument " "1"" of type '" "wxRadioBox const *""'"); 
 
19136
  }
 
19137
  arg1 = reinterpret_cast< wxRadioBox * >(argp1);
 
19138
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
19139
  if (!SWIG_IsOK(ecode2)) {
 
19140
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioBox_GetItemHelpText" "', expected argument " "2"" of type '" "unsigned int""'");
 
19141
  } 
 
19142
  arg2 = static_cast< unsigned int >(val2);
 
19143
  {
 
19144
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19145
    result = ((wxRadioBox const *)arg1)->GetItemHelpText(arg2);
 
19146
    wxPyEndAllowThreads(__tstate);
 
19147
    if (PyErr_Occurred()) SWIG_fail;
 
19148
  }
 
19149
  {
 
19150
#if wxUSE_UNICODE
 
19151
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
19152
#else
 
19153
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
19154
#endif
 
19155
  }
 
19156
  return resultobj;
 
19157
fail:
 
19158
  return NULL;
 
19159
}
 
19160
 
 
19161
 
 
19162
SWIGINTERN PyObject *_wrap_RadioBox_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19163
  PyObject *resultobj = 0;
 
19164
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
19165
  SwigValueWrapper<wxVisualAttributes > result;
 
19166
  int val1 ;
 
19167
  int ecode1 = 0 ;
 
19168
  PyObject * obj0 = 0 ;
 
19169
  char *  kwnames[] = {
 
19170
    (char *) "variant", NULL 
 
19171
  };
 
19172
  
 
19173
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:RadioBox_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
19174
  if (obj0) {
 
19175
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
19176
    if (!SWIG_IsOK(ecode1)) {
 
19177
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RadioBox_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
19178
    } 
 
19179
    arg1 = static_cast< wxWindowVariant >(val1);
 
19180
  }
 
19181
  {
 
19182
    if (!wxPyCheckForApp()) SWIG_fail;
 
19183
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19184
    result = wxRadioBox::GetClassDefaultAttributes(arg1);
 
19185
    wxPyEndAllowThreads(__tstate);
 
19186
    if (PyErr_Occurred()) SWIG_fail;
 
19187
  }
 
19188
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
19189
  return resultobj;
 
19190
fail:
 
19191
  return NULL;
 
19192
}
 
19193
 
 
19194
 
 
19195
SWIGINTERN PyObject *RadioBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19196
  PyObject *obj;
 
19197
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
19198
  SWIG_TypeNewClientData(SWIGTYPE_p_wxRadioBox, SWIG_NewClientData(obj));
 
19199
  return SWIG_Py_Void();
 
19200
}
 
19201
 
 
19202
SWIGINTERN PyObject *RadioBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19203
  return SWIG_Python_InitShadowInstance(args);
 
19204
}
 
19205
 
 
19206
SWIGINTERN PyObject *_wrap_new_RadioButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19207
  PyObject *resultobj = 0;
 
19208
  wxWindow *arg1 = (wxWindow *) 0 ;
 
19209
  int arg2 = (int) -1 ;
 
19210
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
19211
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
19212
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
19213
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
19214
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
19215
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
19216
  long arg6 = (long) 0 ;
 
19217
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
19218
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
19219
  wxString const &arg8_defvalue = wxPyRadioButtonNameStr ;
 
19220
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
19221
  wxRadioButton *result = 0 ;
 
19222
  void *argp1 = 0 ;
 
19223
  int res1 = 0 ;
 
19224
  int val2 ;
 
19225
  int ecode2 = 0 ;
 
19226
  bool temp3 = false ;
 
19227
  wxPoint temp4 ;
 
19228
  wxSize temp5 ;
 
19229
  long val6 ;
 
19230
  int ecode6 = 0 ;
 
19231
  void *argp7 = 0 ;
 
19232
  int res7 = 0 ;
 
19233
  bool temp8 = false ;
 
19234
  PyObject * obj0 = 0 ;
 
19235
  PyObject * obj1 = 0 ;
 
19236
  PyObject * obj2 = 0 ;
 
19237
  PyObject * obj3 = 0 ;
 
19238
  PyObject * obj4 = 0 ;
 
19239
  PyObject * obj5 = 0 ;
 
19240
  PyObject * obj6 = 0 ;
 
19241
  PyObject * obj7 = 0 ;
 
19242
  char *  kwnames[] = {
 
19243
    (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
19244
  };
 
19245
  
 
19246
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_RadioButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
19247
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
19248
  if (!SWIG_IsOK(res1)) {
 
19249
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RadioButton" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
19250
  }
 
19251
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
19252
  if (obj1) {
 
19253
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
19254
    if (!SWIG_IsOK(ecode2)) {
 
19255
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RadioButton" "', expected argument " "2"" of type '" "int""'");
 
19256
    } 
 
19257
    arg2 = static_cast< int >(val2);
 
19258
  }
 
19259
  if (obj2) {
 
19260
    {
 
19261
      arg3 = wxString_in_helper(obj2);
 
19262
      if (arg3 == NULL) SWIG_fail;
 
19263
      temp3 = true;
 
19264
    }
 
19265
  }
 
19266
  if (obj3) {
 
19267
    {
 
19268
      arg4 = &temp4;
 
19269
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
19270
    }
 
19271
  }
 
19272
  if (obj4) {
 
19273
    {
 
19274
      arg5 = &temp5;
 
19275
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
19276
    }
 
19277
  }
 
19278
  if (obj5) {
 
19279
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
19280
    if (!SWIG_IsOK(ecode6)) {
 
19281
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RadioButton" "', expected argument " "6"" of type '" "long""'");
 
19282
    } 
 
19283
    arg6 = static_cast< long >(val6);
 
19284
  }
 
19285
  if (obj6) {
 
19286
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
19287
    if (!SWIG_IsOK(res7)) {
 
19288
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_RadioButton" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
19289
    }
 
19290
    if (!argp7) {
 
19291
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RadioButton" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
19292
    }
 
19293
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
19294
  }
 
19295
  if (obj7) {
 
19296
    {
 
19297
      arg8 = wxString_in_helper(obj7);
 
19298
      if (arg8 == NULL) SWIG_fail;
 
19299
      temp8 = true;
 
19300
    }
 
19301
  }
 
19302
  {
 
19303
    if (!wxPyCheckForApp()) SWIG_fail;
 
19304
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19305
    result = (wxRadioButton *)new wxRadioButton(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
19306
    wxPyEndAllowThreads(__tstate);
 
19307
    if (PyErr_Occurred()) SWIG_fail;
 
19308
  }
 
19309
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRadioButton, SWIG_POINTER_NEW |  0 );
 
19310
  {
 
19311
    if (temp3)
 
19312
    delete arg3;
 
19313
  }
 
19314
  {
 
19315
    if (temp8)
 
19316
    delete arg8;
 
19317
  }
 
19318
  return resultobj;
 
19319
fail:
 
19320
  {
 
19321
    if (temp3)
 
19322
    delete arg3;
 
19323
  }
 
19324
  {
 
19325
    if (temp8)
 
19326
    delete arg8;
 
19327
  }
 
19328
  return NULL;
 
19329
}
 
19330
 
 
19331
 
 
19332
SWIGINTERN PyObject *_wrap_new_PreRadioButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19333
  PyObject *resultobj = 0;
 
19334
  wxRadioButton *result = 0 ;
 
19335
  
 
19336
  if (!SWIG_Python_UnpackTuple(args,"new_PreRadioButton",0,0,0)) SWIG_fail;
 
19337
  {
 
19338
    if (!wxPyCheckForApp()) SWIG_fail;
 
19339
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19340
    result = (wxRadioButton *)new wxRadioButton();
 
19341
    wxPyEndAllowThreads(__tstate);
 
19342
    if (PyErr_Occurred()) SWIG_fail;
 
19343
  }
 
19344
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRadioButton, SWIG_POINTER_OWN |  0 );
 
19345
  return resultobj;
 
19346
fail:
 
19347
  return NULL;
 
19348
}
 
19349
 
 
19350
 
 
19351
SWIGINTERN PyObject *_wrap_RadioButton_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19352
  PyObject *resultobj = 0;
 
19353
  wxRadioButton *arg1 = (wxRadioButton *) 0 ;
 
19354
  wxWindow *arg2 = (wxWindow *) 0 ;
 
19355
  int arg3 = (int) -1 ;
 
19356
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
19357
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
19358
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
19359
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
19360
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
19361
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
19362
  long arg7 = (long) 0 ;
 
19363
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
19364
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
19365
  wxString const &arg9_defvalue = wxPyRadioButtonNameStr ;
 
19366
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
19367
  bool result;
 
19368
  void *argp1 = 0 ;
 
19369
  int res1 = 0 ;
 
19370
  void *argp2 = 0 ;
 
19371
  int res2 = 0 ;
 
19372
  int val3 ;
 
19373
  int ecode3 = 0 ;
 
19374
  bool temp4 = false ;
 
19375
  wxPoint temp5 ;
 
19376
  wxSize temp6 ;
 
19377
  long val7 ;
 
19378
  int ecode7 = 0 ;
 
19379
  void *argp8 = 0 ;
 
19380
  int res8 = 0 ;
 
19381
  bool temp9 = false ;
 
19382
  PyObject * obj0 = 0 ;
 
19383
  PyObject * obj1 = 0 ;
 
19384
  PyObject * obj2 = 0 ;
 
19385
  PyObject * obj3 = 0 ;
 
19386
  PyObject * obj4 = 0 ;
 
19387
  PyObject * obj5 = 0 ;
 
19388
  PyObject * obj6 = 0 ;
 
19389
  PyObject * obj7 = 0 ;
 
19390
  PyObject * obj8 = 0 ;
 
19391
  char *  kwnames[] = {
 
19392
    (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
19393
  };
 
19394
  
 
19395
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:RadioButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
19396
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioButton, 0 |  0 );
 
19397
  if (!SWIG_IsOK(res1)) {
 
19398
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioButton_Create" "', expected argument " "1"" of type '" "wxRadioButton *""'"); 
 
19399
  }
 
19400
  arg1 = reinterpret_cast< wxRadioButton * >(argp1);
 
19401
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
19402
  if (!SWIG_IsOK(res2)) {
 
19403
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RadioButton_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
19404
  }
 
19405
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
19406
  if (obj2) {
 
19407
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
19408
    if (!SWIG_IsOK(ecode3)) {
 
19409
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RadioButton_Create" "', expected argument " "3"" of type '" "int""'");
 
19410
    } 
 
19411
    arg3 = static_cast< int >(val3);
 
19412
  }
 
19413
  if (obj3) {
 
19414
    {
 
19415
      arg4 = wxString_in_helper(obj3);
 
19416
      if (arg4 == NULL) SWIG_fail;
 
19417
      temp4 = true;
 
19418
    }
 
19419
  }
 
19420
  if (obj4) {
 
19421
    {
 
19422
      arg5 = &temp5;
 
19423
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
19424
    }
 
19425
  }
 
19426
  if (obj5) {
 
19427
    {
 
19428
      arg6 = &temp6;
 
19429
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
19430
    }
 
19431
  }
 
19432
  if (obj6) {
 
19433
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
19434
    if (!SWIG_IsOK(ecode7)) {
 
19435
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RadioButton_Create" "', expected argument " "7"" of type '" "long""'");
 
19436
    } 
 
19437
    arg7 = static_cast< long >(val7);
 
19438
  }
 
19439
  if (obj7) {
 
19440
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
19441
    if (!SWIG_IsOK(res8)) {
 
19442
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "RadioButton_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
19443
    }
 
19444
    if (!argp8) {
 
19445
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RadioButton_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
19446
    }
 
19447
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
19448
  }
 
19449
  if (obj8) {
 
19450
    {
 
19451
      arg9 = wxString_in_helper(obj8);
 
19452
      if (arg9 == NULL) SWIG_fail;
 
19453
      temp9 = true;
 
19454
    }
 
19455
  }
 
19456
  {
 
19457
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19458
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
19459
    wxPyEndAllowThreads(__tstate);
 
19460
    if (PyErr_Occurred()) SWIG_fail;
 
19461
  }
 
19462
  {
 
19463
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
19464
  }
 
19465
  {
 
19466
    if (temp4)
 
19467
    delete arg4;
 
19468
  }
 
19469
  {
 
19470
    if (temp9)
 
19471
    delete arg9;
 
19472
  }
 
19473
  return resultobj;
 
19474
fail:
 
19475
  {
 
19476
    if (temp4)
 
19477
    delete arg4;
 
19478
  }
 
19479
  {
 
19480
    if (temp9)
 
19481
    delete arg9;
 
19482
  }
 
19483
  return NULL;
 
19484
}
 
19485
 
 
19486
 
 
19487
SWIGINTERN PyObject *_wrap_RadioButton_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19488
  PyObject *resultobj = 0;
 
19489
  wxRadioButton *arg1 = (wxRadioButton *) 0 ;
 
19490
  bool result;
 
19491
  void *argp1 = 0 ;
 
19492
  int res1 = 0 ;
 
19493
  PyObject *swig_obj[1] ;
 
19494
  
 
19495
  if (!args) SWIG_fail;
 
19496
  swig_obj[0] = args;
 
19497
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRadioButton, 0 |  0 );
 
19498
  if (!SWIG_IsOK(res1)) {
 
19499
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioButton_GetValue" "', expected argument " "1"" of type '" "wxRadioButton *""'"); 
 
19500
  }
 
19501
  arg1 = reinterpret_cast< wxRadioButton * >(argp1);
 
19502
  {
 
19503
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19504
    result = (bool)(arg1)->GetValue();
 
19505
    wxPyEndAllowThreads(__tstate);
 
19506
    if (PyErr_Occurred()) SWIG_fail;
 
19507
  }
 
19508
  {
 
19509
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
19510
  }
 
19511
  return resultobj;
 
19512
fail:
 
19513
  return NULL;
 
19514
}
 
19515
 
 
19516
 
 
19517
SWIGINTERN PyObject *_wrap_RadioButton_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19518
  PyObject *resultobj = 0;
 
19519
  wxRadioButton *arg1 = (wxRadioButton *) 0 ;
 
19520
  bool arg2 ;
 
19521
  void *argp1 = 0 ;
 
19522
  int res1 = 0 ;
 
19523
  bool val2 ;
 
19524
  int ecode2 = 0 ;
 
19525
  PyObject * obj0 = 0 ;
 
19526
  PyObject * obj1 = 0 ;
 
19527
  char *  kwnames[] = {
 
19528
    (char *) "self",(char *) "value", NULL 
 
19529
  };
 
19530
  
 
19531
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RadioButton_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
19532
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRadioButton, 0 |  0 );
 
19533
  if (!SWIG_IsOK(res1)) {
 
19534
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RadioButton_SetValue" "', expected argument " "1"" of type '" "wxRadioButton *""'"); 
 
19535
  }
 
19536
  arg1 = reinterpret_cast< wxRadioButton * >(argp1);
 
19537
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
19538
  if (!SWIG_IsOK(ecode2)) {
 
19539
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RadioButton_SetValue" "', expected argument " "2"" of type '" "bool""'");
 
19540
  } 
 
19541
  arg2 = static_cast< bool >(val2);
 
19542
  {
 
19543
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19544
    (arg1)->SetValue(arg2);
 
19545
    wxPyEndAllowThreads(__tstate);
 
19546
    if (PyErr_Occurred()) SWIG_fail;
 
19547
  }
 
19548
  resultobj = SWIG_Py_Void();
 
19549
  return resultobj;
 
19550
fail:
 
19551
  return NULL;
 
19552
}
 
19553
 
 
19554
 
 
19555
SWIGINTERN PyObject *_wrap_RadioButton_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19556
  PyObject *resultobj = 0;
 
19557
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
19558
  SwigValueWrapper<wxVisualAttributes > result;
 
19559
  int val1 ;
 
19560
  int ecode1 = 0 ;
 
19561
  PyObject * obj0 = 0 ;
 
19562
  char *  kwnames[] = {
 
19563
    (char *) "variant", NULL 
 
19564
  };
 
19565
  
 
19566
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:RadioButton_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
19567
  if (obj0) {
 
19568
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
19569
    if (!SWIG_IsOK(ecode1)) {
 
19570
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RadioButton_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
19571
    } 
 
19572
    arg1 = static_cast< wxWindowVariant >(val1);
 
19573
  }
 
19574
  {
 
19575
    if (!wxPyCheckForApp()) SWIG_fail;
 
19576
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19577
    result = wxRadioButton::GetClassDefaultAttributes(arg1);
 
19578
    wxPyEndAllowThreads(__tstate);
 
19579
    if (PyErr_Occurred()) SWIG_fail;
 
19580
  }
 
19581
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
19582
  return resultobj;
 
19583
fail:
 
19584
  return NULL;
 
19585
}
 
19586
 
 
19587
 
 
19588
SWIGINTERN PyObject *RadioButton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19589
  PyObject *obj;
 
19590
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
19591
  SWIG_TypeNewClientData(SWIGTYPE_p_wxRadioButton, SWIG_NewClientData(obj));
 
19592
  return SWIG_Py_Void();
 
19593
}
 
19594
 
 
19595
SWIGINTERN PyObject *RadioButton_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19596
  return SWIG_Python_InitShadowInstance(args);
 
19597
}
 
19598
 
 
19599
SWIGINTERN int SliderNameStr_set(PyObject *) {
 
19600
  SWIG_Error(SWIG_AttributeError,"Variable SliderNameStr is read-only.");
 
19601
  return 1;
 
19602
}
 
19603
 
 
19604
 
 
19605
SWIGINTERN PyObject *SliderNameStr_get(void) {
 
19606
  PyObject *pyobj = 0;
 
19607
  
 
19608
  {
 
19609
#if wxUSE_UNICODE
 
19610
    pyobj = PyUnicode_FromWideChar((&wxPySliderNameStr)->c_str(), (&wxPySliderNameStr)->Len());
 
19611
#else
 
19612
    pyobj = PyString_FromStringAndSize((&wxPySliderNameStr)->c_str(), (&wxPySliderNameStr)->Len());
 
19613
#endif
 
19614
  }
 
19615
  return pyobj;
 
19616
}
 
19617
 
 
19618
 
 
19619
SWIGINTERN PyObject *_wrap_new_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19620
  PyObject *resultobj = 0;
 
19621
  wxWindow *arg1 = (wxWindow *) 0 ;
 
19622
  int arg2 = (int) -1 ;
 
19623
  int arg3 = (int) 0 ;
 
19624
  int arg4 = (int) 0 ;
 
19625
  int arg5 = (int) 100 ;
 
19626
  wxPoint const &arg6_defvalue = wxDefaultPosition ;
 
19627
  wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
 
19628
  wxSize const &arg7_defvalue = wxDefaultSize ;
 
19629
  wxSize *arg7 = (wxSize *) &arg7_defvalue ;
 
19630
  long arg8 = (long) wxSL_HORIZONTAL ;
 
19631
  wxValidator const &arg9_defvalue = wxDefaultValidator ;
 
19632
  wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
 
19633
  wxString const &arg10_defvalue = wxPySliderNameStr ;
 
19634
  wxString *arg10 = (wxString *) &arg10_defvalue ;
 
19635
  wxSlider *result = 0 ;
 
19636
  void *argp1 = 0 ;
 
19637
  int res1 = 0 ;
 
19638
  int val2 ;
 
19639
  int ecode2 = 0 ;
 
19640
  int val3 ;
 
19641
  int ecode3 = 0 ;
 
19642
  int val4 ;
 
19643
  int ecode4 = 0 ;
 
19644
  int val5 ;
 
19645
  int ecode5 = 0 ;
 
19646
  wxPoint temp6 ;
 
19647
  wxSize temp7 ;
 
19648
  long val8 ;
 
19649
  int ecode8 = 0 ;
 
19650
  void *argp9 = 0 ;
 
19651
  int res9 = 0 ;
 
19652
  bool temp10 = false ;
 
19653
  PyObject * obj0 = 0 ;
 
19654
  PyObject * obj1 = 0 ;
 
19655
  PyObject * obj2 = 0 ;
 
19656
  PyObject * obj3 = 0 ;
 
19657
  PyObject * obj4 = 0 ;
 
19658
  PyObject * obj5 = 0 ;
 
19659
  PyObject * obj6 = 0 ;
 
19660
  PyObject * obj7 = 0 ;
 
19661
  PyObject * obj8 = 0 ;
 
19662
  PyObject * obj9 = 0 ;
 
19663
  char *  kwnames[] = {
 
19664
    (char *) "parent",(char *) "id",(char *) "value",(char *) "minValue",(char *) "maxValue",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
19665
  };
 
19666
  
 
19667
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOO:new_Slider",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
 
19668
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
19669
  if (!SWIG_IsOK(res1)) {
 
19670
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Slider" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
19671
  }
 
19672
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
19673
  if (obj1) {
 
19674
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
19675
    if (!SWIG_IsOK(ecode2)) {
 
19676
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Slider" "', expected argument " "2"" of type '" "int""'");
 
19677
    } 
 
19678
    arg2 = static_cast< int >(val2);
 
19679
  }
 
19680
  if (obj2) {
 
19681
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
19682
    if (!SWIG_IsOK(ecode3)) {
 
19683
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Slider" "', expected argument " "3"" of type '" "int""'");
 
19684
    } 
 
19685
    arg3 = static_cast< int >(val3);
 
19686
  }
 
19687
  if (obj3) {
 
19688
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
19689
    if (!SWIG_IsOK(ecode4)) {
 
19690
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Slider" "', expected argument " "4"" of type '" "int""'");
 
19691
    } 
 
19692
    arg4 = static_cast< int >(val4);
 
19693
  }
 
19694
  if (obj4) {
 
19695
    ecode5 = SWIG_AsVal_int(obj4, &val5);
 
19696
    if (!SWIG_IsOK(ecode5)) {
 
19697
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Slider" "', expected argument " "5"" of type '" "int""'");
 
19698
    } 
 
19699
    arg5 = static_cast< int >(val5);
 
19700
  }
 
19701
  if (obj5) {
 
19702
    {
 
19703
      arg6 = &temp6;
 
19704
      if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
 
19705
    }
 
19706
  }
 
19707
  if (obj6) {
 
19708
    {
 
19709
      arg7 = &temp7;
 
19710
      if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
 
19711
    }
 
19712
  }
 
19713
  if (obj7) {
 
19714
    ecode8 = SWIG_AsVal_long(obj7, &val8);
 
19715
    if (!SWIG_IsOK(ecode8)) {
 
19716
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Slider" "', expected argument " "8"" of type '" "long""'");
 
19717
    } 
 
19718
    arg8 = static_cast< long >(val8);
 
19719
  }
 
19720
  if (obj8) {
 
19721
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_wxValidator,  0  | 0);
 
19722
    if (!SWIG_IsOK(res9)) {
 
19723
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_Slider" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
19724
    }
 
19725
    if (!argp9) {
 
19726
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Slider" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
19727
    }
 
19728
    arg9 = reinterpret_cast< wxValidator * >(argp9);
 
19729
  }
 
19730
  if (obj9) {
 
19731
    {
 
19732
      arg10 = wxString_in_helper(obj9);
 
19733
      if (arg10 == NULL) SWIG_fail;
 
19734
      temp10 = true;
 
19735
    }
 
19736
  }
 
19737
  {
 
19738
    if (!wxPyCheckForApp()) SWIG_fail;
 
19739
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19740
    result = (wxSlider *)new wxSlider(arg1,arg2,arg3,arg4,arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);
 
19741
    wxPyEndAllowThreads(__tstate);
 
19742
    if (PyErr_Occurred()) SWIG_fail;
 
19743
  }
 
19744
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSlider, SWIG_POINTER_NEW |  0 );
 
19745
  {
 
19746
    if (temp10)
 
19747
    delete arg10;
 
19748
  }
 
19749
  return resultobj;
 
19750
fail:
 
19751
  {
 
19752
    if (temp10)
 
19753
    delete arg10;
 
19754
  }
 
19755
  return NULL;
 
19756
}
 
19757
 
 
19758
 
 
19759
SWIGINTERN PyObject *_wrap_new_PreSlider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19760
  PyObject *resultobj = 0;
 
19761
  wxSlider *result = 0 ;
 
19762
  
 
19763
  if (!SWIG_Python_UnpackTuple(args,"new_PreSlider",0,0,0)) SWIG_fail;
 
19764
  {
 
19765
    if (!wxPyCheckForApp()) SWIG_fail;
 
19766
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19767
    result = (wxSlider *)new wxSlider();
 
19768
    wxPyEndAllowThreads(__tstate);
 
19769
    if (PyErr_Occurred()) SWIG_fail;
 
19770
  }
 
19771
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSlider, SWIG_POINTER_OWN |  0 );
 
19772
  return resultobj;
 
19773
fail:
 
19774
  return NULL;
 
19775
}
 
19776
 
 
19777
 
 
19778
SWIGINTERN PyObject *_wrap_Slider_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19779
  PyObject *resultobj = 0;
 
19780
  wxSlider *arg1 = (wxSlider *) 0 ;
 
19781
  wxWindow *arg2 = (wxWindow *) 0 ;
 
19782
  int arg3 = (int) -1 ;
 
19783
  int arg4 = (int) 0 ;
 
19784
  int arg5 = (int) 0 ;
 
19785
  int arg6 = (int) 100 ;
 
19786
  wxPoint const &arg7_defvalue = wxDefaultPosition ;
 
19787
  wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
 
19788
  wxSize const &arg8_defvalue = wxDefaultSize ;
 
19789
  wxSize *arg8 = (wxSize *) &arg8_defvalue ;
 
19790
  long arg9 = (long) wxSL_HORIZONTAL ;
 
19791
  wxValidator const &arg10_defvalue = wxDefaultValidator ;
 
19792
  wxValidator *arg10 = (wxValidator *) &arg10_defvalue ;
 
19793
  wxString const &arg11_defvalue = wxPySliderNameStr ;
 
19794
  wxString *arg11 = (wxString *) &arg11_defvalue ;
 
19795
  bool result;
 
19796
  void *argp1 = 0 ;
 
19797
  int res1 = 0 ;
 
19798
  void *argp2 = 0 ;
 
19799
  int res2 = 0 ;
 
19800
  int val3 ;
 
19801
  int ecode3 = 0 ;
 
19802
  int val4 ;
 
19803
  int ecode4 = 0 ;
 
19804
  int val5 ;
 
19805
  int ecode5 = 0 ;
 
19806
  int val6 ;
 
19807
  int ecode6 = 0 ;
 
19808
  wxPoint temp7 ;
 
19809
  wxSize temp8 ;
 
19810
  long val9 ;
 
19811
  int ecode9 = 0 ;
 
19812
  void *argp10 = 0 ;
 
19813
  int res10 = 0 ;
 
19814
  bool temp11 = false ;
 
19815
  PyObject * obj0 = 0 ;
 
19816
  PyObject * obj1 = 0 ;
 
19817
  PyObject * obj2 = 0 ;
 
19818
  PyObject * obj3 = 0 ;
 
19819
  PyObject * obj4 = 0 ;
 
19820
  PyObject * obj5 = 0 ;
 
19821
  PyObject * obj6 = 0 ;
 
19822
  PyObject * obj7 = 0 ;
 
19823
  PyObject * obj8 = 0 ;
 
19824
  PyObject * obj9 = 0 ;
 
19825
  PyObject * obj10 = 0 ;
 
19826
  char *  kwnames[] = {
 
19827
    (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "minValue",(char *) "maxValue",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
19828
  };
 
19829
  
 
19830
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOO:Slider_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
 
19831
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
19832
  if (!SWIG_IsOK(res1)) {
 
19833
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_Create" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
19834
  }
 
19835
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
19836
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
19837
  if (!SWIG_IsOK(res2)) {
 
19838
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Slider_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
19839
  }
 
19840
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
19841
  if (obj2) {
 
19842
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
19843
    if (!SWIG_IsOK(ecode3)) {
 
19844
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Slider_Create" "', expected argument " "3"" of type '" "int""'");
 
19845
    } 
 
19846
    arg3 = static_cast< int >(val3);
 
19847
  }
 
19848
  if (obj3) {
 
19849
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
19850
    if (!SWIG_IsOK(ecode4)) {
 
19851
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Slider_Create" "', expected argument " "4"" of type '" "int""'");
 
19852
    } 
 
19853
    arg4 = static_cast< int >(val4);
 
19854
  }
 
19855
  if (obj4) {
 
19856
    ecode5 = SWIG_AsVal_int(obj4, &val5);
 
19857
    if (!SWIG_IsOK(ecode5)) {
 
19858
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Slider_Create" "', expected argument " "5"" of type '" "int""'");
 
19859
    } 
 
19860
    arg5 = static_cast< int >(val5);
 
19861
  }
 
19862
  if (obj5) {
 
19863
    ecode6 = SWIG_AsVal_int(obj5, &val6);
 
19864
    if (!SWIG_IsOK(ecode6)) {
 
19865
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Slider_Create" "', expected argument " "6"" of type '" "int""'");
 
19866
    } 
 
19867
    arg6 = static_cast< int >(val6);
 
19868
  }
 
19869
  if (obj6) {
 
19870
    {
 
19871
      arg7 = &temp7;
 
19872
      if ( ! wxPoint_helper(obj6, &arg7)) SWIG_fail;
 
19873
    }
 
19874
  }
 
19875
  if (obj7) {
 
19876
    {
 
19877
      arg8 = &temp8;
 
19878
      if ( ! wxSize_helper(obj7, &arg8)) SWIG_fail;
 
19879
    }
 
19880
  }
 
19881
  if (obj8) {
 
19882
    ecode9 = SWIG_AsVal_long(obj8, &val9);
 
19883
    if (!SWIG_IsOK(ecode9)) {
 
19884
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Slider_Create" "', expected argument " "9"" of type '" "long""'");
 
19885
    } 
 
19886
    arg9 = static_cast< long >(val9);
 
19887
  }
 
19888
  if (obj9) {
 
19889
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_wxValidator,  0  | 0);
 
19890
    if (!SWIG_IsOK(res10)) {
 
19891
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Slider_Create" "', expected argument " "10"" of type '" "wxValidator const &""'"); 
 
19892
    }
 
19893
    if (!argp10) {
 
19894
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Slider_Create" "', expected argument " "10"" of type '" "wxValidator const &""'"); 
 
19895
    }
 
19896
    arg10 = reinterpret_cast< wxValidator * >(argp10);
 
19897
  }
 
19898
  if (obj10) {
 
19899
    {
 
19900
      arg11 = wxString_in_helper(obj10);
 
19901
      if (arg11 == NULL) SWIG_fail;
 
19902
      temp11 = true;
 
19903
    }
 
19904
  }
 
19905
  {
 
19906
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19907
    result = (bool)(arg1)->Create(arg2,arg3,arg4,arg5,arg6,(wxPoint const &)*arg7,(wxSize const &)*arg8,arg9,(wxValidator const &)*arg10,(wxString const &)*arg11);
 
19908
    wxPyEndAllowThreads(__tstate);
 
19909
    if (PyErr_Occurred()) SWIG_fail;
 
19910
  }
 
19911
  {
 
19912
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
19913
  }
 
19914
  {
 
19915
    if (temp11)
 
19916
    delete arg11;
 
19917
  }
 
19918
  return resultobj;
 
19919
fail:
 
19920
  {
 
19921
    if (temp11)
 
19922
    delete arg11;
 
19923
  }
 
19924
  return NULL;
 
19925
}
 
19926
 
 
19927
 
 
19928
SWIGINTERN PyObject *_wrap_Slider_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19929
  PyObject *resultobj = 0;
 
19930
  wxSlider *arg1 = (wxSlider *) 0 ;
 
19931
  int result;
 
19932
  void *argp1 = 0 ;
 
19933
  int res1 = 0 ;
 
19934
  PyObject *swig_obj[1] ;
 
19935
  
 
19936
  if (!args) SWIG_fail;
 
19937
  swig_obj[0] = args;
 
19938
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
19939
  if (!SWIG_IsOK(res1)) {
 
19940
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_GetValue" "', expected argument " "1"" of type '" "wxSlider const *""'"); 
 
19941
  }
 
19942
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
19943
  {
 
19944
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19945
    result = (int)((wxSlider const *)arg1)->GetValue();
 
19946
    wxPyEndAllowThreads(__tstate);
 
19947
    if (PyErr_Occurred()) SWIG_fail;
 
19948
  }
 
19949
  resultobj = SWIG_From_int(static_cast< int >(result));
 
19950
  return resultobj;
 
19951
fail:
 
19952
  return NULL;
 
19953
}
 
19954
 
 
19955
 
 
19956
SWIGINTERN PyObject *_wrap_Slider_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
19957
  PyObject *resultobj = 0;
 
19958
  wxSlider *arg1 = (wxSlider *) 0 ;
 
19959
  int arg2 ;
 
19960
  void *argp1 = 0 ;
 
19961
  int res1 = 0 ;
 
19962
  int val2 ;
 
19963
  int ecode2 = 0 ;
 
19964
  PyObject * obj0 = 0 ;
 
19965
  PyObject * obj1 = 0 ;
 
19966
  char *  kwnames[] = {
 
19967
    (char *) "self",(char *) "value", NULL 
 
19968
  };
 
19969
  
 
19970
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
19971
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
19972
  if (!SWIG_IsOK(res1)) {
 
19973
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_SetValue" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
19974
  }
 
19975
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
19976
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
19977
  if (!SWIG_IsOK(ecode2)) {
 
19978
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Slider_SetValue" "', expected argument " "2"" of type '" "int""'");
 
19979
  } 
 
19980
  arg2 = static_cast< int >(val2);
 
19981
  {
 
19982
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
19983
    (arg1)->SetValue(arg2);
 
19984
    wxPyEndAllowThreads(__tstate);
 
19985
    if (PyErr_Occurred()) SWIG_fail;
 
19986
  }
 
19987
  resultobj = SWIG_Py_Void();
 
19988
  return resultobj;
 
19989
fail:
 
19990
  return NULL;
 
19991
}
 
19992
 
 
19993
 
 
19994
SWIGINTERN PyObject *_wrap_Slider_GetMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
19995
  PyObject *resultobj = 0;
 
19996
  wxSlider *arg1 = (wxSlider *) 0 ;
 
19997
  int result;
 
19998
  void *argp1 = 0 ;
 
19999
  int res1 = 0 ;
 
20000
  PyObject *swig_obj[1] ;
 
20001
  
 
20002
  if (!args) SWIG_fail;
 
20003
  swig_obj[0] = args;
 
20004
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20005
  if (!SWIG_IsOK(res1)) {
 
20006
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_GetMin" "', expected argument " "1"" of type '" "wxSlider const *""'"); 
 
20007
  }
 
20008
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20009
  {
 
20010
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20011
    result = (int)((wxSlider const *)arg1)->GetMin();
 
20012
    wxPyEndAllowThreads(__tstate);
 
20013
    if (PyErr_Occurred()) SWIG_fail;
 
20014
  }
 
20015
  resultobj = SWIG_From_int(static_cast< int >(result));
 
20016
  return resultobj;
 
20017
fail:
 
20018
  return NULL;
 
20019
}
 
20020
 
 
20021
 
 
20022
SWIGINTERN PyObject *_wrap_Slider_GetMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20023
  PyObject *resultobj = 0;
 
20024
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20025
  int result;
 
20026
  void *argp1 = 0 ;
 
20027
  int res1 = 0 ;
 
20028
  PyObject *swig_obj[1] ;
 
20029
  
 
20030
  if (!args) SWIG_fail;
 
20031
  swig_obj[0] = args;
 
20032
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20033
  if (!SWIG_IsOK(res1)) {
 
20034
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_GetMax" "', expected argument " "1"" of type '" "wxSlider const *""'"); 
 
20035
  }
 
20036
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20037
  {
 
20038
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20039
    result = (int)((wxSlider const *)arg1)->GetMax();
 
20040
    wxPyEndAllowThreads(__tstate);
 
20041
    if (PyErr_Occurred()) SWIG_fail;
 
20042
  }
 
20043
  resultobj = SWIG_From_int(static_cast< int >(result));
 
20044
  return resultobj;
 
20045
fail:
 
20046
  return NULL;
 
20047
}
 
20048
 
 
20049
 
 
20050
SWIGINTERN PyObject *_wrap_Slider_SetMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20051
  PyObject *resultobj = 0;
 
20052
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20053
  int arg2 ;
 
20054
  void *argp1 = 0 ;
 
20055
  int res1 = 0 ;
 
20056
  int val2 ;
 
20057
  int ecode2 = 0 ;
 
20058
  PyObject * obj0 = 0 ;
 
20059
  PyObject * obj1 = 0 ;
 
20060
  char *  kwnames[] = {
 
20061
    (char *) "self",(char *) "minValue", NULL 
 
20062
  };
 
20063
  
 
20064
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetMin",kwnames,&obj0,&obj1)) SWIG_fail;
 
20065
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20066
  if (!SWIG_IsOK(res1)) {
 
20067
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_SetMin" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20068
  }
 
20069
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20070
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
20071
  if (!SWIG_IsOK(ecode2)) {
 
20072
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Slider_SetMin" "', expected argument " "2"" of type '" "int""'");
 
20073
  } 
 
20074
  arg2 = static_cast< int >(val2);
 
20075
  {
 
20076
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20077
    (arg1)->SetMin(arg2);
 
20078
    wxPyEndAllowThreads(__tstate);
 
20079
    if (PyErr_Occurred()) SWIG_fail;
 
20080
  }
 
20081
  resultobj = SWIG_Py_Void();
 
20082
  return resultobj;
 
20083
fail:
 
20084
  return NULL;
 
20085
}
 
20086
 
 
20087
 
 
20088
SWIGINTERN PyObject *_wrap_Slider_SetMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20089
  PyObject *resultobj = 0;
 
20090
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20091
  int arg2 ;
 
20092
  void *argp1 = 0 ;
 
20093
  int res1 = 0 ;
 
20094
  int val2 ;
 
20095
  int ecode2 = 0 ;
 
20096
  PyObject * obj0 = 0 ;
 
20097
  PyObject * obj1 = 0 ;
 
20098
  char *  kwnames[] = {
 
20099
    (char *) "self",(char *) "maxValue", NULL 
 
20100
  };
 
20101
  
 
20102
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetMax",kwnames,&obj0,&obj1)) SWIG_fail;
 
20103
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20104
  if (!SWIG_IsOK(res1)) {
 
20105
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_SetMax" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20106
  }
 
20107
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20108
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
20109
  if (!SWIG_IsOK(ecode2)) {
 
20110
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Slider_SetMax" "', expected argument " "2"" of type '" "int""'");
 
20111
  } 
 
20112
  arg2 = static_cast< int >(val2);
 
20113
  {
 
20114
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20115
    (arg1)->SetMax(arg2);
 
20116
    wxPyEndAllowThreads(__tstate);
 
20117
    if (PyErr_Occurred()) SWIG_fail;
 
20118
  }
 
20119
  resultobj = SWIG_Py_Void();
 
20120
  return resultobj;
 
20121
fail:
 
20122
  return NULL;
 
20123
}
 
20124
 
 
20125
 
 
20126
SWIGINTERN PyObject *_wrap_Slider_SetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20127
  PyObject *resultobj = 0;
 
20128
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20129
  int arg2 ;
 
20130
  int arg3 ;
 
20131
  void *argp1 = 0 ;
 
20132
  int res1 = 0 ;
 
20133
  int val2 ;
 
20134
  int ecode2 = 0 ;
 
20135
  int val3 ;
 
20136
  int ecode3 = 0 ;
 
20137
  PyObject * obj0 = 0 ;
 
20138
  PyObject * obj1 = 0 ;
 
20139
  PyObject * obj2 = 0 ;
 
20140
  char *  kwnames[] = {
 
20141
    (char *) "self",(char *) "minValue",(char *) "maxValue", NULL 
 
20142
  };
 
20143
  
 
20144
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Slider_SetRange",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
20145
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20146
  if (!SWIG_IsOK(res1)) {
 
20147
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_SetRange" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20148
  }
 
20149
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20150
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
20151
  if (!SWIG_IsOK(ecode2)) {
 
20152
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Slider_SetRange" "', expected argument " "2"" of type '" "int""'");
 
20153
  } 
 
20154
  arg2 = static_cast< int >(val2);
 
20155
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
20156
  if (!SWIG_IsOK(ecode3)) {
 
20157
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Slider_SetRange" "', expected argument " "3"" of type '" "int""'");
 
20158
  } 
 
20159
  arg3 = static_cast< int >(val3);
 
20160
  {
 
20161
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20162
    (arg1)->SetRange(arg2,arg3);
 
20163
    wxPyEndAllowThreads(__tstate);
 
20164
    if (PyErr_Occurred()) SWIG_fail;
 
20165
  }
 
20166
  resultobj = SWIG_Py_Void();
 
20167
  return resultobj;
 
20168
fail:
 
20169
  return NULL;
 
20170
}
 
20171
 
 
20172
 
 
20173
SWIGINTERN PyObject *_wrap_Slider_SetLineSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20174
  PyObject *resultobj = 0;
 
20175
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20176
  int arg2 ;
 
20177
  void *argp1 = 0 ;
 
20178
  int res1 = 0 ;
 
20179
  int val2 ;
 
20180
  int ecode2 = 0 ;
 
20181
  PyObject * obj0 = 0 ;
 
20182
  PyObject * obj1 = 0 ;
 
20183
  char *  kwnames[] = {
 
20184
    (char *) "self",(char *) "lineSize", NULL 
 
20185
  };
 
20186
  
 
20187
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetLineSize",kwnames,&obj0,&obj1)) SWIG_fail;
 
20188
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20189
  if (!SWIG_IsOK(res1)) {
 
20190
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_SetLineSize" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20191
  }
 
20192
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20193
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
20194
  if (!SWIG_IsOK(ecode2)) {
 
20195
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Slider_SetLineSize" "', expected argument " "2"" of type '" "int""'");
 
20196
  } 
 
20197
  arg2 = static_cast< int >(val2);
 
20198
  {
 
20199
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20200
    (arg1)->SetLineSize(arg2);
 
20201
    wxPyEndAllowThreads(__tstate);
 
20202
    if (PyErr_Occurred()) SWIG_fail;
 
20203
  }
 
20204
  resultobj = SWIG_Py_Void();
 
20205
  return resultobj;
 
20206
fail:
 
20207
  return NULL;
 
20208
}
 
20209
 
 
20210
 
 
20211
SWIGINTERN PyObject *_wrap_Slider_SetPageSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20212
  PyObject *resultobj = 0;
 
20213
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20214
  int arg2 ;
 
20215
  void *argp1 = 0 ;
 
20216
  int res1 = 0 ;
 
20217
  int val2 ;
 
20218
  int ecode2 = 0 ;
 
20219
  PyObject * obj0 = 0 ;
 
20220
  PyObject * obj1 = 0 ;
 
20221
  char *  kwnames[] = {
 
20222
    (char *) "self",(char *) "pageSize", NULL 
 
20223
  };
 
20224
  
 
20225
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetPageSize",kwnames,&obj0,&obj1)) SWIG_fail;
 
20226
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20227
  if (!SWIG_IsOK(res1)) {
 
20228
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_SetPageSize" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20229
  }
 
20230
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20231
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
20232
  if (!SWIG_IsOK(ecode2)) {
 
20233
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Slider_SetPageSize" "', expected argument " "2"" of type '" "int""'");
 
20234
  } 
 
20235
  arg2 = static_cast< int >(val2);
 
20236
  {
 
20237
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20238
    (arg1)->SetPageSize(arg2);
 
20239
    wxPyEndAllowThreads(__tstate);
 
20240
    if (PyErr_Occurred()) SWIG_fail;
 
20241
  }
 
20242
  resultobj = SWIG_Py_Void();
 
20243
  return resultobj;
 
20244
fail:
 
20245
  return NULL;
 
20246
}
 
20247
 
 
20248
 
 
20249
SWIGINTERN PyObject *_wrap_Slider_GetLineSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20250
  PyObject *resultobj = 0;
 
20251
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20252
  int result;
 
20253
  void *argp1 = 0 ;
 
20254
  int res1 = 0 ;
 
20255
  PyObject *swig_obj[1] ;
 
20256
  
 
20257
  if (!args) SWIG_fail;
 
20258
  swig_obj[0] = args;
 
20259
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20260
  if (!SWIG_IsOK(res1)) {
 
20261
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_GetLineSize" "', expected argument " "1"" of type '" "wxSlider const *""'"); 
 
20262
  }
 
20263
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20264
  {
 
20265
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20266
    result = (int)((wxSlider const *)arg1)->GetLineSize();
 
20267
    wxPyEndAllowThreads(__tstate);
 
20268
    if (PyErr_Occurred()) SWIG_fail;
 
20269
  }
 
20270
  resultobj = SWIG_From_int(static_cast< int >(result));
 
20271
  return resultobj;
 
20272
fail:
 
20273
  return NULL;
 
20274
}
 
20275
 
 
20276
 
 
20277
SWIGINTERN PyObject *_wrap_Slider_GetPageSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20278
  PyObject *resultobj = 0;
 
20279
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20280
  int result;
 
20281
  void *argp1 = 0 ;
 
20282
  int res1 = 0 ;
 
20283
  PyObject *swig_obj[1] ;
 
20284
  
 
20285
  if (!args) SWIG_fail;
 
20286
  swig_obj[0] = args;
 
20287
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20288
  if (!SWIG_IsOK(res1)) {
 
20289
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_GetPageSize" "', expected argument " "1"" of type '" "wxSlider const *""'"); 
 
20290
  }
 
20291
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20292
  {
 
20293
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20294
    result = (int)((wxSlider const *)arg1)->GetPageSize();
 
20295
    wxPyEndAllowThreads(__tstate);
 
20296
    if (PyErr_Occurred()) SWIG_fail;
 
20297
  }
 
20298
  resultobj = SWIG_From_int(static_cast< int >(result));
 
20299
  return resultobj;
 
20300
fail:
 
20301
  return NULL;
 
20302
}
 
20303
 
 
20304
 
 
20305
SWIGINTERN PyObject *_wrap_Slider_SetThumbLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20306
  PyObject *resultobj = 0;
 
20307
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20308
  int arg2 ;
 
20309
  void *argp1 = 0 ;
 
20310
  int res1 = 0 ;
 
20311
  int val2 ;
 
20312
  int ecode2 = 0 ;
 
20313
  PyObject * obj0 = 0 ;
 
20314
  PyObject * obj1 = 0 ;
 
20315
  char *  kwnames[] = {
 
20316
    (char *) "self",(char *) "lenPixels", NULL 
 
20317
  };
 
20318
  
 
20319
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetThumbLength",kwnames,&obj0,&obj1)) SWIG_fail;
 
20320
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20321
  if (!SWIG_IsOK(res1)) {
 
20322
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_SetThumbLength" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20323
  }
 
20324
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20325
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
20326
  if (!SWIG_IsOK(ecode2)) {
 
20327
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Slider_SetThumbLength" "', expected argument " "2"" of type '" "int""'");
 
20328
  } 
 
20329
  arg2 = static_cast< int >(val2);
 
20330
  {
 
20331
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20332
    (arg1)->SetThumbLength(arg2);
 
20333
    wxPyEndAllowThreads(__tstate);
 
20334
    if (PyErr_Occurred()) SWIG_fail;
 
20335
  }
 
20336
  resultobj = SWIG_Py_Void();
 
20337
  return resultobj;
 
20338
fail:
 
20339
  return NULL;
 
20340
}
 
20341
 
 
20342
 
 
20343
SWIGINTERN PyObject *_wrap_Slider_GetThumbLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20344
  PyObject *resultobj = 0;
 
20345
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20346
  int result;
 
20347
  void *argp1 = 0 ;
 
20348
  int res1 = 0 ;
 
20349
  PyObject *swig_obj[1] ;
 
20350
  
 
20351
  if (!args) SWIG_fail;
 
20352
  swig_obj[0] = args;
 
20353
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20354
  if (!SWIG_IsOK(res1)) {
 
20355
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_GetThumbLength" "', expected argument " "1"" of type '" "wxSlider const *""'"); 
 
20356
  }
 
20357
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20358
  {
 
20359
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20360
    result = (int)((wxSlider const *)arg1)->GetThumbLength();
 
20361
    wxPyEndAllowThreads(__tstate);
 
20362
    if (PyErr_Occurred()) SWIG_fail;
 
20363
  }
 
20364
  resultobj = SWIG_From_int(static_cast< int >(result));
 
20365
  return resultobj;
 
20366
fail:
 
20367
  return NULL;
 
20368
}
 
20369
 
 
20370
 
 
20371
SWIGINTERN PyObject *_wrap_Slider_SetTickFreq(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20372
  PyObject *resultobj = 0;
 
20373
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20374
  int arg2 ;
 
20375
  int arg3 = (int) 1 ;
 
20376
  void *argp1 = 0 ;
 
20377
  int res1 = 0 ;
 
20378
  int val2 ;
 
20379
  int ecode2 = 0 ;
 
20380
  int val3 ;
 
20381
  int ecode3 = 0 ;
 
20382
  PyObject * obj0 = 0 ;
 
20383
  PyObject * obj1 = 0 ;
 
20384
  PyObject * obj2 = 0 ;
 
20385
  char *  kwnames[] = {
 
20386
    (char *) "self",(char *) "n",(char *) "pos", NULL 
 
20387
  };
 
20388
  
 
20389
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Slider_SetTickFreq",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
20390
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20391
  if (!SWIG_IsOK(res1)) {
 
20392
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_SetTickFreq" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20393
  }
 
20394
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20395
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
20396
  if (!SWIG_IsOK(ecode2)) {
 
20397
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Slider_SetTickFreq" "', expected argument " "2"" of type '" "int""'");
 
20398
  } 
 
20399
  arg2 = static_cast< int >(val2);
 
20400
  if (obj2) {
 
20401
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
20402
    if (!SWIG_IsOK(ecode3)) {
 
20403
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Slider_SetTickFreq" "', expected argument " "3"" of type '" "int""'");
 
20404
    } 
 
20405
    arg3 = static_cast< int >(val3);
 
20406
  }
 
20407
  {
 
20408
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20409
    (arg1)->SetTickFreq(arg2,arg3);
 
20410
    wxPyEndAllowThreads(__tstate);
 
20411
    if (PyErr_Occurred()) SWIG_fail;
 
20412
  }
 
20413
  resultobj = SWIG_Py_Void();
 
20414
  return resultobj;
 
20415
fail:
 
20416
  return NULL;
 
20417
}
 
20418
 
 
20419
 
 
20420
SWIGINTERN PyObject *_wrap_Slider_GetTickFreq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20421
  PyObject *resultobj = 0;
 
20422
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20423
  int result;
 
20424
  void *argp1 = 0 ;
 
20425
  int res1 = 0 ;
 
20426
  PyObject *swig_obj[1] ;
 
20427
  
 
20428
  if (!args) SWIG_fail;
 
20429
  swig_obj[0] = args;
 
20430
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20431
  if (!SWIG_IsOK(res1)) {
 
20432
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_GetTickFreq" "', expected argument " "1"" of type '" "wxSlider const *""'"); 
 
20433
  }
 
20434
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20435
  {
 
20436
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20437
    result = (int)((wxSlider const *)arg1)->GetTickFreq();
 
20438
    wxPyEndAllowThreads(__tstate);
 
20439
    if (PyErr_Occurred()) SWIG_fail;
 
20440
  }
 
20441
  resultobj = SWIG_From_int(static_cast< int >(result));
 
20442
  return resultobj;
 
20443
fail:
 
20444
  return NULL;
 
20445
}
 
20446
 
 
20447
 
 
20448
SWIGINTERN PyObject *_wrap_Slider_ClearTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20449
  PyObject *resultobj = 0;
 
20450
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20451
  void *argp1 = 0 ;
 
20452
  int res1 = 0 ;
 
20453
  PyObject *swig_obj[1] ;
 
20454
  
 
20455
  if (!args) SWIG_fail;
 
20456
  swig_obj[0] = args;
 
20457
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20458
  if (!SWIG_IsOK(res1)) {
 
20459
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_ClearTicks" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20460
  }
 
20461
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20462
  {
 
20463
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20464
    (arg1)->ClearTicks();
 
20465
    wxPyEndAllowThreads(__tstate);
 
20466
    if (PyErr_Occurred()) SWIG_fail;
 
20467
  }
 
20468
  resultobj = SWIG_Py_Void();
 
20469
  return resultobj;
 
20470
fail:
 
20471
  return NULL;
 
20472
}
 
20473
 
 
20474
 
 
20475
SWIGINTERN PyObject *_wrap_Slider_SetTick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20476
  PyObject *resultobj = 0;
 
20477
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20478
  int arg2 ;
 
20479
  void *argp1 = 0 ;
 
20480
  int res1 = 0 ;
 
20481
  int val2 ;
 
20482
  int ecode2 = 0 ;
 
20483
  PyObject * obj0 = 0 ;
 
20484
  PyObject * obj1 = 0 ;
 
20485
  char *  kwnames[] = {
 
20486
    (char *) "self",(char *) "tickPos", NULL 
 
20487
  };
 
20488
  
 
20489
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Slider_SetTick",kwnames,&obj0,&obj1)) SWIG_fail;
 
20490
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20491
  if (!SWIG_IsOK(res1)) {
 
20492
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_SetTick" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20493
  }
 
20494
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20495
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
20496
  if (!SWIG_IsOK(ecode2)) {
 
20497
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Slider_SetTick" "', expected argument " "2"" of type '" "int""'");
 
20498
  } 
 
20499
  arg2 = static_cast< int >(val2);
 
20500
  {
 
20501
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20502
    (arg1)->SetTick(arg2);
 
20503
    wxPyEndAllowThreads(__tstate);
 
20504
    if (PyErr_Occurred()) SWIG_fail;
 
20505
  }
 
20506
  resultobj = SWIG_Py_Void();
 
20507
  return resultobj;
 
20508
fail:
 
20509
  return NULL;
 
20510
}
 
20511
 
 
20512
 
 
20513
SWIGINTERN PyObject *_wrap_Slider_ClearSel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20514
  PyObject *resultobj = 0;
 
20515
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20516
  void *argp1 = 0 ;
 
20517
  int res1 = 0 ;
 
20518
  PyObject *swig_obj[1] ;
 
20519
  
 
20520
  if (!args) SWIG_fail;
 
20521
  swig_obj[0] = args;
 
20522
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20523
  if (!SWIG_IsOK(res1)) {
 
20524
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_ClearSel" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20525
  }
 
20526
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20527
  {
 
20528
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20529
    (arg1)->ClearSel();
 
20530
    wxPyEndAllowThreads(__tstate);
 
20531
    if (PyErr_Occurred()) SWIG_fail;
 
20532
  }
 
20533
  resultobj = SWIG_Py_Void();
 
20534
  return resultobj;
 
20535
fail:
 
20536
  return NULL;
 
20537
}
 
20538
 
 
20539
 
 
20540
SWIGINTERN PyObject *_wrap_Slider_GetSelEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20541
  PyObject *resultobj = 0;
 
20542
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20543
  int result;
 
20544
  void *argp1 = 0 ;
 
20545
  int res1 = 0 ;
 
20546
  PyObject *swig_obj[1] ;
 
20547
  
 
20548
  if (!args) SWIG_fail;
 
20549
  swig_obj[0] = args;
 
20550
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20551
  if (!SWIG_IsOK(res1)) {
 
20552
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_GetSelEnd" "', expected argument " "1"" of type '" "wxSlider const *""'"); 
 
20553
  }
 
20554
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20555
  {
 
20556
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20557
    result = (int)((wxSlider const *)arg1)->GetSelEnd();
 
20558
    wxPyEndAllowThreads(__tstate);
 
20559
    if (PyErr_Occurred()) SWIG_fail;
 
20560
  }
 
20561
  resultobj = SWIG_From_int(static_cast< int >(result));
 
20562
  return resultobj;
 
20563
fail:
 
20564
  return NULL;
 
20565
}
 
20566
 
 
20567
 
 
20568
SWIGINTERN PyObject *_wrap_Slider_GetSelStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20569
  PyObject *resultobj = 0;
 
20570
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20571
  int result;
 
20572
  void *argp1 = 0 ;
 
20573
  int res1 = 0 ;
 
20574
  PyObject *swig_obj[1] ;
 
20575
  
 
20576
  if (!args) SWIG_fail;
 
20577
  swig_obj[0] = args;
 
20578
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20579
  if (!SWIG_IsOK(res1)) {
 
20580
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_GetSelStart" "', expected argument " "1"" of type '" "wxSlider const *""'"); 
 
20581
  }
 
20582
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20583
  {
 
20584
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20585
    result = (int)((wxSlider const *)arg1)->GetSelStart();
 
20586
    wxPyEndAllowThreads(__tstate);
 
20587
    if (PyErr_Occurred()) SWIG_fail;
 
20588
  }
 
20589
  resultobj = SWIG_From_int(static_cast< int >(result));
 
20590
  return resultobj;
 
20591
fail:
 
20592
  return NULL;
 
20593
}
 
20594
 
 
20595
 
 
20596
SWIGINTERN PyObject *_wrap_Slider_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20597
  PyObject *resultobj = 0;
 
20598
  wxSlider *arg1 = (wxSlider *) 0 ;
 
20599
  int arg2 ;
 
20600
  int arg3 ;
 
20601
  void *argp1 = 0 ;
 
20602
  int res1 = 0 ;
 
20603
  int val2 ;
 
20604
  int ecode2 = 0 ;
 
20605
  int val3 ;
 
20606
  int ecode3 = 0 ;
 
20607
  PyObject * obj0 = 0 ;
 
20608
  PyObject * obj1 = 0 ;
 
20609
  PyObject * obj2 = 0 ;
 
20610
  char *  kwnames[] = {
 
20611
    (char *) "self",(char *) "min",(char *) "max", NULL 
 
20612
  };
 
20613
  
 
20614
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Slider_SetSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
20615
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSlider, 0 |  0 );
 
20616
  if (!SWIG_IsOK(res1)) {
 
20617
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Slider_SetSelection" "', expected argument " "1"" of type '" "wxSlider *""'"); 
 
20618
  }
 
20619
  arg1 = reinterpret_cast< wxSlider * >(argp1);
 
20620
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
20621
  if (!SWIG_IsOK(ecode2)) {
 
20622
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Slider_SetSelection" "', expected argument " "2"" of type '" "int""'");
 
20623
  } 
 
20624
  arg2 = static_cast< int >(val2);
 
20625
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
20626
  if (!SWIG_IsOK(ecode3)) {
 
20627
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Slider_SetSelection" "', expected argument " "3"" of type '" "int""'");
 
20628
  } 
 
20629
  arg3 = static_cast< int >(val3);
 
20630
  {
 
20631
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20632
    (arg1)->SetSelection(arg2,arg3);
 
20633
    wxPyEndAllowThreads(__tstate);
 
20634
    if (PyErr_Occurred()) SWIG_fail;
 
20635
  }
 
20636
  resultobj = SWIG_Py_Void();
 
20637
  return resultobj;
 
20638
fail:
 
20639
  return NULL;
 
20640
}
 
20641
 
 
20642
 
 
20643
SWIGINTERN PyObject *_wrap_Slider_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20644
  PyObject *resultobj = 0;
 
20645
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
20646
  SwigValueWrapper<wxVisualAttributes > result;
 
20647
  int val1 ;
 
20648
  int ecode1 = 0 ;
 
20649
  PyObject * obj0 = 0 ;
 
20650
  char *  kwnames[] = {
 
20651
    (char *) "variant", NULL 
 
20652
  };
 
20653
  
 
20654
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Slider_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
20655
  if (obj0) {
 
20656
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
20657
    if (!SWIG_IsOK(ecode1)) {
 
20658
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Slider_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
20659
    } 
 
20660
    arg1 = static_cast< wxWindowVariant >(val1);
 
20661
  }
 
20662
  {
 
20663
    if (!wxPyCheckForApp()) SWIG_fail;
 
20664
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20665
    result = wxSlider::GetClassDefaultAttributes(arg1);
 
20666
    wxPyEndAllowThreads(__tstate);
 
20667
    if (PyErr_Occurred()) SWIG_fail;
 
20668
  }
 
20669
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
20670
  return resultobj;
 
20671
fail:
 
20672
  return NULL;
 
20673
}
 
20674
 
 
20675
 
 
20676
SWIGINTERN PyObject *Slider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20677
  PyObject *obj;
 
20678
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
20679
  SWIG_TypeNewClientData(SWIGTYPE_p_wxSlider, SWIG_NewClientData(obj));
 
20680
  return SWIG_Py_Void();
 
20681
}
 
20682
 
 
20683
SWIGINTERN PyObject *Slider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20684
  return SWIG_Python_InitShadowInstance(args);
 
20685
}
 
20686
 
 
20687
SWIGINTERN int ToggleButtonNameStr_set(PyObject *) {
 
20688
  SWIG_Error(SWIG_AttributeError,"Variable ToggleButtonNameStr is read-only.");
 
20689
  return 1;
 
20690
}
 
20691
 
 
20692
 
 
20693
SWIGINTERN PyObject *ToggleButtonNameStr_get(void) {
 
20694
  PyObject *pyobj = 0;
 
20695
  
 
20696
  {
 
20697
#if wxUSE_UNICODE
 
20698
    pyobj = PyUnicode_FromWideChar((&wxPyToggleButtonNameStr)->c_str(), (&wxPyToggleButtonNameStr)->Len());
 
20699
#else
 
20700
    pyobj = PyString_FromStringAndSize((&wxPyToggleButtonNameStr)->c_str(), (&wxPyToggleButtonNameStr)->Len());
 
20701
#endif
 
20702
  }
 
20703
  return pyobj;
 
20704
}
 
20705
 
 
20706
 
 
20707
SWIGINTERN PyObject *_wrap_new_ToggleButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20708
  PyObject *resultobj = 0;
 
20709
  wxWindow *arg1 = (wxWindow *) 0 ;
 
20710
  int arg2 = (int) -1 ;
 
20711
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
20712
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
20713
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
20714
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
20715
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
20716
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
20717
  long arg6 = (long) 0 ;
 
20718
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
20719
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
20720
  wxString const &arg8_defvalue = wxPyToggleButtonNameStr ;
 
20721
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
20722
  wxToggleButton *result = 0 ;
 
20723
  void *argp1 = 0 ;
 
20724
  int res1 = 0 ;
 
20725
  int val2 ;
 
20726
  int ecode2 = 0 ;
 
20727
  bool temp3 = false ;
 
20728
  wxPoint temp4 ;
 
20729
  wxSize temp5 ;
 
20730
  long val6 ;
 
20731
  int ecode6 = 0 ;
 
20732
  void *argp7 = 0 ;
 
20733
  int res7 = 0 ;
 
20734
  bool temp8 = false ;
 
20735
  PyObject * obj0 = 0 ;
 
20736
  PyObject * obj1 = 0 ;
 
20737
  PyObject * obj2 = 0 ;
 
20738
  PyObject * obj3 = 0 ;
 
20739
  PyObject * obj4 = 0 ;
 
20740
  PyObject * obj5 = 0 ;
 
20741
  PyObject * obj6 = 0 ;
 
20742
  PyObject * obj7 = 0 ;
 
20743
  char *  kwnames[] = {
 
20744
    (char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
20745
  };
 
20746
  
 
20747
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_ToggleButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
20748
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
20749
  if (!SWIG_IsOK(res1)) {
 
20750
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ToggleButton" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
20751
  }
 
20752
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
20753
  if (obj1) {
 
20754
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
20755
    if (!SWIG_IsOK(ecode2)) {
 
20756
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ToggleButton" "', expected argument " "2"" of type '" "int""'");
 
20757
    } 
 
20758
    arg2 = static_cast< int >(val2);
 
20759
  }
 
20760
  if (obj2) {
 
20761
    {
 
20762
      arg3 = wxString_in_helper(obj2);
 
20763
      if (arg3 == NULL) SWIG_fail;
 
20764
      temp3 = true;
 
20765
    }
 
20766
  }
 
20767
  if (obj3) {
 
20768
    {
 
20769
      arg4 = &temp4;
 
20770
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
20771
    }
 
20772
  }
 
20773
  if (obj4) {
 
20774
    {
 
20775
      arg5 = &temp5;
 
20776
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
20777
    }
 
20778
  }
 
20779
  if (obj5) {
 
20780
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
20781
    if (!SWIG_IsOK(ecode6)) {
 
20782
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ToggleButton" "', expected argument " "6"" of type '" "long""'");
 
20783
    } 
 
20784
    arg6 = static_cast< long >(val6);
 
20785
  }
 
20786
  if (obj6) {
 
20787
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
20788
    if (!SWIG_IsOK(res7)) {
 
20789
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ToggleButton" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
20790
    }
 
20791
    if (!argp7) {
 
20792
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ToggleButton" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
20793
    }
 
20794
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
20795
  }
 
20796
  if (obj7) {
 
20797
    {
 
20798
      arg8 = wxString_in_helper(obj7);
 
20799
      if (arg8 == NULL) SWIG_fail;
 
20800
      temp8 = true;
 
20801
    }
 
20802
  }
 
20803
  {
 
20804
    if (!wxPyCheckForApp()) SWIG_fail;
 
20805
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20806
    result = (wxToggleButton *)new wxToggleButton(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
20807
    wxPyEndAllowThreads(__tstate);
 
20808
    if (PyErr_Occurred()) SWIG_fail;
 
20809
  }
 
20810
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToggleButton, SWIG_POINTER_NEW |  0 );
 
20811
  {
 
20812
    if (temp3)
 
20813
    delete arg3;
 
20814
  }
 
20815
  {
 
20816
    if (temp8)
 
20817
    delete arg8;
 
20818
  }
 
20819
  return resultobj;
 
20820
fail:
 
20821
  {
 
20822
    if (temp3)
 
20823
    delete arg3;
 
20824
  }
 
20825
  {
 
20826
    if (temp8)
 
20827
    delete arg8;
 
20828
  }
 
20829
  return NULL;
 
20830
}
 
20831
 
 
20832
 
 
20833
SWIGINTERN PyObject *_wrap_new_PreToggleButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
20834
  PyObject *resultobj = 0;
 
20835
  wxToggleButton *result = 0 ;
 
20836
  
 
20837
  if (!SWIG_Python_UnpackTuple(args,"new_PreToggleButton",0,0,0)) SWIG_fail;
 
20838
  {
 
20839
    if (!wxPyCheckForApp()) SWIG_fail;
 
20840
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20841
    result = (wxToggleButton *)new wxToggleButton();
 
20842
    wxPyEndAllowThreads(__tstate);
 
20843
    if (PyErr_Occurred()) SWIG_fail;
 
20844
  }
 
20845
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToggleButton, SWIG_POINTER_OWN |  0 );
 
20846
  return resultobj;
 
20847
fail:
 
20848
  return NULL;
 
20849
}
 
20850
 
 
20851
 
 
20852
SWIGINTERN PyObject *_wrap_ToggleButton_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20853
  PyObject *resultobj = 0;
 
20854
  wxToggleButton *arg1 = (wxToggleButton *) 0 ;
 
20855
  wxWindow *arg2 = (wxWindow *) 0 ;
 
20856
  int arg3 = (int) -1 ;
 
20857
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
20858
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
20859
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
20860
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
20861
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
20862
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
20863
  long arg7 = (long) 0 ;
 
20864
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
20865
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
20866
  wxString const &arg9_defvalue = wxPyToggleButtonNameStr ;
 
20867
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
20868
  bool result;
 
20869
  void *argp1 = 0 ;
 
20870
  int res1 = 0 ;
 
20871
  void *argp2 = 0 ;
 
20872
  int res2 = 0 ;
 
20873
  int val3 ;
 
20874
  int ecode3 = 0 ;
 
20875
  bool temp4 = false ;
 
20876
  wxPoint temp5 ;
 
20877
  wxSize temp6 ;
 
20878
  long val7 ;
 
20879
  int ecode7 = 0 ;
 
20880
  void *argp8 = 0 ;
 
20881
  int res8 = 0 ;
 
20882
  bool temp9 = false ;
 
20883
  PyObject * obj0 = 0 ;
 
20884
  PyObject * obj1 = 0 ;
 
20885
  PyObject * obj2 = 0 ;
 
20886
  PyObject * obj3 = 0 ;
 
20887
  PyObject * obj4 = 0 ;
 
20888
  PyObject * obj5 = 0 ;
 
20889
  PyObject * obj6 = 0 ;
 
20890
  PyObject * obj7 = 0 ;
 
20891
  PyObject * obj8 = 0 ;
 
20892
  char *  kwnames[] = {
 
20893
    (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
20894
  };
 
20895
  
 
20896
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:ToggleButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
20897
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToggleButton, 0 |  0 );
 
20898
  if (!SWIG_IsOK(res1)) {
 
20899
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToggleButton_Create" "', expected argument " "1"" of type '" "wxToggleButton *""'"); 
 
20900
  }
 
20901
  arg1 = reinterpret_cast< wxToggleButton * >(argp1);
 
20902
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
20903
  if (!SWIG_IsOK(res2)) {
 
20904
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ToggleButton_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
20905
  }
 
20906
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
20907
  if (obj2) {
 
20908
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
20909
    if (!SWIG_IsOK(ecode3)) {
 
20910
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ToggleButton_Create" "', expected argument " "3"" of type '" "int""'");
 
20911
    } 
 
20912
    arg3 = static_cast< int >(val3);
 
20913
  }
 
20914
  if (obj3) {
 
20915
    {
 
20916
      arg4 = wxString_in_helper(obj3);
 
20917
      if (arg4 == NULL) SWIG_fail;
 
20918
      temp4 = true;
 
20919
    }
 
20920
  }
 
20921
  if (obj4) {
 
20922
    {
 
20923
      arg5 = &temp5;
 
20924
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
20925
    }
 
20926
  }
 
20927
  if (obj5) {
 
20928
    {
 
20929
      arg6 = &temp6;
 
20930
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
20931
    }
 
20932
  }
 
20933
  if (obj6) {
 
20934
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
20935
    if (!SWIG_IsOK(ecode7)) {
 
20936
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ToggleButton_Create" "', expected argument " "7"" of type '" "long""'");
 
20937
    } 
 
20938
    arg7 = static_cast< long >(val7);
 
20939
  }
 
20940
  if (obj7) {
 
20941
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
20942
    if (!SWIG_IsOK(res8)) {
 
20943
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ToggleButton_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
20944
    }
 
20945
    if (!argp8) {
 
20946
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ToggleButton_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
20947
    }
 
20948
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
20949
  }
 
20950
  if (obj8) {
 
20951
    {
 
20952
      arg9 = wxString_in_helper(obj8);
 
20953
      if (arg9 == NULL) SWIG_fail;
 
20954
      temp9 = true;
 
20955
    }
 
20956
  }
 
20957
  {
 
20958
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
20959
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
20960
    wxPyEndAllowThreads(__tstate);
 
20961
    if (PyErr_Occurred()) SWIG_fail;
 
20962
  }
 
20963
  {
 
20964
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
20965
  }
 
20966
  {
 
20967
    if (temp4)
 
20968
    delete arg4;
 
20969
  }
 
20970
  {
 
20971
    if (temp9)
 
20972
    delete arg9;
 
20973
  }
 
20974
  return resultobj;
 
20975
fail:
 
20976
  {
 
20977
    if (temp4)
 
20978
    delete arg4;
 
20979
  }
 
20980
  {
 
20981
    if (temp9)
 
20982
    delete arg9;
 
20983
  }
 
20984
  return NULL;
 
20985
}
 
20986
 
 
20987
 
 
20988
SWIGINTERN PyObject *_wrap_ToggleButton_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
20989
  PyObject *resultobj = 0;
 
20990
  wxToggleButton *arg1 = (wxToggleButton *) 0 ;
 
20991
  bool arg2 ;
 
20992
  void *argp1 = 0 ;
 
20993
  int res1 = 0 ;
 
20994
  bool val2 ;
 
20995
  int ecode2 = 0 ;
 
20996
  PyObject * obj0 = 0 ;
 
20997
  PyObject * obj1 = 0 ;
 
20998
  char *  kwnames[] = {
 
20999
    (char *) "self",(char *) "value", NULL 
 
21000
  };
 
21001
  
 
21002
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToggleButton_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
21003
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToggleButton, 0 |  0 );
 
21004
  if (!SWIG_IsOK(res1)) {
 
21005
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToggleButton_SetValue" "', expected argument " "1"" of type '" "wxToggleButton *""'"); 
 
21006
  }
 
21007
  arg1 = reinterpret_cast< wxToggleButton * >(argp1);
 
21008
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
21009
  if (!SWIG_IsOK(ecode2)) {
 
21010
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToggleButton_SetValue" "', expected argument " "2"" of type '" "bool""'");
 
21011
  } 
 
21012
  arg2 = static_cast< bool >(val2);
 
21013
  {
 
21014
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21015
    (arg1)->SetValue(arg2);
 
21016
    wxPyEndAllowThreads(__tstate);
 
21017
    if (PyErr_Occurred()) SWIG_fail;
 
21018
  }
 
21019
  resultobj = SWIG_Py_Void();
 
21020
  return resultobj;
 
21021
fail:
 
21022
  return NULL;
 
21023
}
 
21024
 
 
21025
 
 
21026
SWIGINTERN PyObject *_wrap_ToggleButton_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21027
  PyObject *resultobj = 0;
 
21028
  wxToggleButton *arg1 = (wxToggleButton *) 0 ;
 
21029
  bool result;
 
21030
  void *argp1 = 0 ;
 
21031
  int res1 = 0 ;
 
21032
  PyObject *swig_obj[1] ;
 
21033
  
 
21034
  if (!args) SWIG_fail;
 
21035
  swig_obj[0] = args;
 
21036
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToggleButton, 0 |  0 );
 
21037
  if (!SWIG_IsOK(res1)) {
 
21038
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToggleButton_GetValue" "', expected argument " "1"" of type '" "wxToggleButton const *""'"); 
 
21039
  }
 
21040
  arg1 = reinterpret_cast< wxToggleButton * >(argp1);
 
21041
  {
 
21042
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21043
    result = (bool)((wxToggleButton const *)arg1)->GetValue();
 
21044
    wxPyEndAllowThreads(__tstate);
 
21045
    if (PyErr_Occurred()) SWIG_fail;
 
21046
  }
 
21047
  {
 
21048
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
21049
  }
 
21050
  return resultobj;
 
21051
fail:
 
21052
  return NULL;
 
21053
}
 
21054
 
 
21055
 
 
21056
SWIGINTERN PyObject *_wrap_ToggleButton_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21057
  PyObject *resultobj = 0;
 
21058
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
21059
  SwigValueWrapper<wxVisualAttributes > result;
 
21060
  int val1 ;
 
21061
  int ecode1 = 0 ;
 
21062
  PyObject * obj0 = 0 ;
 
21063
  char *  kwnames[] = {
 
21064
    (char *) "variant", NULL 
 
21065
  };
 
21066
  
 
21067
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ToggleButton_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
21068
  if (obj0) {
 
21069
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
21070
    if (!SWIG_IsOK(ecode1)) {
 
21071
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToggleButton_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
21072
    } 
 
21073
    arg1 = static_cast< wxWindowVariant >(val1);
 
21074
  }
 
21075
  {
 
21076
    if (!wxPyCheckForApp()) SWIG_fail;
 
21077
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21078
    result = wxToggleButton::GetClassDefaultAttributes(arg1);
 
21079
    wxPyEndAllowThreads(__tstate);
 
21080
    if (PyErr_Occurred()) SWIG_fail;
 
21081
  }
 
21082
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
21083
  return resultobj;
 
21084
fail:
 
21085
  return NULL;
 
21086
}
 
21087
 
 
21088
 
 
21089
SWIGINTERN PyObject *ToggleButton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21090
  PyObject *obj;
 
21091
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
21092
  SWIG_TypeNewClientData(SWIGTYPE_p_wxToggleButton, SWIG_NewClientData(obj));
 
21093
  return SWIG_Py_Void();
 
21094
}
 
21095
 
 
21096
SWIGINTERN PyObject *ToggleButton_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21097
  return SWIG_Python_InitShadowInstance(args);
 
21098
}
 
21099
 
 
21100
SWIGINTERN int NotebookNameStr_set(PyObject *) {
 
21101
  SWIG_Error(SWIG_AttributeError,"Variable NotebookNameStr is read-only.");
 
21102
  return 1;
 
21103
}
 
21104
 
 
21105
 
 
21106
SWIGINTERN PyObject *NotebookNameStr_get(void) {
 
21107
  PyObject *pyobj = 0;
 
21108
  
 
21109
  {
 
21110
#if wxUSE_UNICODE
 
21111
    pyobj = PyUnicode_FromWideChar((&wxPyNotebookNameStr)->c_str(), (&wxPyNotebookNameStr)->Len());
 
21112
#else
 
21113
    pyobj = PyString_FromStringAndSize((&wxPyNotebookNameStr)->c_str(), (&wxPyNotebookNameStr)->Len());
 
21114
#endif
 
21115
  }
 
21116
  return pyobj;
 
21117
}
 
21118
 
 
21119
 
 
21120
SWIGINTERN PyObject *_wrap_new_Notebook(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21121
  PyObject *resultobj = 0;
 
21122
  wxWindow *arg1 = (wxWindow *) 0 ;
 
21123
  int arg2 = (int) -1 ;
 
21124
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
21125
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
21126
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
21127
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
21128
  long arg5 = (long) 0 ;
 
21129
  wxString const &arg6_defvalue = wxPyNotebookNameStr ;
 
21130
  wxString *arg6 = (wxString *) &arg6_defvalue ;
 
21131
  wxNotebook *result = 0 ;
 
21132
  void *argp1 = 0 ;
 
21133
  int res1 = 0 ;
 
21134
  int val2 ;
 
21135
  int ecode2 = 0 ;
 
21136
  wxPoint temp3 ;
 
21137
  wxSize temp4 ;
 
21138
  long val5 ;
 
21139
  int ecode5 = 0 ;
 
21140
  bool temp6 = false ;
 
21141
  PyObject * obj0 = 0 ;
 
21142
  PyObject * obj1 = 0 ;
 
21143
  PyObject * obj2 = 0 ;
 
21144
  PyObject * obj3 = 0 ;
 
21145
  PyObject * obj4 = 0 ;
 
21146
  PyObject * obj5 = 0 ;
 
21147
  char *  kwnames[] = {
 
21148
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
21149
  };
 
21150
  
 
21151
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Notebook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
21152
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
21153
  if (!SWIG_IsOK(res1)) {
 
21154
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Notebook" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
21155
  }
 
21156
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
21157
  if (obj1) {
 
21158
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
21159
    if (!SWIG_IsOK(ecode2)) {
 
21160
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Notebook" "', expected argument " "2"" of type '" "int""'");
 
21161
    } 
 
21162
    arg2 = static_cast< int >(val2);
 
21163
  }
 
21164
  if (obj2) {
 
21165
    {
 
21166
      arg3 = &temp3;
 
21167
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
21168
    }
 
21169
  }
 
21170
  if (obj3) {
 
21171
    {
 
21172
      arg4 = &temp4;
 
21173
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
21174
    }
 
21175
  }
 
21176
  if (obj4) {
 
21177
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
21178
    if (!SWIG_IsOK(ecode5)) {
 
21179
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Notebook" "', expected argument " "5"" of type '" "long""'");
 
21180
    } 
 
21181
    arg5 = static_cast< long >(val5);
 
21182
  }
 
21183
  if (obj5) {
 
21184
    {
 
21185
      arg6 = wxString_in_helper(obj5);
 
21186
      if (arg6 == NULL) SWIG_fail;
 
21187
      temp6 = true;
 
21188
    }
 
21189
  }
 
21190
  {
 
21191
    if (!wxPyCheckForApp()) SWIG_fail;
 
21192
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21193
    result = (wxNotebook *)new wxNotebook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
 
21194
    wxPyEndAllowThreads(__tstate);
 
21195
    if (PyErr_Occurred()) SWIG_fail;
 
21196
  }
 
21197
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotebook, SWIG_POINTER_NEW |  0 );
 
21198
  {
 
21199
    if (temp6)
 
21200
    delete arg6;
 
21201
  }
 
21202
  return resultobj;
 
21203
fail:
 
21204
  {
 
21205
    if (temp6)
 
21206
    delete arg6;
 
21207
  }
 
21208
  return NULL;
 
21209
}
 
21210
 
 
21211
 
 
21212
SWIGINTERN PyObject *_wrap_new_PreNotebook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21213
  PyObject *resultobj = 0;
 
21214
  wxNotebook *result = 0 ;
 
21215
  
 
21216
  if (!SWIG_Python_UnpackTuple(args,"new_PreNotebook",0,0,0)) SWIG_fail;
 
21217
  {
 
21218
    if (!wxPyCheckForApp()) SWIG_fail;
 
21219
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21220
    result = (wxNotebook *)new wxNotebook();
 
21221
    wxPyEndAllowThreads(__tstate);
 
21222
    if (PyErr_Occurred()) SWIG_fail;
 
21223
  }
 
21224
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotebook, SWIG_POINTER_OWN |  0 );
 
21225
  return resultobj;
 
21226
fail:
 
21227
  return NULL;
 
21228
}
 
21229
 
 
21230
 
 
21231
SWIGINTERN PyObject *_wrap_Notebook_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21232
  PyObject *resultobj = 0;
 
21233
  wxNotebook *arg1 = (wxNotebook *) 0 ;
 
21234
  wxWindow *arg2 = (wxWindow *) 0 ;
 
21235
  int arg3 = (int) -1 ;
 
21236
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
21237
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
21238
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
21239
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
21240
  long arg6 = (long) 0 ;
 
21241
  wxString const &arg7_defvalue = wxPyNotebookNameStr ;
 
21242
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
21243
  bool result;
 
21244
  void *argp1 = 0 ;
 
21245
  int res1 = 0 ;
 
21246
  void *argp2 = 0 ;
 
21247
  int res2 = 0 ;
 
21248
  int val3 ;
 
21249
  int ecode3 = 0 ;
 
21250
  wxPoint temp4 ;
 
21251
  wxSize temp5 ;
 
21252
  long val6 ;
 
21253
  int ecode6 = 0 ;
 
21254
  bool temp7 = false ;
 
21255
  PyObject * obj0 = 0 ;
 
21256
  PyObject * obj1 = 0 ;
 
21257
  PyObject * obj2 = 0 ;
 
21258
  PyObject * obj3 = 0 ;
 
21259
  PyObject * obj4 = 0 ;
 
21260
  PyObject * obj5 = 0 ;
 
21261
  PyObject * obj6 = 0 ;
 
21262
  char *  kwnames[] = {
 
21263
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
21264
  };
 
21265
  
 
21266
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Notebook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
21267
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNotebook, 0 |  0 );
 
21268
  if (!SWIG_IsOK(res1)) {
 
21269
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Notebook_Create" "', expected argument " "1"" of type '" "wxNotebook *""'"); 
 
21270
  }
 
21271
  arg1 = reinterpret_cast< wxNotebook * >(argp1);
 
21272
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
21273
  if (!SWIG_IsOK(res2)) {
 
21274
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Notebook_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
21275
  }
 
21276
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
21277
  if (obj2) {
 
21278
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
21279
    if (!SWIG_IsOK(ecode3)) {
 
21280
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Notebook_Create" "', expected argument " "3"" of type '" "int""'");
 
21281
    } 
 
21282
    arg3 = static_cast< int >(val3);
 
21283
  }
 
21284
  if (obj3) {
 
21285
    {
 
21286
      arg4 = &temp4;
 
21287
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
21288
    }
 
21289
  }
 
21290
  if (obj4) {
 
21291
    {
 
21292
      arg5 = &temp5;
 
21293
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
21294
    }
 
21295
  }
 
21296
  if (obj5) {
 
21297
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
21298
    if (!SWIG_IsOK(ecode6)) {
 
21299
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Notebook_Create" "', expected argument " "6"" of type '" "long""'");
 
21300
    } 
 
21301
    arg6 = static_cast< long >(val6);
 
21302
  }
 
21303
  if (obj6) {
 
21304
    {
 
21305
      arg7 = wxString_in_helper(obj6);
 
21306
      if (arg7 == NULL) SWIG_fail;
 
21307
      temp7 = true;
 
21308
    }
 
21309
  }
 
21310
  {
 
21311
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21312
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
21313
    wxPyEndAllowThreads(__tstate);
 
21314
    if (PyErr_Occurred()) SWIG_fail;
 
21315
  }
 
21316
  {
 
21317
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
21318
  }
 
21319
  {
 
21320
    if (temp7)
 
21321
    delete arg7;
 
21322
  }
 
21323
  return resultobj;
 
21324
fail:
 
21325
  {
 
21326
    if (temp7)
 
21327
    delete arg7;
 
21328
  }
 
21329
  return NULL;
 
21330
}
 
21331
 
 
21332
 
 
21333
SWIGINTERN PyObject *_wrap_Notebook_GetRowCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21334
  PyObject *resultobj = 0;
 
21335
  wxNotebook *arg1 = (wxNotebook *) 0 ;
 
21336
  int result;
 
21337
  void *argp1 = 0 ;
 
21338
  int res1 = 0 ;
 
21339
  PyObject *swig_obj[1] ;
 
21340
  
 
21341
  if (!args) SWIG_fail;
 
21342
  swig_obj[0] = args;
 
21343
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotebook, 0 |  0 );
 
21344
  if (!SWIG_IsOK(res1)) {
 
21345
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Notebook_GetRowCount" "', expected argument " "1"" of type '" "wxNotebook const *""'"); 
 
21346
  }
 
21347
  arg1 = reinterpret_cast< wxNotebook * >(argp1);
 
21348
  {
 
21349
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21350
    result = (int)((wxNotebook const *)arg1)->GetRowCount();
 
21351
    wxPyEndAllowThreads(__tstate);
 
21352
    if (PyErr_Occurred()) SWIG_fail;
 
21353
  }
 
21354
  resultobj = SWIG_From_int(static_cast< int >(result));
 
21355
  return resultobj;
 
21356
fail:
 
21357
  return NULL;
 
21358
}
 
21359
 
 
21360
 
 
21361
SWIGINTERN PyObject *_wrap_Notebook_SetPadding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21362
  PyObject *resultobj = 0;
 
21363
  wxNotebook *arg1 = (wxNotebook *) 0 ;
 
21364
  wxSize *arg2 = 0 ;
 
21365
  void *argp1 = 0 ;
 
21366
  int res1 = 0 ;
 
21367
  wxSize temp2 ;
 
21368
  PyObject * obj0 = 0 ;
 
21369
  PyObject * obj1 = 0 ;
 
21370
  char *  kwnames[] = {
 
21371
    (char *) "self",(char *) "padding", NULL 
 
21372
  };
 
21373
  
 
21374
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_SetPadding",kwnames,&obj0,&obj1)) SWIG_fail;
 
21375
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNotebook, 0 |  0 );
 
21376
  if (!SWIG_IsOK(res1)) {
 
21377
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Notebook_SetPadding" "', expected argument " "1"" of type '" "wxNotebook *""'"); 
 
21378
  }
 
21379
  arg1 = reinterpret_cast< wxNotebook * >(argp1);
 
21380
  {
 
21381
    arg2 = &temp2;
 
21382
    if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
 
21383
  }
 
21384
  {
 
21385
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21386
    (arg1)->SetPadding((wxSize const &)*arg2);
 
21387
    wxPyEndAllowThreads(__tstate);
 
21388
    if (PyErr_Occurred()) SWIG_fail;
 
21389
  }
 
21390
  resultobj = SWIG_Py_Void();
 
21391
  return resultobj;
 
21392
fail:
 
21393
  return NULL;
 
21394
}
 
21395
 
 
21396
 
 
21397
SWIGINTERN PyObject *_wrap_Notebook_SetTabSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21398
  PyObject *resultobj = 0;
 
21399
  wxNotebook *arg1 = (wxNotebook *) 0 ;
 
21400
  wxSize *arg2 = 0 ;
 
21401
  void *argp1 = 0 ;
 
21402
  int res1 = 0 ;
 
21403
  wxSize temp2 ;
 
21404
  PyObject * obj0 = 0 ;
 
21405
  PyObject * obj1 = 0 ;
 
21406
  char *  kwnames[] = {
 
21407
    (char *) "self",(char *) "sz", NULL 
 
21408
  };
 
21409
  
 
21410
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_SetTabSize",kwnames,&obj0,&obj1)) SWIG_fail;
 
21411
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNotebook, 0 |  0 );
 
21412
  if (!SWIG_IsOK(res1)) {
 
21413
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Notebook_SetTabSize" "', expected argument " "1"" of type '" "wxNotebook *""'"); 
 
21414
  }
 
21415
  arg1 = reinterpret_cast< wxNotebook * >(argp1);
 
21416
  {
 
21417
    arg2 = &temp2;
 
21418
    if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
 
21419
  }
 
21420
  {
 
21421
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21422
    (arg1)->SetTabSize((wxSize const &)*arg2);
 
21423
    wxPyEndAllowThreads(__tstate);
 
21424
    if (PyErr_Occurred()) SWIG_fail;
 
21425
  }
 
21426
  resultobj = SWIG_Py_Void();
 
21427
  return resultobj;
 
21428
fail:
 
21429
  return NULL;
 
21430
}
 
21431
 
 
21432
 
 
21433
SWIGINTERN PyObject *_wrap_Notebook_GetThemeBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21434
  PyObject *resultobj = 0;
 
21435
  wxNotebook *arg1 = (wxNotebook *) 0 ;
 
21436
  wxColour result;
 
21437
  void *argp1 = 0 ;
 
21438
  int res1 = 0 ;
 
21439
  PyObject *swig_obj[1] ;
 
21440
  
 
21441
  if (!args) SWIG_fail;
 
21442
  swig_obj[0] = args;
 
21443
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotebook, 0 |  0 );
 
21444
  if (!SWIG_IsOK(res1)) {
 
21445
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Notebook_GetThemeBackgroundColour" "', expected argument " "1"" of type '" "wxNotebook const *""'"); 
 
21446
  }
 
21447
  arg1 = reinterpret_cast< wxNotebook * >(argp1);
 
21448
  {
 
21449
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21450
    result = ((wxNotebook const *)arg1)->GetThemeBackgroundColour();
 
21451
    wxPyEndAllowThreads(__tstate);
 
21452
    if (PyErr_Occurred()) SWIG_fail;
 
21453
  }
 
21454
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
21455
  return resultobj;
 
21456
fail:
 
21457
  return NULL;
 
21458
}
 
21459
 
 
21460
 
 
21461
SWIGINTERN PyObject *_wrap_Notebook_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21462
  PyObject *resultobj = 0;
 
21463
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
21464
  SwigValueWrapper<wxVisualAttributes > result;
 
21465
  int val1 ;
 
21466
  int ecode1 = 0 ;
 
21467
  PyObject * obj0 = 0 ;
 
21468
  char *  kwnames[] = {
 
21469
    (char *) "variant", NULL 
 
21470
  };
 
21471
  
 
21472
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Notebook_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
21473
  if (obj0) {
 
21474
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
21475
    if (!SWIG_IsOK(ecode1)) {
 
21476
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Notebook_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
21477
    } 
 
21478
    arg1 = static_cast< wxWindowVariant >(val1);
 
21479
  }
 
21480
  {
 
21481
    if (!wxPyCheckForApp()) SWIG_fail;
 
21482
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21483
    result = wxNotebook::GetClassDefaultAttributes(arg1);
 
21484
    wxPyEndAllowThreads(__tstate);
 
21485
    if (PyErr_Occurred()) SWIG_fail;
 
21486
  }
 
21487
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
21488
  return resultobj;
 
21489
fail:
 
21490
  return NULL;
 
21491
}
 
21492
 
 
21493
 
 
21494
SWIGINTERN PyObject *_wrap_Notebook_SendPageChangingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21495
  PyObject *resultobj = 0;
 
21496
  wxNotebook *arg1 = (wxNotebook *) 0 ;
 
21497
  int arg2 ;
 
21498
  bool result;
 
21499
  void *argp1 = 0 ;
 
21500
  int res1 = 0 ;
 
21501
  int val2 ;
 
21502
  int ecode2 = 0 ;
 
21503
  PyObject * obj0 = 0 ;
 
21504
  PyObject * obj1 = 0 ;
 
21505
  char *  kwnames[] = {
 
21506
    (char *) "self",(char *) "nPage", NULL 
 
21507
  };
 
21508
  
 
21509
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Notebook_SendPageChangingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
 
21510
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNotebook, 0 |  0 );
 
21511
  if (!SWIG_IsOK(res1)) {
 
21512
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Notebook_SendPageChangingEvent" "', expected argument " "1"" of type '" "wxNotebook *""'"); 
 
21513
  }
 
21514
  arg1 = reinterpret_cast< wxNotebook * >(argp1);
 
21515
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
21516
  if (!SWIG_IsOK(ecode2)) {
 
21517
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Notebook_SendPageChangingEvent" "', expected argument " "2"" of type '" "int""'");
 
21518
  } 
 
21519
  arg2 = static_cast< int >(val2);
 
21520
  {
 
21521
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21522
    result = (bool)(arg1)->SendPageChangingEvent(arg2);
 
21523
    wxPyEndAllowThreads(__tstate);
 
21524
    if (PyErr_Occurred()) SWIG_fail;
 
21525
  }
 
21526
  {
 
21527
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
21528
  }
 
21529
  return resultobj;
 
21530
fail:
 
21531
  return NULL;
 
21532
}
 
21533
 
 
21534
 
 
21535
SWIGINTERN PyObject *_wrap_Notebook_SendPageChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21536
  PyObject *resultobj = 0;
 
21537
  wxNotebook *arg1 = (wxNotebook *) 0 ;
 
21538
  int arg2 ;
 
21539
  int arg3 = (int) -1 ;
 
21540
  void *argp1 = 0 ;
 
21541
  int res1 = 0 ;
 
21542
  int val2 ;
 
21543
  int ecode2 = 0 ;
 
21544
  int val3 ;
 
21545
  int ecode3 = 0 ;
 
21546
  PyObject * obj0 = 0 ;
 
21547
  PyObject * obj1 = 0 ;
 
21548
  PyObject * obj2 = 0 ;
 
21549
  char *  kwnames[] = {
 
21550
    (char *) "self",(char *) "nPageOld",(char *) "nPageNew", NULL 
 
21551
  };
 
21552
  
 
21553
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Notebook_SendPageChangedEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
21554
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNotebook, 0 |  0 );
 
21555
  if (!SWIG_IsOK(res1)) {
 
21556
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Notebook_SendPageChangedEvent" "', expected argument " "1"" of type '" "wxNotebook *""'"); 
 
21557
  }
 
21558
  arg1 = reinterpret_cast< wxNotebook * >(argp1);
 
21559
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
21560
  if (!SWIG_IsOK(ecode2)) {
 
21561
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Notebook_SendPageChangedEvent" "', expected argument " "2"" of type '" "int""'");
 
21562
  } 
 
21563
  arg2 = static_cast< int >(val2);
 
21564
  if (obj2) {
 
21565
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
21566
    if (!SWIG_IsOK(ecode3)) {
 
21567
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Notebook_SendPageChangedEvent" "', expected argument " "3"" of type '" "int""'");
 
21568
    } 
 
21569
    arg3 = static_cast< int >(val3);
 
21570
  }
 
21571
  {
 
21572
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21573
    (arg1)->SendPageChangedEvent(arg2,arg3);
 
21574
    wxPyEndAllowThreads(__tstate);
 
21575
    if (PyErr_Occurred()) SWIG_fail;
 
21576
  }
 
21577
  resultobj = SWIG_Py_Void();
 
21578
  return resultobj;
 
21579
fail:
 
21580
  return NULL;
 
21581
}
 
21582
 
 
21583
 
 
21584
SWIGINTERN PyObject *Notebook_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21585
  PyObject *obj;
 
21586
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
21587
  SWIG_TypeNewClientData(SWIGTYPE_p_wxNotebook, SWIG_NewClientData(obj));
 
21588
  return SWIG_Py_Void();
 
21589
}
 
21590
 
 
21591
SWIGINTERN PyObject *Notebook_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21592
  return SWIG_Python_InitShadowInstance(args);
 
21593
}
 
21594
 
 
21595
SWIGINTERN PyObject *_wrap_new_Listbook(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21596
  PyObject *resultobj = 0;
 
21597
  wxWindow *arg1 = (wxWindow *) 0 ;
 
21598
  int arg2 = (int) -1 ;
 
21599
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
21600
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
21601
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
21602
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
21603
  long arg5 = (long) 0 ;
 
21604
  wxString const &arg6_defvalue = wxPyEmptyString ;
 
21605
  wxString *arg6 = (wxString *) &arg6_defvalue ;
 
21606
  wxListbook *result = 0 ;
 
21607
  void *argp1 = 0 ;
 
21608
  int res1 = 0 ;
 
21609
  int val2 ;
 
21610
  int ecode2 = 0 ;
 
21611
  wxPoint temp3 ;
 
21612
  wxSize temp4 ;
 
21613
  long val5 ;
 
21614
  int ecode5 = 0 ;
 
21615
  bool temp6 = false ;
 
21616
  PyObject * obj0 = 0 ;
 
21617
  PyObject * obj1 = 0 ;
 
21618
  PyObject * obj2 = 0 ;
 
21619
  PyObject * obj3 = 0 ;
 
21620
  PyObject * obj4 = 0 ;
 
21621
  PyObject * obj5 = 0 ;
 
21622
  char *  kwnames[] = {
 
21623
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
21624
  };
 
21625
  
 
21626
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Listbook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
21627
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
21628
  if (!SWIG_IsOK(res1)) {
 
21629
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Listbook" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
21630
  }
 
21631
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
21632
  if (obj1) {
 
21633
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
21634
    if (!SWIG_IsOK(ecode2)) {
 
21635
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Listbook" "', expected argument " "2"" of type '" "int""'");
 
21636
    } 
 
21637
    arg2 = static_cast< int >(val2);
 
21638
  }
 
21639
  if (obj2) {
 
21640
    {
 
21641
      arg3 = &temp3;
 
21642
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
21643
    }
 
21644
  }
 
21645
  if (obj3) {
 
21646
    {
 
21647
      arg4 = &temp4;
 
21648
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
21649
    }
 
21650
  }
 
21651
  if (obj4) {
 
21652
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
21653
    if (!SWIG_IsOK(ecode5)) {
 
21654
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Listbook" "', expected argument " "5"" of type '" "long""'");
 
21655
    } 
 
21656
    arg5 = static_cast< long >(val5);
 
21657
  }
 
21658
  if (obj5) {
 
21659
    {
 
21660
      arg6 = wxString_in_helper(obj5);
 
21661
      if (arg6 == NULL) SWIG_fail;
 
21662
      temp6 = true;
 
21663
    }
 
21664
  }
 
21665
  {
 
21666
    if (!wxPyCheckForApp()) SWIG_fail;
 
21667
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21668
    result = (wxListbook *)new wxListbook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
 
21669
    wxPyEndAllowThreads(__tstate);
 
21670
    if (PyErr_Occurred()) SWIG_fail;
 
21671
  }
 
21672
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListbook, SWIG_POINTER_NEW |  0 );
 
21673
  {
 
21674
    if (temp6)
 
21675
    delete arg6;
 
21676
  }
 
21677
  return resultobj;
 
21678
fail:
 
21679
  {
 
21680
    if (temp6)
 
21681
    delete arg6;
 
21682
  }
 
21683
  return NULL;
 
21684
}
 
21685
 
 
21686
 
 
21687
SWIGINTERN PyObject *_wrap_new_PreListbook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21688
  PyObject *resultobj = 0;
 
21689
  wxListbook *result = 0 ;
 
21690
  
 
21691
  if (!SWIG_Python_UnpackTuple(args,"new_PreListbook",0,0,0)) SWIG_fail;
 
21692
  {
 
21693
    if (!wxPyCheckForApp()) SWIG_fail;
 
21694
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21695
    result = (wxListbook *)new wxListbook();
 
21696
    wxPyEndAllowThreads(__tstate);
 
21697
    if (PyErr_Occurred()) SWIG_fail;
 
21698
  }
 
21699
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListbook, SWIG_POINTER_OWN |  0 );
 
21700
  return resultobj;
 
21701
fail:
 
21702
  return NULL;
 
21703
}
 
21704
 
 
21705
 
 
21706
SWIGINTERN PyObject *_wrap_Listbook_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21707
  PyObject *resultobj = 0;
 
21708
  wxListbook *arg1 = (wxListbook *) 0 ;
 
21709
  wxWindow *arg2 = (wxWindow *) 0 ;
 
21710
  int arg3 = (int) -1 ;
 
21711
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
21712
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
21713
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
21714
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
21715
  long arg6 = (long) 0 ;
 
21716
  wxString const &arg7_defvalue = wxPyEmptyString ;
 
21717
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
21718
  bool result;
 
21719
  void *argp1 = 0 ;
 
21720
  int res1 = 0 ;
 
21721
  void *argp2 = 0 ;
 
21722
  int res2 = 0 ;
 
21723
  int val3 ;
 
21724
  int ecode3 = 0 ;
 
21725
  wxPoint temp4 ;
 
21726
  wxSize temp5 ;
 
21727
  long val6 ;
 
21728
  int ecode6 = 0 ;
 
21729
  bool temp7 = false ;
 
21730
  PyObject * obj0 = 0 ;
 
21731
  PyObject * obj1 = 0 ;
 
21732
  PyObject * obj2 = 0 ;
 
21733
  PyObject * obj3 = 0 ;
 
21734
  PyObject * obj4 = 0 ;
 
21735
  PyObject * obj5 = 0 ;
 
21736
  PyObject * obj6 = 0 ;
 
21737
  char *  kwnames[] = {
 
21738
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
21739
  };
 
21740
  
 
21741
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Listbook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
21742
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListbook, 0 |  0 );
 
21743
  if (!SWIG_IsOK(res1)) {
 
21744
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Listbook_Create" "', expected argument " "1"" of type '" "wxListbook *""'"); 
 
21745
  }
 
21746
  arg1 = reinterpret_cast< wxListbook * >(argp1);
 
21747
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
21748
  if (!SWIG_IsOK(res2)) {
 
21749
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Listbook_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
21750
  }
 
21751
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
21752
  if (obj2) {
 
21753
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
21754
    if (!SWIG_IsOK(ecode3)) {
 
21755
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Listbook_Create" "', expected argument " "3"" of type '" "int""'");
 
21756
    } 
 
21757
    arg3 = static_cast< int >(val3);
 
21758
  }
 
21759
  if (obj3) {
 
21760
    {
 
21761
      arg4 = &temp4;
 
21762
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
21763
    }
 
21764
  }
 
21765
  if (obj4) {
 
21766
    {
 
21767
      arg5 = &temp5;
 
21768
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
21769
    }
 
21770
  }
 
21771
  if (obj5) {
 
21772
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
21773
    if (!SWIG_IsOK(ecode6)) {
 
21774
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Listbook_Create" "', expected argument " "6"" of type '" "long""'");
 
21775
    } 
 
21776
    arg6 = static_cast< long >(val6);
 
21777
  }
 
21778
  if (obj6) {
 
21779
    {
 
21780
      arg7 = wxString_in_helper(obj6);
 
21781
      if (arg7 == NULL) SWIG_fail;
 
21782
      temp7 = true;
 
21783
    }
 
21784
  }
 
21785
  {
 
21786
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21787
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
21788
    wxPyEndAllowThreads(__tstate);
 
21789
    if (PyErr_Occurred()) SWIG_fail;
 
21790
  }
 
21791
  {
 
21792
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
21793
  }
 
21794
  {
 
21795
    if (temp7)
 
21796
    delete arg7;
 
21797
  }
 
21798
  return resultobj;
 
21799
fail:
 
21800
  {
 
21801
    if (temp7)
 
21802
    delete arg7;
 
21803
  }
 
21804
  return NULL;
 
21805
}
 
21806
 
 
21807
 
 
21808
SWIGINTERN PyObject *_wrap_Listbook_GetListView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21809
  PyObject *resultobj = 0;
 
21810
  wxListbook *arg1 = (wxListbook *) 0 ;
 
21811
  wxListView *result = 0 ;
 
21812
  void *argp1 = 0 ;
 
21813
  int res1 = 0 ;
 
21814
  PyObject *swig_obj[1] ;
 
21815
  
 
21816
  if (!args) SWIG_fail;
 
21817
  swig_obj[0] = args;
 
21818
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListbook, 0 |  0 );
 
21819
  if (!SWIG_IsOK(res1)) {
 
21820
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Listbook_GetListView" "', expected argument " "1"" of type '" "wxListbook *""'"); 
 
21821
  }
 
21822
  arg1 = reinterpret_cast< wxListbook * >(argp1);
 
21823
  {
 
21824
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21825
    result = (wxListView *)(arg1)->GetListView();
 
21826
    wxPyEndAllowThreads(__tstate);
 
21827
    if (PyErr_Occurred()) SWIG_fail;
 
21828
  }
 
21829
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListView, 0 |  0 );
 
21830
  return resultobj;
 
21831
fail:
 
21832
  return NULL;
 
21833
}
 
21834
 
 
21835
 
 
21836
SWIGINTERN PyObject *Listbook_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21837
  PyObject *obj;
 
21838
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
21839
  SWIG_TypeNewClientData(SWIGTYPE_p_wxListbook, SWIG_NewClientData(obj));
 
21840
  return SWIG_Py_Void();
 
21841
}
 
21842
 
 
21843
SWIGINTERN PyObject *Listbook_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21844
  return SWIG_Python_InitShadowInstance(args);
 
21845
}
 
21846
 
 
21847
SWIGINTERN PyObject *_wrap_new_Choicebook(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21848
  PyObject *resultobj = 0;
 
21849
  wxWindow *arg1 = (wxWindow *) 0 ;
 
21850
  int arg2 ;
 
21851
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
21852
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
21853
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
21854
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
21855
  long arg5 = (long) 0 ;
 
21856
  wxString const &arg6_defvalue = wxPyEmptyString ;
 
21857
  wxString *arg6 = (wxString *) &arg6_defvalue ;
 
21858
  wxChoicebook *result = 0 ;
 
21859
  void *argp1 = 0 ;
 
21860
  int res1 = 0 ;
 
21861
  int val2 ;
 
21862
  int ecode2 = 0 ;
 
21863
  wxPoint temp3 ;
 
21864
  wxSize temp4 ;
 
21865
  long val5 ;
 
21866
  int ecode5 = 0 ;
 
21867
  bool temp6 = false ;
 
21868
  PyObject * obj0 = 0 ;
 
21869
  PyObject * obj1 = 0 ;
 
21870
  PyObject * obj2 = 0 ;
 
21871
  PyObject * obj3 = 0 ;
 
21872
  PyObject * obj4 = 0 ;
 
21873
  PyObject * obj5 = 0 ;
 
21874
  char *  kwnames[] = {
 
21875
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
21876
  };
 
21877
  
 
21878
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_Choicebook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
21879
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
21880
  if (!SWIG_IsOK(res1)) {
 
21881
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Choicebook" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
21882
  }
 
21883
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
21884
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
21885
  if (!SWIG_IsOK(ecode2)) {
 
21886
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Choicebook" "', expected argument " "2"" of type '" "int""'");
 
21887
  } 
 
21888
  arg2 = static_cast< int >(val2);
 
21889
  if (obj2) {
 
21890
    {
 
21891
      arg3 = &temp3;
 
21892
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
21893
    }
 
21894
  }
 
21895
  if (obj3) {
 
21896
    {
 
21897
      arg4 = &temp4;
 
21898
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
21899
    }
 
21900
  }
 
21901
  if (obj4) {
 
21902
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
21903
    if (!SWIG_IsOK(ecode5)) {
 
21904
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Choicebook" "', expected argument " "5"" of type '" "long""'");
 
21905
    } 
 
21906
    arg5 = static_cast< long >(val5);
 
21907
  }
 
21908
  if (obj5) {
 
21909
    {
 
21910
      arg6 = wxString_in_helper(obj5);
 
21911
      if (arg6 == NULL) SWIG_fail;
 
21912
      temp6 = true;
 
21913
    }
 
21914
  }
 
21915
  {
 
21916
    if (!wxPyCheckForApp()) SWIG_fail;
 
21917
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21918
    result = (wxChoicebook *)new wxChoicebook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
 
21919
    wxPyEndAllowThreads(__tstate);
 
21920
    if (PyErr_Occurred()) SWIG_fail;
 
21921
  }
 
21922
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChoicebook, SWIG_POINTER_NEW |  0 );
 
21923
  {
 
21924
    if (temp6)
 
21925
    delete arg6;
 
21926
  }
 
21927
  return resultobj;
 
21928
fail:
 
21929
  {
 
21930
    if (temp6)
 
21931
    delete arg6;
 
21932
  }
 
21933
  return NULL;
 
21934
}
 
21935
 
 
21936
 
 
21937
SWIGINTERN PyObject *_wrap_new_PreChoicebook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
21938
  PyObject *resultobj = 0;
 
21939
  wxChoicebook *result = 0 ;
 
21940
  
 
21941
  if (!SWIG_Python_UnpackTuple(args,"new_PreChoicebook",0,0,0)) SWIG_fail;
 
21942
  {
 
21943
    if (!wxPyCheckForApp()) SWIG_fail;
 
21944
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
21945
    result = (wxChoicebook *)new wxChoicebook();
 
21946
    wxPyEndAllowThreads(__tstate);
 
21947
    if (PyErr_Occurred()) SWIG_fail;
 
21948
  }
 
21949
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChoicebook, SWIG_POINTER_OWN |  0 );
 
21950
  return resultobj;
 
21951
fail:
 
21952
  return NULL;
 
21953
}
 
21954
 
 
21955
 
 
21956
SWIGINTERN PyObject *_wrap_Choicebook_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
21957
  PyObject *resultobj = 0;
 
21958
  wxChoicebook *arg1 = (wxChoicebook *) 0 ;
 
21959
  wxWindow *arg2 = (wxWindow *) 0 ;
 
21960
  int arg3 ;
 
21961
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
21962
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
21963
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
21964
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
21965
  long arg6 = (long) 0 ;
 
21966
  wxString const &arg7_defvalue = wxPyEmptyString ;
 
21967
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
21968
  bool result;
 
21969
  void *argp1 = 0 ;
 
21970
  int res1 = 0 ;
 
21971
  void *argp2 = 0 ;
 
21972
  int res2 = 0 ;
 
21973
  int val3 ;
 
21974
  int ecode3 = 0 ;
 
21975
  wxPoint temp4 ;
 
21976
  wxSize temp5 ;
 
21977
  long val6 ;
 
21978
  int ecode6 = 0 ;
 
21979
  bool temp7 = false ;
 
21980
  PyObject * obj0 = 0 ;
 
21981
  PyObject * obj1 = 0 ;
 
21982
  PyObject * obj2 = 0 ;
 
21983
  PyObject * obj3 = 0 ;
 
21984
  PyObject * obj4 = 0 ;
 
21985
  PyObject * obj5 = 0 ;
 
21986
  PyObject * obj6 = 0 ;
 
21987
  char *  kwnames[] = {
 
21988
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
21989
  };
 
21990
  
 
21991
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Choicebook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
21992
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChoicebook, 0 |  0 );
 
21993
  if (!SWIG_IsOK(res1)) {
 
21994
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Choicebook_Create" "', expected argument " "1"" of type '" "wxChoicebook *""'"); 
 
21995
  }
 
21996
  arg1 = reinterpret_cast< wxChoicebook * >(argp1);
 
21997
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
21998
  if (!SWIG_IsOK(res2)) {
 
21999
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Choicebook_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
22000
  }
 
22001
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
22002
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
22003
  if (!SWIG_IsOK(ecode3)) {
 
22004
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Choicebook_Create" "', expected argument " "3"" of type '" "int""'");
 
22005
  } 
 
22006
  arg3 = static_cast< int >(val3);
 
22007
  if (obj3) {
 
22008
    {
 
22009
      arg4 = &temp4;
 
22010
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
22011
    }
 
22012
  }
 
22013
  if (obj4) {
 
22014
    {
 
22015
      arg5 = &temp5;
 
22016
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
22017
    }
 
22018
  }
 
22019
  if (obj5) {
 
22020
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
22021
    if (!SWIG_IsOK(ecode6)) {
 
22022
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Choicebook_Create" "', expected argument " "6"" of type '" "long""'");
 
22023
    } 
 
22024
    arg6 = static_cast< long >(val6);
 
22025
  }
 
22026
  if (obj6) {
 
22027
    {
 
22028
      arg7 = wxString_in_helper(obj6);
 
22029
      if (arg7 == NULL) SWIG_fail;
 
22030
      temp7 = true;
 
22031
    }
 
22032
  }
 
22033
  {
 
22034
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22035
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
22036
    wxPyEndAllowThreads(__tstate);
 
22037
    if (PyErr_Occurred()) SWIG_fail;
 
22038
  }
 
22039
  {
 
22040
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
22041
  }
 
22042
  {
 
22043
    if (temp7)
 
22044
    delete arg7;
 
22045
  }
 
22046
  return resultobj;
 
22047
fail:
 
22048
  {
 
22049
    if (temp7)
 
22050
    delete arg7;
 
22051
  }
 
22052
  return NULL;
 
22053
}
 
22054
 
 
22055
 
 
22056
SWIGINTERN PyObject *_wrap_Choicebook_GetChoiceCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22057
  PyObject *resultobj = 0;
 
22058
  wxChoicebook *arg1 = (wxChoicebook *) 0 ;
 
22059
  wxChoice *result = 0 ;
 
22060
  void *argp1 = 0 ;
 
22061
  int res1 = 0 ;
 
22062
  PyObject *swig_obj[1] ;
 
22063
  
 
22064
  if (!args) SWIG_fail;
 
22065
  swig_obj[0] = args;
 
22066
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChoicebook, 0 |  0 );
 
22067
  if (!SWIG_IsOK(res1)) {
 
22068
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Choicebook_GetChoiceCtrl" "', expected argument " "1"" of type '" "wxChoicebook const *""'"); 
 
22069
  }
 
22070
  arg1 = reinterpret_cast< wxChoicebook * >(argp1);
 
22071
  {
 
22072
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22073
    result = (wxChoice *)((wxChoicebook const *)arg1)->GetChoiceCtrl();
 
22074
    wxPyEndAllowThreads(__tstate);
 
22075
    if (PyErr_Occurred()) SWIG_fail;
 
22076
  }
 
22077
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChoice, 0 |  0 );
 
22078
  return resultobj;
 
22079
fail:
 
22080
  return NULL;
 
22081
}
 
22082
 
 
22083
 
 
22084
SWIGINTERN PyObject *Choicebook_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22085
  PyObject *obj;
 
22086
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
22087
  SWIG_TypeNewClientData(SWIGTYPE_p_wxChoicebook, SWIG_NewClientData(obj));
 
22088
  return SWIG_Py_Void();
 
22089
}
 
22090
 
 
22091
SWIGINTERN PyObject *Choicebook_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22092
  return SWIG_Python_InitShadowInstance(args);
 
22093
}
 
22094
 
 
22095
SWIGINTERN PyObject *_wrap_new_Treebook(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
22096
  PyObject *resultobj = 0;
 
22097
  wxWindow *arg1 = (wxWindow *) 0 ;
 
22098
  int arg2 ;
 
22099
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
22100
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
22101
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
22102
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
22103
  long arg5 = (long) wxBK_DEFAULT ;
 
22104
  wxString const &arg6_defvalue = wxPyEmptyString ;
 
22105
  wxString *arg6 = (wxString *) &arg6_defvalue ;
 
22106
  wxTreebook *result = 0 ;
 
22107
  void *argp1 = 0 ;
 
22108
  int res1 = 0 ;
 
22109
  int val2 ;
 
22110
  int ecode2 = 0 ;
 
22111
  wxPoint temp3 ;
 
22112
  wxSize temp4 ;
 
22113
  long val5 ;
 
22114
  int ecode5 = 0 ;
 
22115
  bool temp6 = false ;
 
22116
  PyObject * obj0 = 0 ;
 
22117
  PyObject * obj1 = 0 ;
 
22118
  PyObject * obj2 = 0 ;
 
22119
  PyObject * obj3 = 0 ;
 
22120
  PyObject * obj4 = 0 ;
 
22121
  PyObject * obj5 = 0 ;
 
22122
  char *  kwnames[] = {
 
22123
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
22124
  };
 
22125
  
 
22126
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_Treebook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
22127
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
22128
  if (!SWIG_IsOK(res1)) {
 
22129
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Treebook" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
22130
  }
 
22131
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
22132
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
22133
  if (!SWIG_IsOK(ecode2)) {
 
22134
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Treebook" "', expected argument " "2"" of type '" "int""'");
 
22135
  } 
 
22136
  arg2 = static_cast< int >(val2);
 
22137
  if (obj2) {
 
22138
    {
 
22139
      arg3 = &temp3;
 
22140
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
22141
    }
 
22142
  }
 
22143
  if (obj3) {
 
22144
    {
 
22145
      arg4 = &temp4;
 
22146
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
22147
    }
 
22148
  }
 
22149
  if (obj4) {
 
22150
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
22151
    if (!SWIG_IsOK(ecode5)) {
 
22152
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Treebook" "', expected argument " "5"" of type '" "long""'");
 
22153
    } 
 
22154
    arg5 = static_cast< long >(val5);
 
22155
  }
 
22156
  if (obj5) {
 
22157
    {
 
22158
      arg6 = wxString_in_helper(obj5);
 
22159
      if (arg6 == NULL) SWIG_fail;
 
22160
      temp6 = true;
 
22161
    }
 
22162
  }
 
22163
  {
 
22164
    if (!wxPyCheckForApp()) SWIG_fail;
 
22165
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22166
    result = (wxTreebook *)new wxTreebook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
 
22167
    wxPyEndAllowThreads(__tstate);
 
22168
    if (PyErr_Occurred()) SWIG_fail;
 
22169
  }
 
22170
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTreebook, SWIG_POINTER_NEW |  0 );
 
22171
  {
 
22172
    if (temp6)
 
22173
    delete arg6;
 
22174
  }
 
22175
  return resultobj;
 
22176
fail:
 
22177
  {
 
22178
    if (temp6)
 
22179
    delete arg6;
 
22180
  }
 
22181
  return NULL;
 
22182
}
 
22183
 
 
22184
 
 
22185
SWIGINTERN PyObject *_wrap_new_PreTreebook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22186
  PyObject *resultobj = 0;
 
22187
  wxTreebook *result = 0 ;
 
22188
  
 
22189
  if (!SWIG_Python_UnpackTuple(args,"new_PreTreebook",0,0,0)) SWIG_fail;
 
22190
  {
 
22191
    if (!wxPyCheckForApp()) SWIG_fail;
 
22192
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22193
    result = (wxTreebook *)new wxTreebook();
 
22194
    wxPyEndAllowThreads(__tstate);
 
22195
    if (PyErr_Occurred()) SWIG_fail;
 
22196
  }
 
22197
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTreebook, SWIG_POINTER_OWN |  0 );
 
22198
  return resultobj;
 
22199
fail:
 
22200
  return NULL;
 
22201
}
 
22202
 
 
22203
 
 
22204
SWIGINTERN PyObject *_wrap_Treebook_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
22205
  PyObject *resultobj = 0;
 
22206
  wxTreebook *arg1 = (wxTreebook *) 0 ;
 
22207
  wxWindow *arg2 = (wxWindow *) 0 ;
 
22208
  int arg3 ;
 
22209
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
22210
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
22211
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
22212
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
22213
  long arg6 = (long) wxBK_DEFAULT ;
 
22214
  wxString const &arg7_defvalue = wxPyEmptyString ;
 
22215
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
22216
  bool result;
 
22217
  void *argp1 = 0 ;
 
22218
  int res1 = 0 ;
 
22219
  void *argp2 = 0 ;
 
22220
  int res2 = 0 ;
 
22221
  int val3 ;
 
22222
  int ecode3 = 0 ;
 
22223
  wxPoint temp4 ;
 
22224
  wxSize temp5 ;
 
22225
  long val6 ;
 
22226
  int ecode6 = 0 ;
 
22227
  bool temp7 = false ;
 
22228
  PyObject * obj0 = 0 ;
 
22229
  PyObject * obj1 = 0 ;
 
22230
  PyObject * obj2 = 0 ;
 
22231
  PyObject * obj3 = 0 ;
 
22232
  PyObject * obj4 = 0 ;
 
22233
  PyObject * obj5 = 0 ;
 
22234
  PyObject * obj6 = 0 ;
 
22235
  char *  kwnames[] = {
 
22236
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
22237
  };
 
22238
  
 
22239
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Treebook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
22240
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreebook, 0 |  0 );
 
22241
  if (!SWIG_IsOK(res1)) {
 
22242
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Treebook_Create" "', expected argument " "1"" of type '" "wxTreebook *""'"); 
 
22243
  }
 
22244
  arg1 = reinterpret_cast< wxTreebook * >(argp1);
 
22245
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
22246
  if (!SWIG_IsOK(res2)) {
 
22247
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Treebook_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
22248
  }
 
22249
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
22250
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
22251
  if (!SWIG_IsOK(ecode3)) {
 
22252
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Treebook_Create" "', expected argument " "3"" of type '" "int""'");
 
22253
  } 
 
22254
  arg3 = static_cast< int >(val3);
 
22255
  if (obj3) {
 
22256
    {
 
22257
      arg4 = &temp4;
 
22258
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
22259
    }
 
22260
  }
 
22261
  if (obj4) {
 
22262
    {
 
22263
      arg5 = &temp5;
 
22264
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
22265
    }
 
22266
  }
 
22267
  if (obj5) {
 
22268
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
22269
    if (!SWIG_IsOK(ecode6)) {
 
22270
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Treebook_Create" "', expected argument " "6"" of type '" "long""'");
 
22271
    } 
 
22272
    arg6 = static_cast< long >(val6);
 
22273
  }
 
22274
  if (obj6) {
 
22275
    {
 
22276
      arg7 = wxString_in_helper(obj6);
 
22277
      if (arg7 == NULL) SWIG_fail;
 
22278
      temp7 = true;
 
22279
    }
 
22280
  }
 
22281
  {
 
22282
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22283
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
22284
    wxPyEndAllowThreads(__tstate);
 
22285
    if (PyErr_Occurred()) SWIG_fail;
 
22286
  }
 
22287
  {
 
22288
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
22289
  }
 
22290
  {
 
22291
    if (temp7)
 
22292
    delete arg7;
 
22293
  }
 
22294
  return resultobj;
 
22295
fail:
 
22296
  {
 
22297
    if (temp7)
 
22298
    delete arg7;
 
22299
  }
 
22300
  return NULL;
 
22301
}
 
22302
 
 
22303
 
 
22304
SWIGINTERN PyObject *_wrap_Treebook_InsertSubPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
22305
  PyObject *resultobj = 0;
 
22306
  wxTreebook *arg1 = (wxTreebook *) 0 ;
 
22307
  size_t arg2 ;
 
22308
  wxWindow *arg3 = (wxWindow *) 0 ;
 
22309
  wxString *arg4 = 0 ;
 
22310
  bool arg5 = (bool) false ;
 
22311
  int arg6 = (int) wxNOT_FOUND ;
 
22312
  bool result;
 
22313
  void *argp1 = 0 ;
 
22314
  int res1 = 0 ;
 
22315
  size_t val2 ;
 
22316
  int ecode2 = 0 ;
 
22317
  void *argp3 = 0 ;
 
22318
  int res3 = 0 ;
 
22319
  bool temp4 = false ;
 
22320
  bool val5 ;
 
22321
  int ecode5 = 0 ;
 
22322
  int val6 ;
 
22323
  int ecode6 = 0 ;
 
22324
  PyObject * obj0 = 0 ;
 
22325
  PyObject * obj1 = 0 ;
 
22326
  PyObject * obj2 = 0 ;
 
22327
  PyObject * obj3 = 0 ;
 
22328
  PyObject * obj4 = 0 ;
 
22329
  PyObject * obj5 = 0 ;
 
22330
  char *  kwnames[] = {
 
22331
    (char *) "self",(char *) "pos",(char *) "page",(char *) "text",(char *) "select",(char *) "imageId", NULL 
 
22332
  };
 
22333
  
 
22334
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Treebook_InsertSubPage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
22335
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreebook, 0 |  0 );
 
22336
  if (!SWIG_IsOK(res1)) {
 
22337
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Treebook_InsertSubPage" "', expected argument " "1"" of type '" "wxTreebook *""'"); 
 
22338
  }
 
22339
  arg1 = reinterpret_cast< wxTreebook * >(argp1);
 
22340
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
22341
  if (!SWIG_IsOK(ecode2)) {
 
22342
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Treebook_InsertSubPage" "', expected argument " "2"" of type '" "size_t""'");
 
22343
  } 
 
22344
  arg2 = static_cast< size_t >(val2);
 
22345
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 |  0 );
 
22346
  if (!SWIG_IsOK(res3)) {
 
22347
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Treebook_InsertSubPage" "', expected argument " "3"" of type '" "wxWindow *""'"); 
 
22348
  }
 
22349
  arg3 = reinterpret_cast< wxWindow * >(argp3);
 
22350
  {
 
22351
    arg4 = wxString_in_helper(obj3);
 
22352
    if (arg4 == NULL) SWIG_fail;
 
22353
    temp4 = true;
 
22354
  }
 
22355
  if (obj4) {
 
22356
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
 
22357
    if (!SWIG_IsOK(ecode5)) {
 
22358
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Treebook_InsertSubPage" "', expected argument " "5"" of type '" "bool""'");
 
22359
    } 
 
22360
    arg5 = static_cast< bool >(val5);
 
22361
  }
 
22362
  if (obj5) {
 
22363
    ecode6 = SWIG_AsVal_int(obj5, &val6);
 
22364
    if (!SWIG_IsOK(ecode6)) {
 
22365
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Treebook_InsertSubPage" "', expected argument " "6"" of type '" "int""'");
 
22366
    } 
 
22367
    arg6 = static_cast< int >(val6);
 
22368
  }
 
22369
  {
 
22370
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22371
    result = (bool)(arg1)->InsertSubPage(arg2,arg3,(wxString const &)*arg4,arg5,arg6);
 
22372
    wxPyEndAllowThreads(__tstate);
 
22373
    if (PyErr_Occurred()) SWIG_fail;
 
22374
  }
 
22375
  {
 
22376
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
22377
  }
 
22378
  {
 
22379
    if (temp4)
 
22380
    delete arg4;
 
22381
  }
 
22382
  return resultobj;
 
22383
fail:
 
22384
  {
 
22385
    if (temp4)
 
22386
    delete arg4;
 
22387
  }
 
22388
  return NULL;
 
22389
}
 
22390
 
 
22391
 
 
22392
SWIGINTERN PyObject *_wrap_Treebook_AddSubPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
22393
  PyObject *resultobj = 0;
 
22394
  wxTreebook *arg1 = (wxTreebook *) 0 ;
 
22395
  wxWindow *arg2 = (wxWindow *) 0 ;
 
22396
  wxString *arg3 = 0 ;
 
22397
  bool arg4 = (bool) false ;
 
22398
  int arg5 = (int) wxNOT_FOUND ;
 
22399
  bool result;
 
22400
  void *argp1 = 0 ;
 
22401
  int res1 = 0 ;
 
22402
  void *argp2 = 0 ;
 
22403
  int res2 = 0 ;
 
22404
  bool temp3 = false ;
 
22405
  bool val4 ;
 
22406
  int ecode4 = 0 ;
 
22407
  int val5 ;
 
22408
  int ecode5 = 0 ;
 
22409
  PyObject * obj0 = 0 ;
 
22410
  PyObject * obj1 = 0 ;
 
22411
  PyObject * obj2 = 0 ;
 
22412
  PyObject * obj3 = 0 ;
 
22413
  PyObject * obj4 = 0 ;
 
22414
  char *  kwnames[] = {
 
22415
    (char *) "self",(char *) "page",(char *) "text",(char *) "select",(char *) "imageId", NULL 
 
22416
  };
 
22417
  
 
22418
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Treebook_AddSubPage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
22419
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreebook, 0 |  0 );
 
22420
  if (!SWIG_IsOK(res1)) {
 
22421
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Treebook_AddSubPage" "', expected argument " "1"" of type '" "wxTreebook *""'"); 
 
22422
  }
 
22423
  arg1 = reinterpret_cast< wxTreebook * >(argp1);
 
22424
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
22425
  if (!SWIG_IsOK(res2)) {
 
22426
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Treebook_AddSubPage" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
22427
  }
 
22428
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
22429
  {
 
22430
    arg3 = wxString_in_helper(obj2);
 
22431
    if (arg3 == NULL) SWIG_fail;
 
22432
    temp3 = true;
 
22433
  }
 
22434
  if (obj3) {
 
22435
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
 
22436
    if (!SWIG_IsOK(ecode4)) {
 
22437
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Treebook_AddSubPage" "', expected argument " "4"" of type '" "bool""'");
 
22438
    } 
 
22439
    arg4 = static_cast< bool >(val4);
 
22440
  }
 
22441
  if (obj4) {
 
22442
    ecode5 = SWIG_AsVal_int(obj4, &val5);
 
22443
    if (!SWIG_IsOK(ecode5)) {
 
22444
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Treebook_AddSubPage" "', expected argument " "5"" of type '" "int""'");
 
22445
    } 
 
22446
    arg5 = static_cast< int >(val5);
 
22447
  }
 
22448
  {
 
22449
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22450
    result = (bool)(arg1)->AddSubPage(arg2,(wxString const &)*arg3,arg4,arg5);
 
22451
    wxPyEndAllowThreads(__tstate);
 
22452
    if (PyErr_Occurred()) SWIG_fail;
 
22453
  }
 
22454
  {
 
22455
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
22456
  }
 
22457
  {
 
22458
    if (temp3)
 
22459
    delete arg3;
 
22460
  }
 
22461
  return resultobj;
 
22462
fail:
 
22463
  {
 
22464
    if (temp3)
 
22465
    delete arg3;
 
22466
  }
 
22467
  return NULL;
 
22468
}
 
22469
 
 
22470
 
 
22471
SWIGINTERN PyObject *_wrap_Treebook_IsNodeExpanded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
22472
  PyObject *resultobj = 0;
 
22473
  wxTreebook *arg1 = (wxTreebook *) 0 ;
 
22474
  size_t arg2 ;
 
22475
  bool result;
 
22476
  void *argp1 = 0 ;
 
22477
  int res1 = 0 ;
 
22478
  size_t val2 ;
 
22479
  int ecode2 = 0 ;
 
22480
  PyObject * obj0 = 0 ;
 
22481
  PyObject * obj1 = 0 ;
 
22482
  char *  kwnames[] = {
 
22483
    (char *) "self",(char *) "pos", NULL 
 
22484
  };
 
22485
  
 
22486
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Treebook_IsNodeExpanded",kwnames,&obj0,&obj1)) SWIG_fail;
 
22487
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreebook, 0 |  0 );
 
22488
  if (!SWIG_IsOK(res1)) {
 
22489
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Treebook_IsNodeExpanded" "', expected argument " "1"" of type '" "wxTreebook const *""'"); 
 
22490
  }
 
22491
  arg1 = reinterpret_cast< wxTreebook * >(argp1);
 
22492
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
22493
  if (!SWIG_IsOK(ecode2)) {
 
22494
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Treebook_IsNodeExpanded" "', expected argument " "2"" of type '" "size_t""'");
 
22495
  } 
 
22496
  arg2 = static_cast< size_t >(val2);
 
22497
  {
 
22498
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22499
    result = (bool)((wxTreebook const *)arg1)->IsNodeExpanded(arg2);
 
22500
    wxPyEndAllowThreads(__tstate);
 
22501
    if (PyErr_Occurred()) SWIG_fail;
 
22502
  }
 
22503
  {
 
22504
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
22505
  }
 
22506
  return resultobj;
 
22507
fail:
 
22508
  return NULL;
 
22509
}
 
22510
 
 
22511
 
 
22512
SWIGINTERN PyObject *_wrap_Treebook_ExpandNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
22513
  PyObject *resultobj = 0;
 
22514
  wxTreebook *arg1 = (wxTreebook *) 0 ;
 
22515
  size_t arg2 ;
 
22516
  bool arg3 = (bool) true ;
 
22517
  bool result;
 
22518
  void *argp1 = 0 ;
 
22519
  int res1 = 0 ;
 
22520
  size_t val2 ;
 
22521
  int ecode2 = 0 ;
 
22522
  bool val3 ;
 
22523
  int ecode3 = 0 ;
 
22524
  PyObject * obj0 = 0 ;
 
22525
  PyObject * obj1 = 0 ;
 
22526
  PyObject * obj2 = 0 ;
 
22527
  char *  kwnames[] = {
 
22528
    (char *) "self",(char *) "pos",(char *) "expand", NULL 
 
22529
  };
 
22530
  
 
22531
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Treebook_ExpandNode",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
22532
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreebook, 0 |  0 );
 
22533
  if (!SWIG_IsOK(res1)) {
 
22534
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Treebook_ExpandNode" "', expected argument " "1"" of type '" "wxTreebook *""'"); 
 
22535
  }
 
22536
  arg1 = reinterpret_cast< wxTreebook * >(argp1);
 
22537
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
22538
  if (!SWIG_IsOK(ecode2)) {
 
22539
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Treebook_ExpandNode" "', expected argument " "2"" of type '" "size_t""'");
 
22540
  } 
 
22541
  arg2 = static_cast< size_t >(val2);
 
22542
  if (obj2) {
 
22543
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
22544
    if (!SWIG_IsOK(ecode3)) {
 
22545
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Treebook_ExpandNode" "', expected argument " "3"" of type '" "bool""'");
 
22546
    } 
 
22547
    arg3 = static_cast< bool >(val3);
 
22548
  }
 
22549
  {
 
22550
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22551
    result = (bool)(arg1)->ExpandNode(arg2,arg3);
 
22552
    wxPyEndAllowThreads(__tstate);
 
22553
    if (PyErr_Occurred()) SWIG_fail;
 
22554
  }
 
22555
  {
 
22556
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
22557
  }
 
22558
  return resultobj;
 
22559
fail:
 
22560
  return NULL;
 
22561
}
 
22562
 
 
22563
 
 
22564
SWIGINTERN PyObject *_wrap_Treebook_CollapseNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
22565
  PyObject *resultobj = 0;
 
22566
  wxTreebook *arg1 = (wxTreebook *) 0 ;
 
22567
  size_t arg2 ;
 
22568
  bool result;
 
22569
  void *argp1 = 0 ;
 
22570
  int res1 = 0 ;
 
22571
  size_t val2 ;
 
22572
  int ecode2 = 0 ;
 
22573
  PyObject * obj0 = 0 ;
 
22574
  PyObject * obj1 = 0 ;
 
22575
  char *  kwnames[] = {
 
22576
    (char *) "self",(char *) "pos", NULL 
 
22577
  };
 
22578
  
 
22579
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Treebook_CollapseNode",kwnames,&obj0,&obj1)) SWIG_fail;
 
22580
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreebook, 0 |  0 );
 
22581
  if (!SWIG_IsOK(res1)) {
 
22582
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Treebook_CollapseNode" "', expected argument " "1"" of type '" "wxTreebook *""'"); 
 
22583
  }
 
22584
  arg1 = reinterpret_cast< wxTreebook * >(argp1);
 
22585
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
22586
  if (!SWIG_IsOK(ecode2)) {
 
22587
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Treebook_CollapseNode" "', expected argument " "2"" of type '" "size_t""'");
 
22588
  } 
 
22589
  arg2 = static_cast< size_t >(val2);
 
22590
  {
 
22591
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22592
    result = (bool)(arg1)->CollapseNode(arg2);
 
22593
    wxPyEndAllowThreads(__tstate);
 
22594
    if (PyErr_Occurred()) SWIG_fail;
 
22595
  }
 
22596
  {
 
22597
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
22598
  }
 
22599
  return resultobj;
 
22600
fail:
 
22601
  return NULL;
 
22602
}
 
22603
 
 
22604
 
 
22605
SWIGINTERN PyObject *_wrap_Treebook_GetPageParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
22606
  PyObject *resultobj = 0;
 
22607
  wxTreebook *arg1 = (wxTreebook *) 0 ;
 
22608
  size_t arg2 ;
 
22609
  int result;
 
22610
  void *argp1 = 0 ;
 
22611
  int res1 = 0 ;
 
22612
  size_t val2 ;
 
22613
  int ecode2 = 0 ;
 
22614
  PyObject * obj0 = 0 ;
 
22615
  PyObject * obj1 = 0 ;
 
22616
  char *  kwnames[] = {
 
22617
    (char *) "self",(char *) "pos", NULL 
 
22618
  };
 
22619
  
 
22620
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Treebook_GetPageParent",kwnames,&obj0,&obj1)) SWIG_fail;
 
22621
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreebook, 0 |  0 );
 
22622
  if (!SWIG_IsOK(res1)) {
 
22623
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Treebook_GetPageParent" "', expected argument " "1"" of type '" "wxTreebook const *""'"); 
 
22624
  }
 
22625
  arg1 = reinterpret_cast< wxTreebook * >(argp1);
 
22626
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
22627
  if (!SWIG_IsOK(ecode2)) {
 
22628
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Treebook_GetPageParent" "', expected argument " "2"" of type '" "size_t""'");
 
22629
  } 
 
22630
  arg2 = static_cast< size_t >(val2);
 
22631
  {
 
22632
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22633
    result = (int)((wxTreebook const *)arg1)->GetPageParent(arg2);
 
22634
    wxPyEndAllowThreads(__tstate);
 
22635
    if (PyErr_Occurred()) SWIG_fail;
 
22636
  }
 
22637
  resultobj = SWIG_From_int(static_cast< int >(result));
 
22638
  return resultobj;
 
22639
fail:
 
22640
  return NULL;
 
22641
}
 
22642
 
 
22643
 
 
22644
SWIGINTERN PyObject *_wrap_Treebook_GetTreeCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22645
  PyObject *resultobj = 0;
 
22646
  wxTreebook *arg1 = (wxTreebook *) 0 ;
 
22647
  wxPyTreeCtrl *result = 0 ;
 
22648
  void *argp1 = 0 ;
 
22649
  int res1 = 0 ;
 
22650
  PyObject *swig_obj[1] ;
 
22651
  
 
22652
  if (!args) SWIG_fail;
 
22653
  swig_obj[0] = args;
 
22654
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreebook, 0 |  0 );
 
22655
  if (!SWIG_IsOK(res1)) {
 
22656
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Treebook_GetTreeCtrl" "', expected argument " "1"" of type '" "wxTreebook const *""'"); 
 
22657
  }
 
22658
  arg1 = reinterpret_cast< wxTreebook * >(argp1);
 
22659
  {
 
22660
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22661
    result = (wxPyTreeCtrl *)((wxTreebook const *)arg1)->GetTreeCtrl();
 
22662
    wxPyEndAllowThreads(__tstate);
 
22663
    if (PyErr_Occurred()) SWIG_fail;
 
22664
  }
 
22665
  {
 
22666
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
22667
  }
 
22668
  return resultobj;
 
22669
fail:
 
22670
  return NULL;
 
22671
}
 
22672
 
 
22673
 
 
22674
SWIGINTERN PyObject *Treebook_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22675
  PyObject *obj;
 
22676
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
22677
  SWIG_TypeNewClientData(SWIGTYPE_p_wxTreebook, SWIG_NewClientData(obj));
 
22678
  return SWIG_Py_Void();
 
22679
}
 
22680
 
 
22681
SWIGINTERN PyObject *Treebook_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22682
  return SWIG_Python_InitShadowInstance(args);
 
22683
}
 
22684
 
 
22685
SWIGINTERN PyObject *_wrap_new_Toolbook(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
22686
  PyObject *resultobj = 0;
 
22687
  wxWindow *arg1 = (wxWindow *) 0 ;
 
22688
  int arg2 ;
 
22689
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
22690
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
22691
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
22692
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
22693
  long arg5 = (long) wxBK_DEFAULT ;
 
22694
  wxString const &arg6_defvalue = wxPyEmptyString ;
 
22695
  wxString *arg6 = (wxString *) &arg6_defvalue ;
 
22696
  wxToolbook *result = 0 ;
 
22697
  void *argp1 = 0 ;
 
22698
  int res1 = 0 ;
 
22699
  int val2 ;
 
22700
  int ecode2 = 0 ;
 
22701
  wxPoint temp3 ;
 
22702
  wxSize temp4 ;
 
22703
  long val5 ;
 
22704
  int ecode5 = 0 ;
 
22705
  bool temp6 = false ;
 
22706
  PyObject * obj0 = 0 ;
 
22707
  PyObject * obj1 = 0 ;
 
22708
  PyObject * obj2 = 0 ;
 
22709
  PyObject * obj3 = 0 ;
 
22710
  PyObject * obj4 = 0 ;
 
22711
  PyObject * obj5 = 0 ;
 
22712
  char *  kwnames[] = {
 
22713
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
22714
  };
 
22715
  
 
22716
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:new_Toolbook",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
22717
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
22718
  if (!SWIG_IsOK(res1)) {
 
22719
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Toolbook" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
22720
  }
 
22721
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
22722
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
22723
  if (!SWIG_IsOK(ecode2)) {
 
22724
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Toolbook" "', expected argument " "2"" of type '" "int""'");
 
22725
  } 
 
22726
  arg2 = static_cast< int >(val2);
 
22727
  if (obj2) {
 
22728
    {
 
22729
      arg3 = &temp3;
 
22730
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
22731
    }
 
22732
  }
 
22733
  if (obj3) {
 
22734
    {
 
22735
      arg4 = &temp4;
 
22736
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
22737
    }
 
22738
  }
 
22739
  if (obj4) {
 
22740
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
22741
    if (!SWIG_IsOK(ecode5)) {
 
22742
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Toolbook" "', expected argument " "5"" of type '" "long""'");
 
22743
    } 
 
22744
    arg5 = static_cast< long >(val5);
 
22745
  }
 
22746
  if (obj5) {
 
22747
    {
 
22748
      arg6 = wxString_in_helper(obj5);
 
22749
      if (arg6 == NULL) SWIG_fail;
 
22750
      temp6 = true;
 
22751
    }
 
22752
  }
 
22753
  {
 
22754
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22755
    result = (wxToolbook *)new wxToolbook(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
 
22756
    wxPyEndAllowThreads(__tstate);
 
22757
    if (PyErr_Occurred()) SWIG_fail;
 
22758
  }
 
22759
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolbook, SWIG_POINTER_NEW |  0 );
 
22760
  {
 
22761
    if (temp6)
 
22762
    delete arg6;
 
22763
  }
 
22764
  return resultobj;
 
22765
fail:
 
22766
  {
 
22767
    if (temp6)
 
22768
    delete arg6;
 
22769
  }
 
22770
  return NULL;
 
22771
}
 
22772
 
 
22773
 
 
22774
SWIGINTERN PyObject *_wrap_new_PreToolbook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22775
  PyObject *resultobj = 0;
 
22776
  wxToolbook *result = 0 ;
 
22777
  
 
22778
  if (!SWIG_Python_UnpackTuple(args,"new_PreToolbook",0,0,0)) SWIG_fail;
 
22779
  {
 
22780
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22781
    result = (wxToolbook *)new wxToolbook();
 
22782
    wxPyEndAllowThreads(__tstate);
 
22783
    if (PyErr_Occurred()) SWIG_fail;
 
22784
  }
 
22785
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolbook, SWIG_POINTER_OWN |  0 );
 
22786
  return resultobj;
 
22787
fail:
 
22788
  return NULL;
 
22789
}
 
22790
 
 
22791
 
 
22792
SWIGINTERN PyObject *_wrap_Toolbook_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
22793
  PyObject *resultobj = 0;
 
22794
  wxToolbook *arg1 = (wxToolbook *) 0 ;
 
22795
  wxWindow *arg2 = (wxWindow *) 0 ;
 
22796
  int arg3 ;
 
22797
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
22798
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
22799
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
22800
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
22801
  long arg6 = (long) 0 ;
 
22802
  wxString const &arg7_defvalue = wxEmptyString ;
 
22803
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
22804
  bool result;
 
22805
  void *argp1 = 0 ;
 
22806
  int res1 = 0 ;
 
22807
  void *argp2 = 0 ;
 
22808
  int res2 = 0 ;
 
22809
  int val3 ;
 
22810
  int ecode3 = 0 ;
 
22811
  wxPoint temp4 ;
 
22812
  wxSize temp5 ;
 
22813
  long val6 ;
 
22814
  int ecode6 = 0 ;
 
22815
  bool temp7 = false ;
 
22816
  PyObject * obj0 = 0 ;
 
22817
  PyObject * obj1 = 0 ;
 
22818
  PyObject * obj2 = 0 ;
 
22819
  PyObject * obj3 = 0 ;
 
22820
  PyObject * obj4 = 0 ;
 
22821
  PyObject * obj5 = 0 ;
 
22822
  PyObject * obj6 = 0 ;
 
22823
  char *  kwnames[] = {
 
22824
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
22825
  };
 
22826
  
 
22827
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Toolbook_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
22828
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolbook, 0 |  0 );
 
22829
  if (!SWIG_IsOK(res1)) {
 
22830
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Toolbook_Create" "', expected argument " "1"" of type '" "wxToolbook *""'"); 
 
22831
  }
 
22832
  arg1 = reinterpret_cast< wxToolbook * >(argp1);
 
22833
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
22834
  if (!SWIG_IsOK(res2)) {
 
22835
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Toolbook_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
22836
  }
 
22837
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
22838
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
22839
  if (!SWIG_IsOK(ecode3)) {
 
22840
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Toolbook_Create" "', expected argument " "3"" of type '" "int""'");
 
22841
  } 
 
22842
  arg3 = static_cast< int >(val3);
 
22843
  if (obj3) {
 
22844
    {
 
22845
      arg4 = &temp4;
 
22846
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
22847
    }
 
22848
  }
 
22849
  if (obj4) {
 
22850
    {
 
22851
      arg5 = &temp5;
 
22852
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
22853
    }
 
22854
  }
 
22855
  if (obj5) {
 
22856
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
22857
    if (!SWIG_IsOK(ecode6)) {
 
22858
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Toolbook_Create" "', expected argument " "6"" of type '" "long""'");
 
22859
    } 
 
22860
    arg6 = static_cast< long >(val6);
 
22861
  }
 
22862
  if (obj6) {
 
22863
    {
 
22864
      arg7 = wxString_in_helper(obj6);
 
22865
      if (arg7 == NULL) SWIG_fail;
 
22866
      temp7 = true;
 
22867
    }
 
22868
  }
 
22869
  {
 
22870
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22871
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
22872
    wxPyEndAllowThreads(__tstate);
 
22873
    if (PyErr_Occurred()) SWIG_fail;
 
22874
  }
 
22875
  {
 
22876
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
22877
  }
 
22878
  {
 
22879
    if (temp7)
 
22880
    delete arg7;
 
22881
  }
 
22882
  return resultobj;
 
22883
fail:
 
22884
  {
 
22885
    if (temp7)
 
22886
    delete arg7;
 
22887
  }
 
22888
  return NULL;
 
22889
}
 
22890
 
 
22891
 
 
22892
SWIGINTERN PyObject *_wrap_Toolbook_GetToolBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22893
  PyObject *resultobj = 0;
 
22894
  wxToolbook *arg1 = (wxToolbook *) 0 ;
 
22895
  wxToolBarBase *result = 0 ;
 
22896
  void *argp1 = 0 ;
 
22897
  int res1 = 0 ;
 
22898
  PyObject *swig_obj[1] ;
 
22899
  
 
22900
  if (!args) SWIG_fail;
 
22901
  swig_obj[0] = args;
 
22902
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolbook, 0 |  0 );
 
22903
  if (!SWIG_IsOK(res1)) {
 
22904
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Toolbook_GetToolBar" "', expected argument " "1"" of type '" "wxToolbook const *""'"); 
 
22905
  }
 
22906
  arg1 = reinterpret_cast< wxToolbook * >(argp1);
 
22907
  {
 
22908
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22909
    result = (wxToolBarBase *)((wxToolbook const *)arg1)->GetToolBar();
 
22910
    wxPyEndAllowThreads(__tstate);
 
22911
    if (PyErr_Occurred()) SWIG_fail;
 
22912
  }
 
22913
  {
 
22914
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
22915
  }
 
22916
  return resultobj;
 
22917
fail:
 
22918
  return NULL;
 
22919
}
 
22920
 
 
22921
 
 
22922
SWIGINTERN PyObject *_wrap_Toolbook_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22923
  PyObject *resultobj = 0;
 
22924
  wxToolbook *arg1 = (wxToolbook *) 0 ;
 
22925
  void *argp1 = 0 ;
 
22926
  int res1 = 0 ;
 
22927
  PyObject *swig_obj[1] ;
 
22928
  
 
22929
  if (!args) SWIG_fail;
 
22930
  swig_obj[0] = args;
 
22931
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolbook, 0 |  0 );
 
22932
  if (!SWIG_IsOK(res1)) {
 
22933
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Toolbook_Realize" "', expected argument " "1"" of type '" "wxToolbook *""'"); 
 
22934
  }
 
22935
  arg1 = reinterpret_cast< wxToolbook * >(argp1);
 
22936
  {
 
22937
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22938
    (arg1)->Realize();
 
22939
    wxPyEndAllowThreads(__tstate);
 
22940
    if (PyErr_Occurred()) SWIG_fail;
 
22941
  }
 
22942
  resultobj = SWIG_Py_Void();
 
22943
  return resultobj;
 
22944
fail:
 
22945
  return NULL;
 
22946
}
 
22947
 
 
22948
 
 
22949
SWIGINTERN PyObject *Toolbook_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22950
  PyObject *obj;
 
22951
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
22952
  SWIG_TypeNewClientData(SWIGTYPE_p_wxToolbook, SWIG_NewClientData(obj));
 
22953
  return SWIG_Py_Void();
 
22954
}
 
22955
 
 
22956
SWIGINTERN PyObject *Toolbook_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22957
  return SWIG_Python_InitShadowInstance(args);
 
22958
}
 
22959
 
 
22960
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22961
  PyObject *resultobj = 0;
 
22962
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
22963
  int result;
 
22964
  void *argp1 = 0 ;
 
22965
  int res1 = 0 ;
 
22966
  PyObject *swig_obj[1] ;
 
22967
  
 
22968
  if (!args) SWIG_fail;
 
22969
  swig_obj[0] = args;
 
22970
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
22971
  if (!SWIG_IsOK(res1)) {
 
22972
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetId" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
22973
  }
 
22974
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
22975
  {
 
22976
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
22977
    result = (int)(arg1)->GetId();
 
22978
    wxPyEndAllowThreads(__tstate);
 
22979
    if (PyErr_Occurred()) SWIG_fail;
 
22980
  }
 
22981
  resultobj = SWIG_From_int(static_cast< int >(result));
 
22982
  return resultobj;
 
22983
fail:
 
22984
  return NULL;
 
22985
}
 
22986
 
 
22987
 
 
22988
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
22989
  PyObject *resultobj = 0;
 
22990
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
22991
  wxControl *result = 0 ;
 
22992
  void *argp1 = 0 ;
 
22993
  int res1 = 0 ;
 
22994
  PyObject *swig_obj[1] ;
 
22995
  
 
22996
  if (!args) SWIG_fail;
 
22997
  swig_obj[0] = args;
 
22998
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
22999
  if (!SWIG_IsOK(res1)) {
 
23000
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetControl" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23001
  }
 
23002
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23003
  {
 
23004
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23005
    result = (wxControl *)(arg1)->GetControl();
 
23006
    wxPyEndAllowThreads(__tstate);
 
23007
    if (PyErr_Occurred()) SWIG_fail;
 
23008
  }
 
23009
  {
 
23010
    resultobj = wxPyMake_wxObject(result, 0); 
 
23011
  }
 
23012
  return resultobj;
 
23013
fail:
 
23014
  return NULL;
 
23015
}
 
23016
 
 
23017
 
 
23018
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetToolBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23019
  PyObject *resultobj = 0;
 
23020
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23021
  wxToolBarBase *result = 0 ;
 
23022
  void *argp1 = 0 ;
 
23023
  int res1 = 0 ;
 
23024
  PyObject *swig_obj[1] ;
 
23025
  
 
23026
  if (!args) SWIG_fail;
 
23027
  swig_obj[0] = args;
 
23028
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23029
  if (!SWIG_IsOK(res1)) {
 
23030
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetToolBar" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23031
  }
 
23032
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23033
  {
 
23034
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23035
    result = (wxToolBarBase *)(arg1)->GetToolBar();
 
23036
    wxPyEndAllowThreads(__tstate);
 
23037
    if (PyErr_Occurred()) SWIG_fail;
 
23038
  }
 
23039
  {
 
23040
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
23041
  }
 
23042
  return resultobj;
 
23043
fail:
 
23044
  return NULL;
 
23045
}
 
23046
 
 
23047
 
 
23048
SWIGINTERN PyObject *_wrap_ToolBarToolBase_IsStretchable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23049
  PyObject *resultobj = 0;
 
23050
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23051
  bool result;
 
23052
  void *argp1 = 0 ;
 
23053
  int res1 = 0 ;
 
23054
  PyObject *swig_obj[1] ;
 
23055
  
 
23056
  if (!args) SWIG_fail;
 
23057
  swig_obj[0] = args;
 
23058
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23059
  if (!SWIG_IsOK(res1)) {
 
23060
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_IsStretchable" "', expected argument " "1"" of type '" "wxToolBarToolBase const *""'"); 
 
23061
  }
 
23062
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23063
  {
 
23064
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23065
    result = (bool)((wxToolBarToolBase const *)arg1)->IsStretchable();
 
23066
    wxPyEndAllowThreads(__tstate);
 
23067
    if (PyErr_Occurred()) SWIG_fail;
 
23068
  }
 
23069
  {
 
23070
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
23071
  }
 
23072
  return resultobj;
 
23073
fail:
 
23074
  return NULL;
 
23075
}
 
23076
 
 
23077
 
 
23078
SWIGINTERN PyObject *_wrap_ToolBarToolBase_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23079
  PyObject *resultobj = 0;
 
23080
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23081
  int result;
 
23082
  void *argp1 = 0 ;
 
23083
  int res1 = 0 ;
 
23084
  PyObject *swig_obj[1] ;
 
23085
  
 
23086
  if (!args) SWIG_fail;
 
23087
  swig_obj[0] = args;
 
23088
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23089
  if (!SWIG_IsOK(res1)) {
 
23090
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_IsButton" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23091
  }
 
23092
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23093
  {
 
23094
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23095
    result = (int)(arg1)->IsButton();
 
23096
    wxPyEndAllowThreads(__tstate);
 
23097
    if (PyErr_Occurred()) SWIG_fail;
 
23098
  }
 
23099
  resultobj = SWIG_From_int(static_cast< int >(result));
 
23100
  return resultobj;
 
23101
fail:
 
23102
  return NULL;
 
23103
}
 
23104
 
 
23105
 
 
23106
SWIGINTERN PyObject *_wrap_ToolBarToolBase_IsControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23107
  PyObject *resultobj = 0;
 
23108
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23109
  int result;
 
23110
  void *argp1 = 0 ;
 
23111
  int res1 = 0 ;
 
23112
  PyObject *swig_obj[1] ;
 
23113
  
 
23114
  if (!args) SWIG_fail;
 
23115
  swig_obj[0] = args;
 
23116
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23117
  if (!SWIG_IsOK(res1)) {
 
23118
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_IsControl" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23119
  }
 
23120
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23121
  {
 
23122
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23123
    result = (int)(arg1)->IsControl();
 
23124
    wxPyEndAllowThreads(__tstate);
 
23125
    if (PyErr_Occurred()) SWIG_fail;
 
23126
  }
 
23127
  resultobj = SWIG_From_int(static_cast< int >(result));
 
23128
  return resultobj;
 
23129
fail:
 
23130
  return NULL;
 
23131
}
 
23132
 
 
23133
 
 
23134
SWIGINTERN PyObject *_wrap_ToolBarToolBase_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23135
  PyObject *resultobj = 0;
 
23136
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23137
  int result;
 
23138
  void *argp1 = 0 ;
 
23139
  int res1 = 0 ;
 
23140
  PyObject *swig_obj[1] ;
 
23141
  
 
23142
  if (!args) SWIG_fail;
 
23143
  swig_obj[0] = args;
 
23144
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23145
  if (!SWIG_IsOK(res1)) {
 
23146
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_IsSeparator" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23147
  }
 
23148
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23149
  {
 
23150
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23151
    result = (int)(arg1)->IsSeparator();
 
23152
    wxPyEndAllowThreads(__tstate);
 
23153
    if (PyErr_Occurred()) SWIG_fail;
 
23154
  }
 
23155
  resultobj = SWIG_From_int(static_cast< int >(result));
 
23156
  return resultobj;
 
23157
fail:
 
23158
  return NULL;
 
23159
}
 
23160
 
 
23161
 
 
23162
SWIGINTERN PyObject *_wrap_ToolBarToolBase_IsStretchableSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23163
  PyObject *resultobj = 0;
 
23164
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23165
  bool result;
 
23166
  void *argp1 = 0 ;
 
23167
  int res1 = 0 ;
 
23168
  PyObject *swig_obj[1] ;
 
23169
  
 
23170
  if (!args) SWIG_fail;
 
23171
  swig_obj[0] = args;
 
23172
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23173
  if (!SWIG_IsOK(res1)) {
 
23174
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_IsStretchableSpace" "', expected argument " "1"" of type '" "wxToolBarToolBase const *""'"); 
 
23175
  }
 
23176
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23177
  {
 
23178
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23179
    result = (bool)((wxToolBarToolBase const *)arg1)->IsStretchableSpace();
 
23180
    wxPyEndAllowThreads(__tstate);
 
23181
    if (PyErr_Occurred()) SWIG_fail;
 
23182
  }
 
23183
  {
 
23184
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
23185
  }
 
23186
  return resultobj;
 
23187
fail:
 
23188
  return NULL;
 
23189
}
 
23190
 
 
23191
 
 
23192
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23193
  PyObject *resultobj = 0;
 
23194
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23195
  int result;
 
23196
  void *argp1 = 0 ;
 
23197
  int res1 = 0 ;
 
23198
  PyObject *swig_obj[1] ;
 
23199
  
 
23200
  if (!args) SWIG_fail;
 
23201
  swig_obj[0] = args;
 
23202
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23203
  if (!SWIG_IsOK(res1)) {
 
23204
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetStyle" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23205
  }
 
23206
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23207
  {
 
23208
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23209
    result = (int)(arg1)->GetStyle();
 
23210
    wxPyEndAllowThreads(__tstate);
 
23211
    if (PyErr_Occurred()) SWIG_fail;
 
23212
  }
 
23213
  resultobj = SWIG_From_int(static_cast< int >(result));
 
23214
  return resultobj;
 
23215
fail:
 
23216
  return NULL;
 
23217
}
 
23218
 
 
23219
 
 
23220
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23221
  PyObject *resultobj = 0;
 
23222
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23223
  wxItemKind result;
 
23224
  void *argp1 = 0 ;
 
23225
  int res1 = 0 ;
 
23226
  PyObject *swig_obj[1] ;
 
23227
  
 
23228
  if (!args) SWIG_fail;
 
23229
  swig_obj[0] = args;
 
23230
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23231
  if (!SWIG_IsOK(res1)) {
 
23232
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetKind" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23233
  }
 
23234
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23235
  {
 
23236
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23237
    result = (wxItemKind)(arg1)->GetKind();
 
23238
    wxPyEndAllowThreads(__tstate);
 
23239
    if (PyErr_Occurred()) SWIG_fail;
 
23240
  }
 
23241
  resultobj = SWIG_From_int(static_cast< int >(result));
 
23242
  return resultobj;
 
23243
fail:
 
23244
  return NULL;
 
23245
}
 
23246
 
 
23247
 
 
23248
SWIGINTERN PyObject *_wrap_ToolBarToolBase_MakeStretchable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23249
  PyObject *resultobj = 0;
 
23250
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23251
  void *argp1 = 0 ;
 
23252
  int res1 = 0 ;
 
23253
  PyObject *swig_obj[1] ;
 
23254
  
 
23255
  if (!args) SWIG_fail;
 
23256
  swig_obj[0] = args;
 
23257
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23258
  if (!SWIG_IsOK(res1)) {
 
23259
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_MakeStretchable" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23260
  }
 
23261
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23262
  {
 
23263
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23264
    (arg1)->MakeStretchable();
 
23265
    wxPyEndAllowThreads(__tstate);
 
23266
    if (PyErr_Occurred()) SWIG_fail;
 
23267
  }
 
23268
  resultobj = SWIG_Py_Void();
 
23269
  return resultobj;
 
23270
fail:
 
23271
  return NULL;
 
23272
}
 
23273
 
 
23274
 
 
23275
SWIGINTERN PyObject *_wrap_ToolBarToolBase_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23276
  PyObject *resultobj = 0;
 
23277
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23278
  bool result;
 
23279
  void *argp1 = 0 ;
 
23280
  int res1 = 0 ;
 
23281
  PyObject *swig_obj[1] ;
 
23282
  
 
23283
  if (!args) SWIG_fail;
 
23284
  swig_obj[0] = args;
 
23285
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23286
  if (!SWIG_IsOK(res1)) {
 
23287
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_IsEnabled" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23288
  }
 
23289
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23290
  {
 
23291
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23292
    result = (bool)(arg1)->IsEnabled();
 
23293
    wxPyEndAllowThreads(__tstate);
 
23294
    if (PyErr_Occurred()) SWIG_fail;
 
23295
  }
 
23296
  {
 
23297
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
23298
  }
 
23299
  return resultobj;
 
23300
fail:
 
23301
  return NULL;
 
23302
}
 
23303
 
 
23304
 
 
23305
SWIGINTERN PyObject *_wrap_ToolBarToolBase_IsToggled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23306
  PyObject *resultobj = 0;
 
23307
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23308
  bool result;
 
23309
  void *argp1 = 0 ;
 
23310
  int res1 = 0 ;
 
23311
  PyObject *swig_obj[1] ;
 
23312
  
 
23313
  if (!args) SWIG_fail;
 
23314
  swig_obj[0] = args;
 
23315
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23316
  if (!SWIG_IsOK(res1)) {
 
23317
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_IsToggled" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23318
  }
 
23319
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23320
  {
 
23321
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23322
    result = (bool)(arg1)->IsToggled();
 
23323
    wxPyEndAllowThreads(__tstate);
 
23324
    if (PyErr_Occurred()) SWIG_fail;
 
23325
  }
 
23326
  {
 
23327
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
23328
  }
 
23329
  return resultobj;
 
23330
fail:
 
23331
  return NULL;
 
23332
}
 
23333
 
 
23334
 
 
23335
SWIGINTERN PyObject *_wrap_ToolBarToolBase_CanBeToggled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23336
  PyObject *resultobj = 0;
 
23337
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23338
  bool result;
 
23339
  void *argp1 = 0 ;
 
23340
  int res1 = 0 ;
 
23341
  PyObject *swig_obj[1] ;
 
23342
  
 
23343
  if (!args) SWIG_fail;
 
23344
  swig_obj[0] = args;
 
23345
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23346
  if (!SWIG_IsOK(res1)) {
 
23347
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_CanBeToggled" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23348
  }
 
23349
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23350
  {
 
23351
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23352
    result = (bool)(arg1)->CanBeToggled();
 
23353
    wxPyEndAllowThreads(__tstate);
 
23354
    if (PyErr_Occurred()) SWIG_fail;
 
23355
  }
 
23356
  {
 
23357
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
23358
  }
 
23359
  return resultobj;
 
23360
fail:
 
23361
  return NULL;
 
23362
}
 
23363
 
 
23364
 
 
23365
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetNormalBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23366
  PyObject *resultobj = 0;
 
23367
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23368
  wxBitmap *result = 0 ;
 
23369
  void *argp1 = 0 ;
 
23370
  int res1 = 0 ;
 
23371
  PyObject *swig_obj[1] ;
 
23372
  
 
23373
  if (!args) SWIG_fail;
 
23374
  swig_obj[0] = args;
 
23375
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23376
  if (!SWIG_IsOK(res1)) {
 
23377
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetNormalBitmap" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23378
  }
 
23379
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23380
  {
 
23381
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23382
    {
 
23383
      wxBitmap const &_result_ref = (arg1)->GetNormalBitmap();
 
23384
      result = (wxBitmap *) &_result_ref;
 
23385
    }
 
23386
    wxPyEndAllowThreads(__tstate);
 
23387
    if (PyErr_Occurred()) SWIG_fail;
 
23388
  }
 
23389
  {
 
23390
    wxBitmap* resultptr = new wxBitmap(*result);
 
23391
    resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
 
23392
  }
 
23393
  return resultobj;
 
23394
fail:
 
23395
  return NULL;
 
23396
}
 
23397
 
 
23398
 
 
23399
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23400
  PyObject *resultobj = 0;
 
23401
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23402
  wxBitmap *result = 0 ;
 
23403
  void *argp1 = 0 ;
 
23404
  int res1 = 0 ;
 
23405
  PyObject *swig_obj[1] ;
 
23406
  
 
23407
  if (!args) SWIG_fail;
 
23408
  swig_obj[0] = args;
 
23409
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23410
  if (!SWIG_IsOK(res1)) {
 
23411
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23412
  }
 
23413
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23414
  {
 
23415
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23416
    {
 
23417
      wxBitmap const &_result_ref = (arg1)->GetDisabledBitmap();
 
23418
      result = (wxBitmap *) &_result_ref;
 
23419
    }
 
23420
    wxPyEndAllowThreads(__tstate);
 
23421
    if (PyErr_Occurred()) SWIG_fail;
 
23422
  }
 
23423
  {
 
23424
    wxBitmap* resultptr = new wxBitmap(*result);
 
23425
    resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
 
23426
  }
 
23427
  return resultobj;
 
23428
fail:
 
23429
  return NULL;
 
23430
}
 
23431
 
 
23432
 
 
23433
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23434
  PyObject *resultobj = 0;
 
23435
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23436
  wxBitmap result;
 
23437
  void *argp1 = 0 ;
 
23438
  int res1 = 0 ;
 
23439
  PyObject *swig_obj[1] ;
 
23440
  
 
23441
  if (!args) SWIG_fail;
 
23442
  swig_obj[0] = args;
 
23443
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23444
  if (!SWIG_IsOK(res1)) {
 
23445
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetBitmap" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23446
  }
 
23447
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23448
  {
 
23449
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23450
    result = (arg1)->GetBitmap();
 
23451
    wxPyEndAllowThreads(__tstate);
 
23452
    if (PyErr_Occurred()) SWIG_fail;
 
23453
  }
 
23454
  resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN |  0 );
 
23455
  return resultobj;
 
23456
fail:
 
23457
  return NULL;
 
23458
}
 
23459
 
 
23460
 
 
23461
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23462
  PyObject *resultobj = 0;
 
23463
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23464
  wxString result;
 
23465
  void *argp1 = 0 ;
 
23466
  int res1 = 0 ;
 
23467
  PyObject *swig_obj[1] ;
 
23468
  
 
23469
  if (!args) SWIG_fail;
 
23470
  swig_obj[0] = args;
 
23471
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23472
  if (!SWIG_IsOK(res1)) {
 
23473
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetLabel" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23474
  }
 
23475
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23476
  {
 
23477
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23478
    result = (arg1)->GetLabel();
 
23479
    wxPyEndAllowThreads(__tstate);
 
23480
    if (PyErr_Occurred()) SWIG_fail;
 
23481
  }
 
23482
  {
 
23483
#if wxUSE_UNICODE
 
23484
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
23485
#else
 
23486
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
23487
#endif
 
23488
  }
 
23489
  return resultobj;
 
23490
fail:
 
23491
  return NULL;
 
23492
}
 
23493
 
 
23494
 
 
23495
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetShortHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23496
  PyObject *resultobj = 0;
 
23497
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23498
  wxString result;
 
23499
  void *argp1 = 0 ;
 
23500
  int res1 = 0 ;
 
23501
  PyObject *swig_obj[1] ;
 
23502
  
 
23503
  if (!args) SWIG_fail;
 
23504
  swig_obj[0] = args;
 
23505
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23506
  if (!SWIG_IsOK(res1)) {
 
23507
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetShortHelp" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23508
  }
 
23509
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23510
  {
 
23511
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23512
    result = (arg1)->GetShortHelp();
 
23513
    wxPyEndAllowThreads(__tstate);
 
23514
    if (PyErr_Occurred()) SWIG_fail;
 
23515
  }
 
23516
  {
 
23517
#if wxUSE_UNICODE
 
23518
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
23519
#else
 
23520
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
23521
#endif
 
23522
  }
 
23523
  return resultobj;
 
23524
fail:
 
23525
  return NULL;
 
23526
}
 
23527
 
 
23528
 
 
23529
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetLongHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23530
  PyObject *resultobj = 0;
 
23531
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23532
  wxString result;
 
23533
  void *argp1 = 0 ;
 
23534
  int res1 = 0 ;
 
23535
  PyObject *swig_obj[1] ;
 
23536
  
 
23537
  if (!args) SWIG_fail;
 
23538
  swig_obj[0] = args;
 
23539
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23540
  if (!SWIG_IsOK(res1)) {
 
23541
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetLongHelp" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23542
  }
 
23543
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23544
  {
 
23545
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23546
    result = (arg1)->GetLongHelp();
 
23547
    wxPyEndAllowThreads(__tstate);
 
23548
    if (PyErr_Occurred()) SWIG_fail;
 
23549
  }
 
23550
  {
 
23551
#if wxUSE_UNICODE
 
23552
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
23553
#else
 
23554
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
23555
#endif
 
23556
  }
 
23557
  return resultobj;
 
23558
fail:
 
23559
  return NULL;
 
23560
}
 
23561
 
 
23562
 
 
23563
SWIGINTERN PyObject *_wrap_ToolBarToolBase_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
23564
  PyObject *resultobj = 0;
 
23565
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23566
  bool arg2 ;
 
23567
  bool result;
 
23568
  void *argp1 = 0 ;
 
23569
  int res1 = 0 ;
 
23570
  bool val2 ;
 
23571
  int ecode2 = 0 ;
 
23572
  PyObject * obj0 = 0 ;
 
23573
  PyObject * obj1 = 0 ;
 
23574
  char *  kwnames[] = {
 
23575
    (char *) "self",(char *) "enable", NULL 
 
23576
  };
 
23577
  
 
23578
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
 
23579
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23580
  if (!SWIG_IsOK(res1)) {
 
23581
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_Enable" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23582
  }
 
23583
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23584
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
23585
  if (!SWIG_IsOK(ecode2)) {
 
23586
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarToolBase_Enable" "', expected argument " "2"" of type '" "bool""'");
 
23587
  } 
 
23588
  arg2 = static_cast< bool >(val2);
 
23589
  {
 
23590
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23591
    result = (bool)(arg1)->Enable(arg2);
 
23592
    wxPyEndAllowThreads(__tstate);
 
23593
    if (PyErr_Occurred()) SWIG_fail;
 
23594
  }
 
23595
  {
 
23596
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
23597
  }
 
23598
  return resultobj;
 
23599
fail:
 
23600
  return NULL;
 
23601
}
 
23602
 
 
23603
 
 
23604
SWIGINTERN PyObject *_wrap_ToolBarToolBase_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23605
  PyObject *resultobj = 0;
 
23606
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23607
  void *argp1 = 0 ;
 
23608
  int res1 = 0 ;
 
23609
  PyObject *swig_obj[1] ;
 
23610
  
 
23611
  if (!args) SWIG_fail;
 
23612
  swig_obj[0] = args;
 
23613
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23614
  if (!SWIG_IsOK(res1)) {
 
23615
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_Toggle" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23616
  }
 
23617
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23618
  {
 
23619
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23620
    (arg1)->Toggle();
 
23621
    wxPyEndAllowThreads(__tstate);
 
23622
    if (PyErr_Occurred()) SWIG_fail;
 
23623
  }
 
23624
  resultobj = SWIG_Py_Void();
 
23625
  return resultobj;
 
23626
fail:
 
23627
  return NULL;
 
23628
}
 
23629
 
 
23630
 
 
23631
SWIGINTERN PyObject *_wrap_ToolBarToolBase_SetToggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
23632
  PyObject *resultobj = 0;
 
23633
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23634
  bool arg2 ;
 
23635
  bool result;
 
23636
  void *argp1 = 0 ;
 
23637
  int res1 = 0 ;
 
23638
  bool val2 ;
 
23639
  int ecode2 = 0 ;
 
23640
  PyObject * obj0 = 0 ;
 
23641
  PyObject * obj1 = 0 ;
 
23642
  char *  kwnames[] = {
 
23643
    (char *) "self",(char *) "toggle", NULL 
 
23644
  };
 
23645
  
 
23646
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetToggle",kwnames,&obj0,&obj1)) SWIG_fail;
 
23647
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23648
  if (!SWIG_IsOK(res1)) {
 
23649
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_SetToggle" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23650
  }
 
23651
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23652
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
23653
  if (!SWIG_IsOK(ecode2)) {
 
23654
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarToolBase_SetToggle" "', expected argument " "2"" of type '" "bool""'");
 
23655
  } 
 
23656
  arg2 = static_cast< bool >(val2);
 
23657
  {
 
23658
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23659
    result = (bool)(arg1)->SetToggle(arg2);
 
23660
    wxPyEndAllowThreads(__tstate);
 
23661
    if (PyErr_Occurred()) SWIG_fail;
 
23662
  }
 
23663
  {
 
23664
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
23665
  }
 
23666
  return resultobj;
 
23667
fail:
 
23668
  return NULL;
 
23669
}
 
23670
 
 
23671
 
 
23672
SWIGINTERN PyObject *_wrap_ToolBarToolBase_SetShortHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
23673
  PyObject *resultobj = 0;
 
23674
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23675
  wxString *arg2 = 0 ;
 
23676
  bool result;
 
23677
  void *argp1 = 0 ;
 
23678
  int res1 = 0 ;
 
23679
  bool temp2 = false ;
 
23680
  PyObject * obj0 = 0 ;
 
23681
  PyObject * obj1 = 0 ;
 
23682
  char *  kwnames[] = {
 
23683
    (char *) "self",(char *) "help", NULL 
 
23684
  };
 
23685
  
 
23686
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetShortHelp",kwnames,&obj0,&obj1)) SWIG_fail;
 
23687
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23688
  if (!SWIG_IsOK(res1)) {
 
23689
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_SetShortHelp" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23690
  }
 
23691
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23692
  {
 
23693
    arg2 = wxString_in_helper(obj1);
 
23694
    if (arg2 == NULL) SWIG_fail;
 
23695
    temp2 = true;
 
23696
  }
 
23697
  {
 
23698
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23699
    result = (bool)(arg1)->SetShortHelp((wxString const &)*arg2);
 
23700
    wxPyEndAllowThreads(__tstate);
 
23701
    if (PyErr_Occurred()) SWIG_fail;
 
23702
  }
 
23703
  {
 
23704
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
23705
  }
 
23706
  {
 
23707
    if (temp2)
 
23708
    delete arg2;
 
23709
  }
 
23710
  return resultobj;
 
23711
fail:
 
23712
  {
 
23713
    if (temp2)
 
23714
    delete arg2;
 
23715
  }
 
23716
  return NULL;
 
23717
}
 
23718
 
 
23719
 
 
23720
SWIGINTERN PyObject *_wrap_ToolBarToolBase_SetLongHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
23721
  PyObject *resultobj = 0;
 
23722
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23723
  wxString *arg2 = 0 ;
 
23724
  bool result;
 
23725
  void *argp1 = 0 ;
 
23726
  int res1 = 0 ;
 
23727
  bool temp2 = false ;
 
23728
  PyObject * obj0 = 0 ;
 
23729
  PyObject * obj1 = 0 ;
 
23730
  char *  kwnames[] = {
 
23731
    (char *) "self",(char *) "help", NULL 
 
23732
  };
 
23733
  
 
23734
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetLongHelp",kwnames,&obj0,&obj1)) SWIG_fail;
 
23735
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23736
  if (!SWIG_IsOK(res1)) {
 
23737
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_SetLongHelp" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23738
  }
 
23739
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23740
  {
 
23741
    arg2 = wxString_in_helper(obj1);
 
23742
    if (arg2 == NULL) SWIG_fail;
 
23743
    temp2 = true;
 
23744
  }
 
23745
  {
 
23746
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23747
    result = (bool)(arg1)->SetLongHelp((wxString const &)*arg2);
 
23748
    wxPyEndAllowThreads(__tstate);
 
23749
    if (PyErr_Occurred()) SWIG_fail;
 
23750
  }
 
23751
  {
 
23752
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
23753
  }
 
23754
  {
 
23755
    if (temp2)
 
23756
    delete arg2;
 
23757
  }
 
23758
  return resultobj;
 
23759
fail:
 
23760
  {
 
23761
    if (temp2)
 
23762
    delete arg2;
 
23763
  }
 
23764
  return NULL;
 
23765
}
 
23766
 
 
23767
 
 
23768
SWIGINTERN PyObject *_wrap_ToolBarToolBase_SetNormalBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
23769
  PyObject *resultobj = 0;
 
23770
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23771
  wxBitmap *arg2 = 0 ;
 
23772
  void *argp1 = 0 ;
 
23773
  int res1 = 0 ;
 
23774
  void *argp2 = 0 ;
 
23775
  int res2 = 0 ;
 
23776
  PyObject * obj0 = 0 ;
 
23777
  PyObject * obj1 = 0 ;
 
23778
  char *  kwnames[] = {
 
23779
    (char *) "self",(char *) "bmp", NULL 
 
23780
  };
 
23781
  
 
23782
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetNormalBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
 
23783
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23784
  if (!SWIG_IsOK(res1)) {
 
23785
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_SetNormalBitmap" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23786
  }
 
23787
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23788
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
23789
  if (!SWIG_IsOK(res2)) {
 
23790
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ToolBarToolBase_SetNormalBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
23791
  }
 
23792
  if (!argp2) {
 
23793
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ToolBarToolBase_SetNormalBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
23794
  }
 
23795
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
23796
  {
 
23797
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23798
    (arg1)->SetNormalBitmap((wxBitmap const &)*arg2);
 
23799
    wxPyEndAllowThreads(__tstate);
 
23800
    if (PyErr_Occurred()) SWIG_fail;
 
23801
  }
 
23802
  resultobj = SWIG_Py_Void();
 
23803
  return resultobj;
 
23804
fail:
 
23805
  return NULL;
 
23806
}
 
23807
 
 
23808
 
 
23809
SWIGINTERN PyObject *_wrap_ToolBarToolBase_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
23810
  PyObject *resultobj = 0;
 
23811
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23812
  wxBitmap *arg2 = 0 ;
 
23813
  void *argp1 = 0 ;
 
23814
  int res1 = 0 ;
 
23815
  void *argp2 = 0 ;
 
23816
  int res2 = 0 ;
 
23817
  PyObject * obj0 = 0 ;
 
23818
  PyObject * obj1 = 0 ;
 
23819
  char *  kwnames[] = {
 
23820
    (char *) "self",(char *) "bmp", NULL 
 
23821
  };
 
23822
  
 
23823
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
 
23824
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23825
  if (!SWIG_IsOK(res1)) {
 
23826
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23827
  }
 
23828
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23829
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
23830
  if (!SWIG_IsOK(res2)) {
 
23831
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ToolBarToolBase_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
23832
  }
 
23833
  if (!argp2) {
 
23834
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ToolBarToolBase_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
23835
  }
 
23836
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
23837
  {
 
23838
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23839
    (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
 
23840
    wxPyEndAllowThreads(__tstate);
 
23841
    if (PyErr_Occurred()) SWIG_fail;
 
23842
  }
 
23843
  resultobj = SWIG_Py_Void();
 
23844
  return resultobj;
 
23845
fail:
 
23846
  return NULL;
 
23847
}
 
23848
 
 
23849
 
 
23850
SWIGINTERN PyObject *_wrap_ToolBarToolBase_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
23851
  PyObject *resultobj = 0;
 
23852
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23853
  wxString *arg2 = 0 ;
 
23854
  void *argp1 = 0 ;
 
23855
  int res1 = 0 ;
 
23856
  bool temp2 = false ;
 
23857
  PyObject * obj0 = 0 ;
 
23858
  PyObject * obj1 = 0 ;
 
23859
  char *  kwnames[] = {
 
23860
    (char *) "self",(char *) "label", NULL 
 
23861
  };
 
23862
  
 
23863
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
 
23864
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23865
  if (!SWIG_IsOK(res1)) {
 
23866
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_SetLabel" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23867
  }
 
23868
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23869
  {
 
23870
    arg2 = wxString_in_helper(obj1);
 
23871
    if (arg2 == NULL) SWIG_fail;
 
23872
    temp2 = true;
 
23873
  }
 
23874
  {
 
23875
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23876
    (arg1)->SetLabel((wxString const &)*arg2);
 
23877
    wxPyEndAllowThreads(__tstate);
 
23878
    if (PyErr_Occurred()) SWIG_fail;
 
23879
  }
 
23880
  resultobj = SWIG_Py_Void();
 
23881
  {
 
23882
    if (temp2)
 
23883
    delete arg2;
 
23884
  }
 
23885
  return resultobj;
 
23886
fail:
 
23887
  {
 
23888
    if (temp2)
 
23889
    delete arg2;
 
23890
  }
 
23891
  return NULL;
 
23892
}
 
23893
 
 
23894
 
 
23895
SWIGINTERN PyObject *_wrap_ToolBarToolBase_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23896
  PyObject *resultobj = 0;
 
23897
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23898
  void *argp1 = 0 ;
 
23899
  int res1 = 0 ;
 
23900
  PyObject *swig_obj[1] ;
 
23901
  
 
23902
  if (!args) SWIG_fail;
 
23903
  swig_obj[0] = args;
 
23904
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23905
  if (!SWIG_IsOK(res1)) {
 
23906
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_Detach" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23907
  }
 
23908
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23909
  {
 
23910
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23911
    (arg1)->Detach();
 
23912
    wxPyEndAllowThreads(__tstate);
 
23913
    if (PyErr_Occurred()) SWIG_fail;
 
23914
  }
 
23915
  resultobj = SWIG_Py_Void();
 
23916
  return resultobj;
 
23917
fail:
 
23918
  return NULL;
 
23919
}
 
23920
 
 
23921
 
 
23922
SWIGINTERN PyObject *_wrap_ToolBarToolBase_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
23923
  PyObject *resultobj = 0;
 
23924
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23925
  wxToolBarBase *arg2 = (wxToolBarBase *) 0 ;
 
23926
  void *argp1 = 0 ;
 
23927
  int res1 = 0 ;
 
23928
  void *argp2 = 0 ;
 
23929
  int res2 = 0 ;
 
23930
  PyObject * obj0 = 0 ;
 
23931
  PyObject * obj1 = 0 ;
 
23932
  char *  kwnames[] = {
 
23933
    (char *) "self",(char *) "tbar", NULL 
 
23934
  };
 
23935
  
 
23936
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
 
23937
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23938
  if (!SWIG_IsOK(res1)) {
 
23939
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_Attach" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23940
  }
 
23941
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23942
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
23943
  if (!SWIG_IsOK(res2)) {
 
23944
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ToolBarToolBase_Attach" "', expected argument " "2"" of type '" "wxToolBarBase *""'"); 
 
23945
  }
 
23946
  arg2 = reinterpret_cast< wxToolBarBase * >(argp2);
 
23947
  {
 
23948
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23949
    (arg1)->Attach(arg2);
 
23950
    wxPyEndAllowThreads(__tstate);
 
23951
    if (PyErr_Occurred()) SWIG_fail;
 
23952
  }
 
23953
  resultobj = SWIG_Py_Void();
 
23954
  return resultobj;
 
23955
fail:
 
23956
  return NULL;
 
23957
}
 
23958
 
 
23959
 
 
23960
SWIGINTERN PyObject *_wrap_ToolBarToolBase_SetDropdownMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
23961
  PyObject *resultobj = 0;
 
23962
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
23963
  wxMenu *arg2 = (wxMenu *) 0 ;
 
23964
  void *argp1 = 0 ;
 
23965
  int res1 = 0 ;
 
23966
  void *argp2 = 0 ;
 
23967
  int res2 = 0 ;
 
23968
  PyObject * obj0 = 0 ;
 
23969
  PyObject * obj1 = 0 ;
 
23970
  char *  kwnames[] = {
 
23971
    (char *) "self",(char *) "menu", NULL 
 
23972
  };
 
23973
  
 
23974
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetDropdownMenu",kwnames,&obj0,&obj1)) SWIG_fail;
 
23975
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
23976
  if (!SWIG_IsOK(res1)) {
 
23977
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_SetDropdownMenu" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
23978
  }
 
23979
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
23980
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 |  0 );
 
23981
  if (!SWIG_IsOK(res2)) {
 
23982
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ToolBarToolBase_SetDropdownMenu" "', expected argument " "2"" of type '" "wxMenu *""'"); 
 
23983
  }
 
23984
  arg2 = reinterpret_cast< wxMenu * >(argp2);
 
23985
  {
 
23986
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
23987
    (arg1)->SetDropdownMenu(arg2);
 
23988
    wxPyEndAllowThreads(__tstate);
 
23989
    if (PyErr_Occurred()) SWIG_fail;
 
23990
  }
 
23991
  resultobj = SWIG_Py_Void();
 
23992
  return resultobj;
 
23993
fail:
 
23994
  return NULL;
 
23995
}
 
23996
 
 
23997
 
 
23998
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetDropdownMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
23999
  PyObject *resultobj = 0;
 
24000
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
24001
  wxMenu *result = 0 ;
 
24002
  void *argp1 = 0 ;
 
24003
  int res1 = 0 ;
 
24004
  PyObject *swig_obj[1] ;
 
24005
  
 
24006
  if (!args) SWIG_fail;
 
24007
  swig_obj[0] = args;
 
24008
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
24009
  if (!SWIG_IsOK(res1)) {
 
24010
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetDropdownMenu" "', expected argument " "1"" of type '" "wxToolBarToolBase const *""'"); 
 
24011
  }
 
24012
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
24013
  {
 
24014
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24015
    result = (wxMenu *)((wxToolBarToolBase const *)arg1)->GetDropdownMenu();
 
24016
    wxPyEndAllowThreads(__tstate);
 
24017
    if (PyErr_Occurred()) SWIG_fail;
 
24018
  }
 
24019
  {
 
24020
    resultobj = wxPyMake_wxObject(result, 0); 
 
24021
  }
 
24022
  return resultobj;
 
24023
fail:
 
24024
  return NULL;
 
24025
}
 
24026
 
 
24027
 
 
24028
SWIGINTERN PyObject *_wrap_ToolBarToolBase_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
24029
  PyObject *resultobj = 0;
 
24030
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
24031
  PyObject *result = 0 ;
 
24032
  void *argp1 = 0 ;
 
24033
  int res1 = 0 ;
 
24034
  PyObject *swig_obj[1] ;
 
24035
  
 
24036
  if (!args) SWIG_fail;
 
24037
  swig_obj[0] = args;
 
24038
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
24039
  if (!SWIG_IsOK(res1)) {
 
24040
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_GetClientData" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
24041
  }
 
24042
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
24043
  {
 
24044
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24045
    result = (PyObject *)wxToolBarToolBase_GetClientData(arg1);
 
24046
    wxPyEndAllowThreads(__tstate);
 
24047
    if (PyErr_Occurred()) SWIG_fail;
 
24048
  }
 
24049
  resultobj = result;
 
24050
  return resultobj;
 
24051
fail:
 
24052
  return NULL;
 
24053
}
 
24054
 
 
24055
 
 
24056
SWIGINTERN PyObject *_wrap_ToolBarToolBase_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24057
  PyObject *resultobj = 0;
 
24058
  wxToolBarToolBase *arg1 = (wxToolBarToolBase *) 0 ;
 
24059
  PyObject *arg2 = (PyObject *) 0 ;
 
24060
  void *argp1 = 0 ;
 
24061
  int res1 = 0 ;
 
24062
  PyObject * obj0 = 0 ;
 
24063
  PyObject * obj1 = 0 ;
 
24064
  char *  kwnames[] = {
 
24065
    (char *) "self",(char *) "clientData", NULL 
 
24066
  };
 
24067
  
 
24068
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarToolBase_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
 
24069
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
24070
  if (!SWIG_IsOK(res1)) {
 
24071
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarToolBase_SetClientData" "', expected argument " "1"" of type '" "wxToolBarToolBase *""'"); 
 
24072
  }
 
24073
  arg1 = reinterpret_cast< wxToolBarToolBase * >(argp1);
 
24074
  arg2 = obj1;
 
24075
  {
 
24076
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24077
    wxToolBarToolBase_SetClientData(arg1,arg2);
 
24078
    wxPyEndAllowThreads(__tstate);
 
24079
    if (PyErr_Occurred()) SWIG_fail;
 
24080
  }
 
24081
  resultobj = SWIG_Py_Void();
 
24082
  return resultobj;
 
24083
fail:
 
24084
  return NULL;
 
24085
}
 
24086
 
 
24087
 
 
24088
SWIGINTERN PyObject *ToolBarToolBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
24089
  PyObject *obj;
 
24090
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
24091
  SWIG_TypeNewClientData(SWIGTYPE_p_wxToolBarToolBase, SWIG_NewClientData(obj));
 
24092
  return SWIG_Py_Void();
 
24093
}
 
24094
 
 
24095
SWIGINTERN PyObject *_wrap_ToolBarBase_DoAddTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24096
  PyObject *resultobj = 0;
 
24097
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24098
  int arg2 ;
 
24099
  wxString *arg3 = 0 ;
 
24100
  wxBitmap *arg4 = 0 ;
 
24101
  wxBitmap const &arg5_defvalue = wxNullBitmap ;
 
24102
  wxBitmap *arg5 = (wxBitmap *) &arg5_defvalue ;
 
24103
  wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
 
24104
  wxString const &arg7_defvalue = wxPyEmptyString ;
 
24105
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
24106
  wxString const &arg8_defvalue = wxPyEmptyString ;
 
24107
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
24108
  PyObject *arg9 = (PyObject *) NULL ;
 
24109
  wxToolBarToolBase *result = 0 ;
 
24110
  void *argp1 = 0 ;
 
24111
  int res1 = 0 ;
 
24112
  int val2 ;
 
24113
  int ecode2 = 0 ;
 
24114
  bool temp3 = false ;
 
24115
  void *argp4 = 0 ;
 
24116
  int res4 = 0 ;
 
24117
  void *argp5 = 0 ;
 
24118
  int res5 = 0 ;
 
24119
  int val6 ;
 
24120
  int ecode6 = 0 ;
 
24121
  bool temp7 = false ;
 
24122
  bool temp8 = false ;
 
24123
  PyObject * obj0 = 0 ;
 
24124
  PyObject * obj1 = 0 ;
 
24125
  PyObject * obj2 = 0 ;
 
24126
  PyObject * obj3 = 0 ;
 
24127
  PyObject * obj4 = 0 ;
 
24128
  PyObject * obj5 = 0 ;
 
24129
  PyObject * obj6 = 0 ;
 
24130
  PyObject * obj7 = 0 ;
 
24131
  PyObject * obj8 = 0 ;
 
24132
  char *  kwnames[] = {
 
24133
    (char *) "self",(char *) "id",(char *) "label",(char *) "bitmap",(char *) "bmpDisabled",(char *) "kind",(char *) "shortHelp",(char *) "longHelp",(char *) "clientData", NULL 
 
24134
  };
 
24135
  
 
24136
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOOO:ToolBarBase_DoAddTool",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
24137
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24138
  if (!SWIG_IsOK(res1)) {
 
24139
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_DoAddTool" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24140
  }
 
24141
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24142
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
24143
  if (!SWIG_IsOK(ecode2)) {
 
24144
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_DoAddTool" "', expected argument " "2"" of type '" "int""'");
 
24145
  } 
 
24146
  arg2 = static_cast< int >(val2);
 
24147
  {
 
24148
    arg3 = wxString_in_helper(obj2);
 
24149
    if (arg3 == NULL) SWIG_fail;
 
24150
    temp3 = true;
 
24151
  }
 
24152
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap,  0  | 0);
 
24153
  if (!SWIG_IsOK(res4)) {
 
24154
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ToolBarBase_DoAddTool" "', expected argument " "4"" of type '" "wxBitmap const &""'"); 
 
24155
  }
 
24156
  if (!argp4) {
 
24157
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ToolBarBase_DoAddTool" "', expected argument " "4"" of type '" "wxBitmap const &""'"); 
 
24158
  }
 
24159
  arg4 = reinterpret_cast< wxBitmap * >(argp4);
 
24160
  if (obj4) {
 
24161
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxBitmap,  0  | 0);
 
24162
    if (!SWIG_IsOK(res5)) {
 
24163
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ToolBarBase_DoAddTool" "', expected argument " "5"" of type '" "wxBitmap const &""'"); 
 
24164
    }
 
24165
    if (!argp5) {
 
24166
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ToolBarBase_DoAddTool" "', expected argument " "5"" of type '" "wxBitmap const &""'"); 
 
24167
    }
 
24168
    arg5 = reinterpret_cast< wxBitmap * >(argp5);
 
24169
  }
 
24170
  if (obj5) {
 
24171
    ecode6 = SWIG_AsVal_int(obj5, &val6);
 
24172
    if (!SWIG_IsOK(ecode6)) {
 
24173
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ToolBarBase_DoAddTool" "', expected argument " "6"" of type '" "wxItemKind""'");
 
24174
    } 
 
24175
    arg6 = static_cast< wxItemKind >(val6);
 
24176
  }
 
24177
  if (obj6) {
 
24178
    {
 
24179
      arg7 = wxString_in_helper(obj6);
 
24180
      if (arg7 == NULL) SWIG_fail;
 
24181
      temp7 = true;
 
24182
    }
 
24183
  }
 
24184
  if (obj7) {
 
24185
    {
 
24186
      arg8 = wxString_in_helper(obj7);
 
24187
      if (arg8 == NULL) SWIG_fail;
 
24188
      temp8 = true;
 
24189
    }
 
24190
  }
 
24191
  if (obj8) {
 
24192
    arg9 = obj8;
 
24193
  }
 
24194
  {
 
24195
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24196
    result = (wxToolBarToolBase *)wxToolBarBase_DoAddTool(arg1,arg2,(wxString const &)*arg3,(wxBitmap const &)*arg4,(wxBitmap const &)*arg5,arg6,(wxString const &)*arg7,(wxString const &)*arg8,arg9);
 
24197
    wxPyEndAllowThreads(__tstate);
 
24198
    if (PyErr_Occurred()) SWIG_fail;
 
24199
  }
 
24200
  {
 
24201
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24202
  }
 
24203
  {
 
24204
    if (temp3)
 
24205
    delete arg3;
 
24206
  }
 
24207
  {
 
24208
    if (temp7)
 
24209
    delete arg7;
 
24210
  }
 
24211
  {
 
24212
    if (temp8)
 
24213
    delete arg8;
 
24214
  }
 
24215
  return resultobj;
 
24216
fail:
 
24217
  {
 
24218
    if (temp3)
 
24219
    delete arg3;
 
24220
  }
 
24221
  {
 
24222
    if (temp7)
 
24223
    delete arg7;
 
24224
  }
 
24225
  {
 
24226
    if (temp8)
 
24227
    delete arg8;
 
24228
  }
 
24229
  return NULL;
 
24230
}
 
24231
 
 
24232
 
 
24233
SWIGINTERN PyObject *_wrap_ToolBarBase_DoInsertTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24234
  PyObject *resultobj = 0;
 
24235
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24236
  size_t arg2 ;
 
24237
  int arg3 ;
 
24238
  wxString *arg4 = 0 ;
 
24239
  wxBitmap *arg5 = 0 ;
 
24240
  wxBitmap const &arg6_defvalue = wxNullBitmap ;
 
24241
  wxBitmap *arg6 = (wxBitmap *) &arg6_defvalue ;
 
24242
  wxItemKind arg7 = (wxItemKind) wxITEM_NORMAL ;
 
24243
  wxString const &arg8_defvalue = wxPyEmptyString ;
 
24244
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
24245
  wxString const &arg9_defvalue = wxPyEmptyString ;
 
24246
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
24247
  PyObject *arg10 = (PyObject *) NULL ;
 
24248
  wxToolBarToolBase *result = 0 ;
 
24249
  void *argp1 = 0 ;
 
24250
  int res1 = 0 ;
 
24251
  size_t val2 ;
 
24252
  int ecode2 = 0 ;
 
24253
  int val3 ;
 
24254
  int ecode3 = 0 ;
 
24255
  bool temp4 = false ;
 
24256
  void *argp5 = 0 ;
 
24257
  int res5 = 0 ;
 
24258
  void *argp6 = 0 ;
 
24259
  int res6 = 0 ;
 
24260
  int val7 ;
 
24261
  int ecode7 = 0 ;
 
24262
  bool temp8 = false ;
 
24263
  bool temp9 = false ;
 
24264
  PyObject * obj0 = 0 ;
 
24265
  PyObject * obj1 = 0 ;
 
24266
  PyObject * obj2 = 0 ;
 
24267
  PyObject * obj3 = 0 ;
 
24268
  PyObject * obj4 = 0 ;
 
24269
  PyObject * obj5 = 0 ;
 
24270
  PyObject * obj6 = 0 ;
 
24271
  PyObject * obj7 = 0 ;
 
24272
  PyObject * obj8 = 0 ;
 
24273
  PyObject * obj9 = 0 ;
 
24274
  char *  kwnames[] = {
 
24275
    (char *) "self",(char *) "pos",(char *) "id",(char *) "label",(char *) "bitmap",(char *) "bmpDisabled",(char *) "kind",(char *) "shortHelp",(char *) "longHelp",(char *) "clientData", NULL 
 
24276
  };
 
24277
  
 
24278
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:ToolBarBase_DoInsertTool",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
 
24279
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24280
  if (!SWIG_IsOK(res1)) {
 
24281
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_DoInsertTool" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24282
  }
 
24283
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24284
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
24285
  if (!SWIG_IsOK(ecode2)) {
 
24286
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_DoInsertTool" "', expected argument " "2"" of type '" "size_t""'");
 
24287
  } 
 
24288
  arg2 = static_cast< size_t >(val2);
 
24289
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
24290
  if (!SWIG_IsOK(ecode3)) {
 
24291
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ToolBarBase_DoInsertTool" "', expected argument " "3"" of type '" "int""'");
 
24292
  } 
 
24293
  arg3 = static_cast< int >(val3);
 
24294
  {
 
24295
    arg4 = wxString_in_helper(obj3);
 
24296
    if (arg4 == NULL) SWIG_fail;
 
24297
    temp4 = true;
 
24298
  }
 
24299
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxBitmap,  0  | 0);
 
24300
  if (!SWIG_IsOK(res5)) {
 
24301
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ToolBarBase_DoInsertTool" "', expected argument " "5"" of type '" "wxBitmap const &""'"); 
 
24302
  }
 
24303
  if (!argp5) {
 
24304
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ToolBarBase_DoInsertTool" "', expected argument " "5"" of type '" "wxBitmap const &""'"); 
 
24305
  }
 
24306
  arg5 = reinterpret_cast< wxBitmap * >(argp5);
 
24307
  if (obj5) {
 
24308
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxBitmap,  0  | 0);
 
24309
    if (!SWIG_IsOK(res6)) {
 
24310
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ToolBarBase_DoInsertTool" "', expected argument " "6"" of type '" "wxBitmap const &""'"); 
 
24311
    }
 
24312
    if (!argp6) {
 
24313
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ToolBarBase_DoInsertTool" "', expected argument " "6"" of type '" "wxBitmap const &""'"); 
 
24314
    }
 
24315
    arg6 = reinterpret_cast< wxBitmap * >(argp6);
 
24316
  }
 
24317
  if (obj6) {
 
24318
    ecode7 = SWIG_AsVal_int(obj6, &val7);
 
24319
    if (!SWIG_IsOK(ecode7)) {
 
24320
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ToolBarBase_DoInsertTool" "', expected argument " "7"" of type '" "wxItemKind""'");
 
24321
    } 
 
24322
    arg7 = static_cast< wxItemKind >(val7);
 
24323
  }
 
24324
  if (obj7) {
 
24325
    {
 
24326
      arg8 = wxString_in_helper(obj7);
 
24327
      if (arg8 == NULL) SWIG_fail;
 
24328
      temp8 = true;
 
24329
    }
 
24330
  }
 
24331
  if (obj8) {
 
24332
    {
 
24333
      arg9 = wxString_in_helper(obj8);
 
24334
      if (arg9 == NULL) SWIG_fail;
 
24335
      temp9 = true;
 
24336
    }
 
24337
  }
 
24338
  if (obj9) {
 
24339
    arg10 = obj9;
 
24340
  }
 
24341
  {
 
24342
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24343
    result = (wxToolBarToolBase *)wxToolBarBase_DoInsertTool(arg1,arg2,arg3,(wxString const &)*arg4,(wxBitmap const &)*arg5,(wxBitmap const &)*arg6,arg7,(wxString const &)*arg8,(wxString const &)*arg9,arg10);
 
24344
    wxPyEndAllowThreads(__tstate);
 
24345
    if (PyErr_Occurred()) SWIG_fail;
 
24346
  }
 
24347
  {
 
24348
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24349
  }
 
24350
  {
 
24351
    if (temp4)
 
24352
    delete arg4;
 
24353
  }
 
24354
  {
 
24355
    if (temp8)
 
24356
    delete arg8;
 
24357
  }
 
24358
  {
 
24359
    if (temp9)
 
24360
    delete arg9;
 
24361
  }
 
24362
  return resultobj;
 
24363
fail:
 
24364
  {
 
24365
    if (temp4)
 
24366
    delete arg4;
 
24367
  }
 
24368
  {
 
24369
    if (temp8)
 
24370
    delete arg8;
 
24371
  }
 
24372
  {
 
24373
    if (temp9)
 
24374
    delete arg9;
 
24375
  }
 
24376
  return NULL;
 
24377
}
 
24378
 
 
24379
 
 
24380
SWIGINTERN PyObject *_wrap_ToolBarBase_AddToolItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24381
  PyObject *resultobj = 0;
 
24382
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24383
  wxToolBarToolBase *arg2 = (wxToolBarToolBase *) 0 ;
 
24384
  wxToolBarToolBase *result = 0 ;
 
24385
  void *argp1 = 0 ;
 
24386
  int res1 = 0 ;
 
24387
  void *argp2 = 0 ;
 
24388
  int res2 = 0 ;
 
24389
  PyObject * obj0 = 0 ;
 
24390
  PyObject * obj1 = 0 ;
 
24391
  char *  kwnames[] = {
 
24392
    (char *) "self",(char *) "tool", NULL 
 
24393
  };
 
24394
  
 
24395
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_AddToolItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
24396
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24397
  if (!SWIG_IsOK(res1)) {
 
24398
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_AddToolItem" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24399
  }
 
24400
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24401
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
24402
  if (!SWIG_IsOK(res2)) {
 
24403
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ToolBarBase_AddToolItem" "', expected argument " "2"" of type '" "wxToolBarToolBase *""'"); 
 
24404
  }
 
24405
  arg2 = reinterpret_cast< wxToolBarToolBase * >(argp2);
 
24406
  {
 
24407
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24408
    result = (wxToolBarToolBase *)(arg1)->AddTool(arg2);
 
24409
    wxPyEndAllowThreads(__tstate);
 
24410
    if (PyErr_Occurred()) SWIG_fail;
 
24411
  }
 
24412
  {
 
24413
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24414
  }
 
24415
  return resultobj;
 
24416
fail:
 
24417
  return NULL;
 
24418
}
 
24419
 
 
24420
 
 
24421
SWIGINTERN PyObject *_wrap_ToolBarBase_InsertToolItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24422
  PyObject *resultobj = 0;
 
24423
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24424
  size_t arg2 ;
 
24425
  wxToolBarToolBase *arg3 = (wxToolBarToolBase *) 0 ;
 
24426
  wxToolBarToolBase *result = 0 ;
 
24427
  void *argp1 = 0 ;
 
24428
  int res1 = 0 ;
 
24429
  size_t val2 ;
 
24430
  int ecode2 = 0 ;
 
24431
  void *argp3 = 0 ;
 
24432
  int res3 = 0 ;
 
24433
  PyObject * obj0 = 0 ;
 
24434
  PyObject * obj1 = 0 ;
 
24435
  PyObject * obj2 = 0 ;
 
24436
  char *  kwnames[] = {
 
24437
    (char *) "self",(char *) "pos",(char *) "tool", NULL 
 
24438
  };
 
24439
  
 
24440
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_InsertToolItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
24441
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24442
  if (!SWIG_IsOK(res1)) {
 
24443
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_InsertToolItem" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24444
  }
 
24445
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24446
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
24447
  if (!SWIG_IsOK(ecode2)) {
 
24448
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_InsertToolItem" "', expected argument " "2"" of type '" "size_t""'");
 
24449
  } 
 
24450
  arg2 = static_cast< size_t >(val2);
 
24451
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxToolBarToolBase, 0 |  0 );
 
24452
  if (!SWIG_IsOK(res3)) {
 
24453
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ToolBarBase_InsertToolItem" "', expected argument " "3"" of type '" "wxToolBarToolBase *""'"); 
 
24454
  }
 
24455
  arg3 = reinterpret_cast< wxToolBarToolBase * >(argp3);
 
24456
  {
 
24457
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24458
    result = (wxToolBarToolBase *)(arg1)->InsertTool(arg2,arg3);
 
24459
    wxPyEndAllowThreads(__tstate);
 
24460
    if (PyErr_Occurred()) SWIG_fail;
 
24461
  }
 
24462
  {
 
24463
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24464
  }
 
24465
  return resultobj;
 
24466
fail:
 
24467
  return NULL;
 
24468
}
 
24469
 
 
24470
 
 
24471
SWIGINTERN PyObject *_wrap_ToolBarBase_AddControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24472
  PyObject *resultobj = 0;
 
24473
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24474
  wxControl *arg2 = (wxControl *) 0 ;
 
24475
  wxString const &arg3_defvalue = wxEmptyString ;
 
24476
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
24477
  wxToolBarToolBase *result = 0 ;
 
24478
  void *argp1 = 0 ;
 
24479
  int res1 = 0 ;
 
24480
  void *argp2 = 0 ;
 
24481
  int res2 = 0 ;
 
24482
  bool temp3 = false ;
 
24483
  PyObject * obj0 = 0 ;
 
24484
  PyObject * obj1 = 0 ;
 
24485
  PyObject * obj2 = 0 ;
 
24486
  char *  kwnames[] = {
 
24487
    (char *) "self",(char *) "control",(char *) "label", NULL 
 
24488
  };
 
24489
  
 
24490
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ToolBarBase_AddControl",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
24491
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24492
  if (!SWIG_IsOK(res1)) {
 
24493
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_AddControl" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24494
  }
 
24495
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24496
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 |  0 );
 
24497
  if (!SWIG_IsOK(res2)) {
 
24498
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ToolBarBase_AddControl" "', expected argument " "2"" of type '" "wxControl *""'"); 
 
24499
  }
 
24500
  arg2 = reinterpret_cast< wxControl * >(argp2);
 
24501
  if (obj2) {
 
24502
    {
 
24503
      arg3 = wxString_in_helper(obj2);
 
24504
      if (arg3 == NULL) SWIG_fail;
 
24505
      temp3 = true;
 
24506
    }
 
24507
  }
 
24508
  {
 
24509
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24510
    result = (wxToolBarToolBase *)(arg1)->AddControl(arg2,(wxString const &)*arg3);
 
24511
    wxPyEndAllowThreads(__tstate);
 
24512
    if (PyErr_Occurred()) SWIG_fail;
 
24513
  }
 
24514
  {
 
24515
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24516
  }
 
24517
  {
 
24518
    if (temp3)
 
24519
    delete arg3;
 
24520
  }
 
24521
  return resultobj;
 
24522
fail:
 
24523
  {
 
24524
    if (temp3)
 
24525
    delete arg3;
 
24526
  }
 
24527
  return NULL;
 
24528
}
 
24529
 
 
24530
 
 
24531
SWIGINTERN PyObject *_wrap_ToolBarBase_InsertControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24532
  PyObject *resultobj = 0;
 
24533
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24534
  size_t arg2 ;
 
24535
  wxControl *arg3 = (wxControl *) 0 ;
 
24536
  wxString const &arg4_defvalue = wxEmptyString ;
 
24537
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
24538
  wxToolBarToolBase *result = 0 ;
 
24539
  void *argp1 = 0 ;
 
24540
  int res1 = 0 ;
 
24541
  size_t val2 ;
 
24542
  int ecode2 = 0 ;
 
24543
  void *argp3 = 0 ;
 
24544
  int res3 = 0 ;
 
24545
  bool temp4 = false ;
 
24546
  PyObject * obj0 = 0 ;
 
24547
  PyObject * obj1 = 0 ;
 
24548
  PyObject * obj2 = 0 ;
 
24549
  PyObject * obj3 = 0 ;
 
24550
  char *  kwnames[] = {
 
24551
    (char *) "self",(char *) "pos",(char *) "control",(char *) "label", NULL 
 
24552
  };
 
24553
  
 
24554
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ToolBarBase_InsertControl",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
24555
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24556
  if (!SWIG_IsOK(res1)) {
 
24557
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_InsertControl" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24558
  }
 
24559
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24560
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
24561
  if (!SWIG_IsOK(ecode2)) {
 
24562
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_InsertControl" "', expected argument " "2"" of type '" "size_t""'");
 
24563
  } 
 
24564
  arg2 = static_cast< size_t >(val2);
 
24565
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxControl, 0 |  0 );
 
24566
  if (!SWIG_IsOK(res3)) {
 
24567
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ToolBarBase_InsertControl" "', expected argument " "3"" of type '" "wxControl *""'"); 
 
24568
  }
 
24569
  arg3 = reinterpret_cast< wxControl * >(argp3);
 
24570
  if (obj3) {
 
24571
    {
 
24572
      arg4 = wxString_in_helper(obj3);
 
24573
      if (arg4 == NULL) SWIG_fail;
 
24574
      temp4 = true;
 
24575
    }
 
24576
  }
 
24577
  {
 
24578
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24579
    result = (wxToolBarToolBase *)(arg1)->InsertControl(arg2,arg3,(wxString const &)*arg4);
 
24580
    wxPyEndAllowThreads(__tstate);
 
24581
    if (PyErr_Occurred()) SWIG_fail;
 
24582
  }
 
24583
  {
 
24584
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24585
  }
 
24586
  {
 
24587
    if (temp4)
 
24588
    delete arg4;
 
24589
  }
 
24590
  return resultobj;
 
24591
fail:
 
24592
  {
 
24593
    if (temp4)
 
24594
    delete arg4;
 
24595
  }
 
24596
  return NULL;
 
24597
}
 
24598
 
 
24599
 
 
24600
SWIGINTERN PyObject *_wrap_ToolBarBase_FindControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24601
  PyObject *resultobj = 0;
 
24602
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24603
  int arg2 ;
 
24604
  wxControl *result = 0 ;
 
24605
  void *argp1 = 0 ;
 
24606
  int res1 = 0 ;
 
24607
  int val2 ;
 
24608
  int ecode2 = 0 ;
 
24609
  PyObject * obj0 = 0 ;
 
24610
  PyObject * obj1 = 0 ;
 
24611
  char *  kwnames[] = {
 
24612
    (char *) "self",(char *) "id", NULL 
 
24613
  };
 
24614
  
 
24615
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_FindControl",kwnames,&obj0,&obj1)) SWIG_fail;
 
24616
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24617
  if (!SWIG_IsOK(res1)) {
 
24618
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_FindControl" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24619
  }
 
24620
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24621
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
24622
  if (!SWIG_IsOK(ecode2)) {
 
24623
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_FindControl" "', expected argument " "2"" of type '" "int""'");
 
24624
  } 
 
24625
  arg2 = static_cast< int >(val2);
 
24626
  {
 
24627
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24628
    result = (wxControl *)(arg1)->FindControl(arg2);
 
24629
    wxPyEndAllowThreads(__tstate);
 
24630
    if (PyErr_Occurred()) SWIG_fail;
 
24631
  }
 
24632
  {
 
24633
    resultobj = wxPyMake_wxObject(result, 0); 
 
24634
  }
 
24635
  return resultobj;
 
24636
fail:
 
24637
  return NULL;
 
24638
}
 
24639
 
 
24640
 
 
24641
SWIGINTERN PyObject *_wrap_ToolBarBase_AddSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
24642
  PyObject *resultobj = 0;
 
24643
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24644
  wxToolBarToolBase *result = 0 ;
 
24645
  void *argp1 = 0 ;
 
24646
  int res1 = 0 ;
 
24647
  PyObject *swig_obj[1] ;
 
24648
  
 
24649
  if (!args) SWIG_fail;
 
24650
  swig_obj[0] = args;
 
24651
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24652
  if (!SWIG_IsOK(res1)) {
 
24653
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_AddSeparator" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24654
  }
 
24655
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24656
  {
 
24657
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24658
    result = (wxToolBarToolBase *)(arg1)->AddSeparator();
 
24659
    wxPyEndAllowThreads(__tstate);
 
24660
    if (PyErr_Occurred()) SWIG_fail;
 
24661
  }
 
24662
  {
 
24663
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24664
  }
 
24665
  return resultobj;
 
24666
fail:
 
24667
  return NULL;
 
24668
}
 
24669
 
 
24670
 
 
24671
SWIGINTERN PyObject *_wrap_ToolBarBase_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24672
  PyObject *resultobj = 0;
 
24673
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24674
  size_t arg2 ;
 
24675
  wxToolBarToolBase *result = 0 ;
 
24676
  void *argp1 = 0 ;
 
24677
  int res1 = 0 ;
 
24678
  size_t val2 ;
 
24679
  int ecode2 = 0 ;
 
24680
  PyObject * obj0 = 0 ;
 
24681
  PyObject * obj1 = 0 ;
 
24682
  char *  kwnames[] = {
 
24683
    (char *) "self",(char *) "pos", NULL 
 
24684
  };
 
24685
  
 
24686
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
 
24687
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24688
  if (!SWIG_IsOK(res1)) {
 
24689
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_InsertSeparator" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24690
  }
 
24691
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24692
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
24693
  if (!SWIG_IsOK(ecode2)) {
 
24694
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
 
24695
  } 
 
24696
  arg2 = static_cast< size_t >(val2);
 
24697
  {
 
24698
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24699
    result = (wxToolBarToolBase *)(arg1)->InsertSeparator(arg2);
 
24700
    wxPyEndAllowThreads(__tstate);
 
24701
    if (PyErr_Occurred()) SWIG_fail;
 
24702
  }
 
24703
  {
 
24704
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24705
  }
 
24706
  return resultobj;
 
24707
fail:
 
24708
  return NULL;
 
24709
}
 
24710
 
 
24711
 
 
24712
SWIGINTERN PyObject *_wrap_ToolBarBase_AddStretchableSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
24713
  PyObject *resultobj = 0;
 
24714
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24715
  wxToolBarToolBase *result = 0 ;
 
24716
  void *argp1 = 0 ;
 
24717
  int res1 = 0 ;
 
24718
  PyObject *swig_obj[1] ;
 
24719
  
 
24720
  if (!args) SWIG_fail;
 
24721
  swig_obj[0] = args;
 
24722
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24723
  if (!SWIG_IsOK(res1)) {
 
24724
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_AddStretchableSpace" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24725
  }
 
24726
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24727
  {
 
24728
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24729
    result = (wxToolBarToolBase *)(arg1)->AddStretchableSpace();
 
24730
    wxPyEndAllowThreads(__tstate);
 
24731
    if (PyErr_Occurred()) SWIG_fail;
 
24732
  }
 
24733
  {
 
24734
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24735
  }
 
24736
  return resultobj;
 
24737
fail:
 
24738
  return NULL;
 
24739
}
 
24740
 
 
24741
 
 
24742
SWIGINTERN PyObject *_wrap_ToolBarBase_InsertStretchableSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24743
  PyObject *resultobj = 0;
 
24744
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24745
  size_t arg2 ;
 
24746
  wxToolBarToolBase *result = 0 ;
 
24747
  void *argp1 = 0 ;
 
24748
  int res1 = 0 ;
 
24749
  size_t val2 ;
 
24750
  int ecode2 = 0 ;
 
24751
  PyObject * obj0 = 0 ;
 
24752
  PyObject * obj1 = 0 ;
 
24753
  char *  kwnames[] = {
 
24754
    (char *) "self",(char *) "pos", NULL 
 
24755
  };
 
24756
  
 
24757
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_InsertStretchableSpace",kwnames,&obj0,&obj1)) SWIG_fail;
 
24758
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24759
  if (!SWIG_IsOK(res1)) {
 
24760
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_InsertStretchableSpace" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24761
  }
 
24762
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24763
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
24764
  if (!SWIG_IsOK(ecode2)) {
 
24765
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_InsertStretchableSpace" "', expected argument " "2"" of type '" "size_t""'");
 
24766
  } 
 
24767
  arg2 = static_cast< size_t >(val2);
 
24768
  {
 
24769
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24770
    result = (wxToolBarToolBase *)(arg1)->InsertStretchableSpace(arg2);
 
24771
    wxPyEndAllowThreads(__tstate);
 
24772
    if (PyErr_Occurred()) SWIG_fail;
 
24773
  }
 
24774
  {
 
24775
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24776
  }
 
24777
  return resultobj;
 
24778
fail:
 
24779
  return NULL;
 
24780
}
 
24781
 
 
24782
 
 
24783
SWIGINTERN PyObject *_wrap_ToolBarBase_RemoveTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24784
  PyObject *resultobj = 0;
 
24785
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24786
  int arg2 ;
 
24787
  wxToolBarToolBase *result = 0 ;
 
24788
  void *argp1 = 0 ;
 
24789
  int res1 = 0 ;
 
24790
  int val2 ;
 
24791
  int ecode2 = 0 ;
 
24792
  PyObject * obj0 = 0 ;
 
24793
  PyObject * obj1 = 0 ;
 
24794
  char *  kwnames[] = {
 
24795
    (char *) "self",(char *) "id", NULL 
 
24796
  };
 
24797
  
 
24798
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_RemoveTool",kwnames,&obj0,&obj1)) SWIG_fail;
 
24799
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24800
  if (!SWIG_IsOK(res1)) {
 
24801
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_RemoveTool" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24802
  }
 
24803
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24804
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
24805
  if (!SWIG_IsOK(ecode2)) {
 
24806
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_RemoveTool" "', expected argument " "2"" of type '" "int""'");
 
24807
  } 
 
24808
  arg2 = static_cast< int >(val2);
 
24809
  {
 
24810
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24811
    result = (wxToolBarToolBase *)(arg1)->RemoveTool(arg2);
 
24812
    wxPyEndAllowThreads(__tstate);
 
24813
    if (PyErr_Occurred()) SWIG_fail;
 
24814
  }
 
24815
  {
 
24816
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
24817
  }
 
24818
  return resultobj;
 
24819
fail:
 
24820
  return NULL;
 
24821
}
 
24822
 
 
24823
 
 
24824
SWIGINTERN PyObject *_wrap_ToolBarBase_DeleteToolByPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24825
  PyObject *resultobj = 0;
 
24826
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24827
  size_t arg2 ;
 
24828
  bool result;
 
24829
  void *argp1 = 0 ;
 
24830
  int res1 = 0 ;
 
24831
  size_t val2 ;
 
24832
  int ecode2 = 0 ;
 
24833
  PyObject * obj0 = 0 ;
 
24834
  PyObject * obj1 = 0 ;
 
24835
  char *  kwnames[] = {
 
24836
    (char *) "self",(char *) "pos", NULL 
 
24837
  };
 
24838
  
 
24839
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_DeleteToolByPos",kwnames,&obj0,&obj1)) SWIG_fail;
 
24840
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24841
  if (!SWIG_IsOK(res1)) {
 
24842
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_DeleteToolByPos" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24843
  }
 
24844
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24845
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
 
24846
  if (!SWIG_IsOK(ecode2)) {
 
24847
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_DeleteToolByPos" "', expected argument " "2"" of type '" "size_t""'");
 
24848
  } 
 
24849
  arg2 = static_cast< size_t >(val2);
 
24850
  {
 
24851
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24852
    result = (bool)(arg1)->DeleteToolByPos(arg2);
 
24853
    wxPyEndAllowThreads(__tstate);
 
24854
    if (PyErr_Occurred()) SWIG_fail;
 
24855
  }
 
24856
  {
 
24857
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
24858
  }
 
24859
  return resultobj;
 
24860
fail:
 
24861
  return NULL;
 
24862
}
 
24863
 
 
24864
 
 
24865
SWIGINTERN PyObject *_wrap_ToolBarBase_DeleteTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24866
  PyObject *resultobj = 0;
 
24867
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24868
  int arg2 ;
 
24869
  bool result;
 
24870
  void *argp1 = 0 ;
 
24871
  int res1 = 0 ;
 
24872
  int val2 ;
 
24873
  int ecode2 = 0 ;
 
24874
  PyObject * obj0 = 0 ;
 
24875
  PyObject * obj1 = 0 ;
 
24876
  char *  kwnames[] = {
 
24877
    (char *) "self",(char *) "id", NULL 
 
24878
  };
 
24879
  
 
24880
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_DeleteTool",kwnames,&obj0,&obj1)) SWIG_fail;
 
24881
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24882
  if (!SWIG_IsOK(res1)) {
 
24883
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_DeleteTool" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24884
  }
 
24885
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24886
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
24887
  if (!SWIG_IsOK(ecode2)) {
 
24888
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_DeleteTool" "', expected argument " "2"" of type '" "int""'");
 
24889
  } 
 
24890
  arg2 = static_cast< int >(val2);
 
24891
  {
 
24892
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24893
    result = (bool)(arg1)->DeleteTool(arg2);
 
24894
    wxPyEndAllowThreads(__tstate);
 
24895
    if (PyErr_Occurred()) SWIG_fail;
 
24896
  }
 
24897
  {
 
24898
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
24899
  }
 
24900
  return resultobj;
 
24901
fail:
 
24902
  return NULL;
 
24903
}
 
24904
 
 
24905
 
 
24906
SWIGINTERN PyObject *_wrap_ToolBarBase_ClearTools(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
24907
  PyObject *resultobj = 0;
 
24908
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24909
  void *argp1 = 0 ;
 
24910
  int res1 = 0 ;
 
24911
  PyObject *swig_obj[1] ;
 
24912
  
 
24913
  if (!args) SWIG_fail;
 
24914
  swig_obj[0] = args;
 
24915
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24916
  if (!SWIG_IsOK(res1)) {
 
24917
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_ClearTools" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24918
  }
 
24919
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24920
  {
 
24921
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24922
    (arg1)->ClearTools();
 
24923
    wxPyEndAllowThreads(__tstate);
 
24924
    if (PyErr_Occurred()) SWIG_fail;
 
24925
  }
 
24926
  resultobj = SWIG_Py_Void();
 
24927
  return resultobj;
 
24928
fail:
 
24929
  return NULL;
 
24930
}
 
24931
 
 
24932
 
 
24933
SWIGINTERN PyObject *_wrap_ToolBarBase_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
24934
  PyObject *resultobj = 0;
 
24935
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24936
  bool result;
 
24937
  void *argp1 = 0 ;
 
24938
  int res1 = 0 ;
 
24939
  PyObject *swig_obj[1] ;
 
24940
  
 
24941
  if (!args) SWIG_fail;
 
24942
  swig_obj[0] = args;
 
24943
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24944
  if (!SWIG_IsOK(res1)) {
 
24945
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_Realize" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24946
  }
 
24947
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24948
  {
 
24949
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24950
    result = (bool)(arg1)->Realize();
 
24951
    wxPyEndAllowThreads(__tstate);
 
24952
    if (PyErr_Occurred()) SWIG_fail;
 
24953
  }
 
24954
  {
 
24955
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
24956
  }
 
24957
  return resultobj;
 
24958
fail:
 
24959
  return NULL;
 
24960
}
 
24961
 
 
24962
 
 
24963
SWIGINTERN PyObject *_wrap_ToolBarBase_EnableTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
24964
  PyObject *resultobj = 0;
 
24965
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
24966
  int arg2 ;
 
24967
  bool arg3 ;
 
24968
  void *argp1 = 0 ;
 
24969
  int res1 = 0 ;
 
24970
  int val2 ;
 
24971
  int ecode2 = 0 ;
 
24972
  bool val3 ;
 
24973
  int ecode3 = 0 ;
 
24974
  PyObject * obj0 = 0 ;
 
24975
  PyObject * obj1 = 0 ;
 
24976
  PyObject * obj2 = 0 ;
 
24977
  char *  kwnames[] = {
 
24978
    (char *) "self",(char *) "id",(char *) "enable", NULL 
 
24979
  };
 
24980
  
 
24981
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_EnableTool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
24982
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
24983
  if (!SWIG_IsOK(res1)) {
 
24984
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_EnableTool" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
24985
  }
 
24986
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
24987
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
24988
  if (!SWIG_IsOK(ecode2)) {
 
24989
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_EnableTool" "', expected argument " "2"" of type '" "int""'");
 
24990
  } 
 
24991
  arg2 = static_cast< int >(val2);
 
24992
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
24993
  if (!SWIG_IsOK(ecode3)) {
 
24994
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ToolBarBase_EnableTool" "', expected argument " "3"" of type '" "bool""'");
 
24995
  } 
 
24996
  arg3 = static_cast< bool >(val3);
 
24997
  {
 
24998
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
24999
    (arg1)->EnableTool(arg2,arg3);
 
25000
    wxPyEndAllowThreads(__tstate);
 
25001
    if (PyErr_Occurred()) SWIG_fail;
 
25002
  }
 
25003
  resultobj = SWIG_Py_Void();
 
25004
  return resultobj;
 
25005
fail:
 
25006
  return NULL;
 
25007
}
 
25008
 
 
25009
 
 
25010
SWIGINTERN PyObject *_wrap_ToolBarBase_ToggleTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25011
  PyObject *resultobj = 0;
 
25012
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25013
  int arg2 ;
 
25014
  bool arg3 ;
 
25015
  void *argp1 = 0 ;
 
25016
  int res1 = 0 ;
 
25017
  int val2 ;
 
25018
  int ecode2 = 0 ;
 
25019
  bool val3 ;
 
25020
  int ecode3 = 0 ;
 
25021
  PyObject * obj0 = 0 ;
 
25022
  PyObject * obj1 = 0 ;
 
25023
  PyObject * obj2 = 0 ;
 
25024
  char *  kwnames[] = {
 
25025
    (char *) "self",(char *) "id",(char *) "toggle", NULL 
 
25026
  };
 
25027
  
 
25028
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_ToggleTool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
25029
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25030
  if (!SWIG_IsOK(res1)) {
 
25031
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_ToggleTool" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25032
  }
 
25033
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25034
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25035
  if (!SWIG_IsOK(ecode2)) {
 
25036
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_ToggleTool" "', expected argument " "2"" of type '" "int""'");
 
25037
  } 
 
25038
  arg2 = static_cast< int >(val2);
 
25039
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
25040
  if (!SWIG_IsOK(ecode3)) {
 
25041
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ToolBarBase_ToggleTool" "', expected argument " "3"" of type '" "bool""'");
 
25042
  } 
 
25043
  arg3 = static_cast< bool >(val3);
 
25044
  {
 
25045
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25046
    (arg1)->ToggleTool(arg2,arg3);
 
25047
    wxPyEndAllowThreads(__tstate);
 
25048
    if (PyErr_Occurred()) SWIG_fail;
 
25049
  }
 
25050
  resultobj = SWIG_Py_Void();
 
25051
  return resultobj;
 
25052
fail:
 
25053
  return NULL;
 
25054
}
 
25055
 
 
25056
 
 
25057
SWIGINTERN PyObject *_wrap_ToolBarBase_SetToggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25058
  PyObject *resultobj = 0;
 
25059
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25060
  int arg2 ;
 
25061
  bool arg3 ;
 
25062
  void *argp1 = 0 ;
 
25063
  int res1 = 0 ;
 
25064
  int val2 ;
 
25065
  int ecode2 = 0 ;
 
25066
  bool val3 ;
 
25067
  int ecode3 = 0 ;
 
25068
  PyObject * obj0 = 0 ;
 
25069
  PyObject * obj1 = 0 ;
 
25070
  PyObject * obj2 = 0 ;
 
25071
  char *  kwnames[] = {
 
25072
    (char *) "self",(char *) "id",(char *) "toggle", NULL 
 
25073
  };
 
25074
  
 
25075
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToggle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
25076
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25077
  if (!SWIG_IsOK(res1)) {
 
25078
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetToggle" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25079
  }
 
25080
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25081
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25082
  if (!SWIG_IsOK(ecode2)) {
 
25083
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_SetToggle" "', expected argument " "2"" of type '" "int""'");
 
25084
  } 
 
25085
  arg2 = static_cast< int >(val2);
 
25086
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
25087
  if (!SWIG_IsOK(ecode3)) {
 
25088
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ToolBarBase_SetToggle" "', expected argument " "3"" of type '" "bool""'");
 
25089
  } 
 
25090
  arg3 = static_cast< bool >(val3);
 
25091
  {
 
25092
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25093
    (arg1)->SetToggle(arg2,arg3);
 
25094
    wxPyEndAllowThreads(__tstate);
 
25095
    if (PyErr_Occurred()) SWIG_fail;
 
25096
  }
 
25097
  resultobj = SWIG_Py_Void();
 
25098
  return resultobj;
 
25099
fail:
 
25100
  return NULL;
 
25101
}
 
25102
 
 
25103
 
 
25104
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25105
  PyObject *resultobj = 0;
 
25106
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25107
  int arg2 ;
 
25108
  PyObject *result = 0 ;
 
25109
  void *argp1 = 0 ;
 
25110
  int res1 = 0 ;
 
25111
  int val2 ;
 
25112
  int ecode2 = 0 ;
 
25113
  PyObject * obj0 = 0 ;
 
25114
  PyObject * obj1 = 0 ;
 
25115
  char *  kwnames[] = {
 
25116
    (char *) "self",(char *) "id", NULL 
 
25117
  };
 
25118
  
 
25119
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolClientData",kwnames,&obj0,&obj1)) SWIG_fail;
 
25120
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25121
  if (!SWIG_IsOK(res1)) {
 
25122
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolClientData" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25123
  }
 
25124
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25125
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25126
  if (!SWIG_IsOK(ecode2)) {
 
25127
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_GetToolClientData" "', expected argument " "2"" of type '" "int""'");
 
25128
  } 
 
25129
  arg2 = static_cast< int >(val2);
 
25130
  {
 
25131
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25132
    result = (PyObject *)wxToolBarBase_GetToolClientData(arg1,arg2);
 
25133
    wxPyEndAllowThreads(__tstate);
 
25134
    if (PyErr_Occurred()) SWIG_fail;
 
25135
  }
 
25136
  resultobj = result;
 
25137
  return resultobj;
 
25138
fail:
 
25139
  return NULL;
 
25140
}
 
25141
 
 
25142
 
 
25143
SWIGINTERN PyObject *_wrap_ToolBarBase_SetToolClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25144
  PyObject *resultobj = 0;
 
25145
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25146
  int arg2 ;
 
25147
  PyObject *arg3 = (PyObject *) 0 ;
 
25148
  void *argp1 = 0 ;
 
25149
  int res1 = 0 ;
 
25150
  int val2 ;
 
25151
  int ecode2 = 0 ;
 
25152
  PyObject * obj0 = 0 ;
 
25153
  PyObject * obj1 = 0 ;
 
25154
  PyObject * obj2 = 0 ;
 
25155
  char *  kwnames[] = {
 
25156
    (char *) "self",(char *) "id",(char *) "clientData", NULL 
 
25157
  };
 
25158
  
 
25159
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToolClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
25160
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25161
  if (!SWIG_IsOK(res1)) {
 
25162
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetToolClientData" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25163
  }
 
25164
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25165
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25166
  if (!SWIG_IsOK(ecode2)) {
 
25167
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_SetToolClientData" "', expected argument " "2"" of type '" "int""'");
 
25168
  } 
 
25169
  arg2 = static_cast< int >(val2);
 
25170
  arg3 = obj2;
 
25171
  {
 
25172
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25173
    wxToolBarBase_SetToolClientData(arg1,arg2,arg3);
 
25174
    wxPyEndAllowThreads(__tstate);
 
25175
    if (PyErr_Occurred()) SWIG_fail;
 
25176
  }
 
25177
  resultobj = SWIG_Py_Void();
 
25178
  return resultobj;
 
25179
fail:
 
25180
  return NULL;
 
25181
}
 
25182
 
 
25183
 
 
25184
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25185
  PyObject *resultobj = 0;
 
25186
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25187
  int arg2 ;
 
25188
  int result;
 
25189
  void *argp1 = 0 ;
 
25190
  int res1 = 0 ;
 
25191
  int val2 ;
 
25192
  int ecode2 = 0 ;
 
25193
  PyObject * obj0 = 0 ;
 
25194
  PyObject * obj1 = 0 ;
 
25195
  char *  kwnames[] = {
 
25196
    (char *) "self",(char *) "id", NULL 
 
25197
  };
 
25198
  
 
25199
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolPos",kwnames,&obj0,&obj1)) SWIG_fail;
 
25200
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25201
  if (!SWIG_IsOK(res1)) {
 
25202
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolPos" "', expected argument " "1"" of type '" "wxToolBarBase const *""'"); 
 
25203
  }
 
25204
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25205
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25206
  if (!SWIG_IsOK(ecode2)) {
 
25207
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_GetToolPos" "', expected argument " "2"" of type '" "int""'");
 
25208
  } 
 
25209
  arg2 = static_cast< int >(val2);
 
25210
  {
 
25211
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25212
    result = (int)((wxToolBarBase const *)arg1)->GetToolPos(arg2);
 
25213
    wxPyEndAllowThreads(__tstate);
 
25214
    if (PyErr_Occurred()) SWIG_fail;
 
25215
  }
 
25216
  resultobj = SWIG_From_int(static_cast< int >(result));
 
25217
  return resultobj;
 
25218
fail:
 
25219
  return NULL;
 
25220
}
 
25221
 
 
25222
 
 
25223
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25224
  PyObject *resultobj = 0;
 
25225
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25226
  int arg2 ;
 
25227
  bool result;
 
25228
  void *argp1 = 0 ;
 
25229
  int res1 = 0 ;
 
25230
  int val2 ;
 
25231
  int ecode2 = 0 ;
 
25232
  PyObject * obj0 = 0 ;
 
25233
  PyObject * obj1 = 0 ;
 
25234
  char *  kwnames[] = {
 
25235
    (char *) "self",(char *) "id", NULL 
 
25236
  };
 
25237
  
 
25238
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolState",kwnames,&obj0,&obj1)) SWIG_fail;
 
25239
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25240
  if (!SWIG_IsOK(res1)) {
 
25241
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolState" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25242
  }
 
25243
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25244
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25245
  if (!SWIG_IsOK(ecode2)) {
 
25246
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_GetToolState" "', expected argument " "2"" of type '" "int""'");
 
25247
  } 
 
25248
  arg2 = static_cast< int >(val2);
 
25249
  {
 
25250
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25251
    result = (bool)(arg1)->GetToolState(arg2);
 
25252
    wxPyEndAllowThreads(__tstate);
 
25253
    if (PyErr_Occurred()) SWIG_fail;
 
25254
  }
 
25255
  {
 
25256
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
25257
  }
 
25258
  return resultobj;
 
25259
fail:
 
25260
  return NULL;
 
25261
}
 
25262
 
 
25263
 
 
25264
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25265
  PyObject *resultobj = 0;
 
25266
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25267
  int arg2 ;
 
25268
  bool result;
 
25269
  void *argp1 = 0 ;
 
25270
  int res1 = 0 ;
 
25271
  int val2 ;
 
25272
  int ecode2 = 0 ;
 
25273
  PyObject * obj0 = 0 ;
 
25274
  PyObject * obj1 = 0 ;
 
25275
  char *  kwnames[] = {
 
25276
    (char *) "self",(char *) "id", NULL 
 
25277
  };
 
25278
  
 
25279
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
 
25280
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25281
  if (!SWIG_IsOK(res1)) {
 
25282
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolEnabled" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25283
  }
 
25284
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25285
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25286
  if (!SWIG_IsOK(ecode2)) {
 
25287
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_GetToolEnabled" "', expected argument " "2"" of type '" "int""'");
 
25288
  } 
 
25289
  arg2 = static_cast< int >(val2);
 
25290
  {
 
25291
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25292
    result = (bool)(arg1)->GetToolEnabled(arg2);
 
25293
    wxPyEndAllowThreads(__tstate);
 
25294
    if (PyErr_Occurred()) SWIG_fail;
 
25295
  }
 
25296
  {
 
25297
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
25298
  }
 
25299
  return resultobj;
 
25300
fail:
 
25301
  return NULL;
 
25302
}
 
25303
 
 
25304
 
 
25305
SWIGINTERN PyObject *_wrap_ToolBarBase_SetToolShortHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25306
  PyObject *resultobj = 0;
 
25307
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25308
  int arg2 ;
 
25309
  wxString *arg3 = 0 ;
 
25310
  void *argp1 = 0 ;
 
25311
  int res1 = 0 ;
 
25312
  int val2 ;
 
25313
  int ecode2 = 0 ;
 
25314
  bool temp3 = false ;
 
25315
  PyObject * obj0 = 0 ;
 
25316
  PyObject * obj1 = 0 ;
 
25317
  PyObject * obj2 = 0 ;
 
25318
  char *  kwnames[] = {
 
25319
    (char *) "self",(char *) "id",(char *) "helpString", NULL 
 
25320
  };
 
25321
  
 
25322
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToolShortHelp",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
25323
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25324
  if (!SWIG_IsOK(res1)) {
 
25325
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetToolShortHelp" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25326
  }
 
25327
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25328
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25329
  if (!SWIG_IsOK(ecode2)) {
 
25330
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_SetToolShortHelp" "', expected argument " "2"" of type '" "int""'");
 
25331
  } 
 
25332
  arg2 = static_cast< int >(val2);
 
25333
  {
 
25334
    arg3 = wxString_in_helper(obj2);
 
25335
    if (arg3 == NULL) SWIG_fail;
 
25336
    temp3 = true;
 
25337
  }
 
25338
  {
 
25339
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25340
    (arg1)->SetToolShortHelp(arg2,(wxString const &)*arg3);
 
25341
    wxPyEndAllowThreads(__tstate);
 
25342
    if (PyErr_Occurred()) SWIG_fail;
 
25343
  }
 
25344
  resultobj = SWIG_Py_Void();
 
25345
  {
 
25346
    if (temp3)
 
25347
    delete arg3;
 
25348
  }
 
25349
  return resultobj;
 
25350
fail:
 
25351
  {
 
25352
    if (temp3)
 
25353
    delete arg3;
 
25354
  }
 
25355
  return NULL;
 
25356
}
 
25357
 
 
25358
 
 
25359
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolShortHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25360
  PyObject *resultobj = 0;
 
25361
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25362
  int arg2 ;
 
25363
  wxString result;
 
25364
  void *argp1 = 0 ;
 
25365
  int res1 = 0 ;
 
25366
  int val2 ;
 
25367
  int ecode2 = 0 ;
 
25368
  PyObject * obj0 = 0 ;
 
25369
  PyObject * obj1 = 0 ;
 
25370
  char *  kwnames[] = {
 
25371
    (char *) "self",(char *) "id", NULL 
 
25372
  };
 
25373
  
 
25374
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolShortHelp",kwnames,&obj0,&obj1)) SWIG_fail;
 
25375
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25376
  if (!SWIG_IsOK(res1)) {
 
25377
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolShortHelp" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25378
  }
 
25379
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25380
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25381
  if (!SWIG_IsOK(ecode2)) {
 
25382
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_GetToolShortHelp" "', expected argument " "2"" of type '" "int""'");
 
25383
  } 
 
25384
  arg2 = static_cast< int >(val2);
 
25385
  {
 
25386
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25387
    result = (arg1)->GetToolShortHelp(arg2);
 
25388
    wxPyEndAllowThreads(__tstate);
 
25389
    if (PyErr_Occurred()) SWIG_fail;
 
25390
  }
 
25391
  {
 
25392
#if wxUSE_UNICODE
 
25393
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
25394
#else
 
25395
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
25396
#endif
 
25397
  }
 
25398
  return resultobj;
 
25399
fail:
 
25400
  return NULL;
 
25401
}
 
25402
 
 
25403
 
 
25404
SWIGINTERN PyObject *_wrap_ToolBarBase_SetToolLongHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25405
  PyObject *resultobj = 0;
 
25406
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25407
  int arg2 ;
 
25408
  wxString *arg3 = 0 ;
 
25409
  void *argp1 = 0 ;
 
25410
  int res1 = 0 ;
 
25411
  int val2 ;
 
25412
  int ecode2 = 0 ;
 
25413
  bool temp3 = false ;
 
25414
  PyObject * obj0 = 0 ;
 
25415
  PyObject * obj1 = 0 ;
 
25416
  PyObject * obj2 = 0 ;
 
25417
  char *  kwnames[] = {
 
25418
    (char *) "self",(char *) "id",(char *) "helpString", NULL 
 
25419
  };
 
25420
  
 
25421
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetToolLongHelp",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
25422
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25423
  if (!SWIG_IsOK(res1)) {
 
25424
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetToolLongHelp" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25425
  }
 
25426
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25427
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25428
  if (!SWIG_IsOK(ecode2)) {
 
25429
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_SetToolLongHelp" "', expected argument " "2"" of type '" "int""'");
 
25430
  } 
 
25431
  arg2 = static_cast< int >(val2);
 
25432
  {
 
25433
    arg3 = wxString_in_helper(obj2);
 
25434
    if (arg3 == NULL) SWIG_fail;
 
25435
    temp3 = true;
 
25436
  }
 
25437
  {
 
25438
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25439
    (arg1)->SetToolLongHelp(arg2,(wxString const &)*arg3);
 
25440
    wxPyEndAllowThreads(__tstate);
 
25441
    if (PyErr_Occurred()) SWIG_fail;
 
25442
  }
 
25443
  resultobj = SWIG_Py_Void();
 
25444
  {
 
25445
    if (temp3)
 
25446
    delete arg3;
 
25447
  }
 
25448
  return resultobj;
 
25449
fail:
 
25450
  {
 
25451
    if (temp3)
 
25452
    delete arg3;
 
25453
  }
 
25454
  return NULL;
 
25455
}
 
25456
 
 
25457
 
 
25458
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolLongHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25459
  PyObject *resultobj = 0;
 
25460
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25461
  int arg2 ;
 
25462
  wxString result;
 
25463
  void *argp1 = 0 ;
 
25464
  int res1 = 0 ;
 
25465
  int val2 ;
 
25466
  int ecode2 = 0 ;
 
25467
  PyObject * obj0 = 0 ;
 
25468
  PyObject * obj1 = 0 ;
 
25469
  char *  kwnames[] = {
 
25470
    (char *) "self",(char *) "id", NULL 
 
25471
  };
 
25472
  
 
25473
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolLongHelp",kwnames,&obj0,&obj1)) SWIG_fail;
 
25474
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25475
  if (!SWIG_IsOK(res1)) {
 
25476
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolLongHelp" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25477
  }
 
25478
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25479
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25480
  if (!SWIG_IsOK(ecode2)) {
 
25481
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_GetToolLongHelp" "', expected argument " "2"" of type '" "int""'");
 
25482
  } 
 
25483
  arg2 = static_cast< int >(val2);
 
25484
  {
 
25485
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25486
    result = (arg1)->GetToolLongHelp(arg2);
 
25487
    wxPyEndAllowThreads(__tstate);
 
25488
    if (PyErr_Occurred()) SWIG_fail;
 
25489
  }
 
25490
  {
 
25491
#if wxUSE_UNICODE
 
25492
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
25493
#else
 
25494
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
25495
#endif
 
25496
  }
 
25497
  return resultobj;
 
25498
fail:
 
25499
  return NULL;
 
25500
}
 
25501
 
 
25502
 
 
25503
SWIGINTERN PyObject *_wrap_ToolBarBase_SetMarginsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25504
  PyObject *resultobj = 0;
 
25505
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25506
  int arg2 ;
 
25507
  int arg3 ;
 
25508
  void *argp1 = 0 ;
 
25509
  int res1 = 0 ;
 
25510
  int val2 ;
 
25511
  int ecode2 = 0 ;
 
25512
  int val3 ;
 
25513
  int ecode3 = 0 ;
 
25514
  PyObject * obj0 = 0 ;
 
25515
  PyObject * obj1 = 0 ;
 
25516
  PyObject * obj2 = 0 ;
 
25517
  char *  kwnames[] = {
 
25518
    (char *) "self",(char *) "x",(char *) "y", NULL 
 
25519
  };
 
25520
  
 
25521
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetMarginsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
25522
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25523
  if (!SWIG_IsOK(res1)) {
 
25524
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetMarginsXY" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25525
  }
 
25526
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25527
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25528
  if (!SWIG_IsOK(ecode2)) {
 
25529
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_SetMarginsXY" "', expected argument " "2"" of type '" "int""'");
 
25530
  } 
 
25531
  arg2 = static_cast< int >(val2);
 
25532
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
25533
  if (!SWIG_IsOK(ecode3)) {
 
25534
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ToolBarBase_SetMarginsXY" "', expected argument " "3"" of type '" "int""'");
 
25535
  } 
 
25536
  arg3 = static_cast< int >(val3);
 
25537
  {
 
25538
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25539
    (arg1)->SetMargins(arg2,arg3);
 
25540
    wxPyEndAllowThreads(__tstate);
 
25541
    if (PyErr_Occurred()) SWIG_fail;
 
25542
  }
 
25543
  resultobj = SWIG_Py_Void();
 
25544
  return resultobj;
 
25545
fail:
 
25546
  return NULL;
 
25547
}
 
25548
 
 
25549
 
 
25550
SWIGINTERN PyObject *_wrap_ToolBarBase_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25551
  PyObject *resultobj = 0;
 
25552
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25553
  wxSize *arg2 = 0 ;
 
25554
  void *argp1 = 0 ;
 
25555
  int res1 = 0 ;
 
25556
  wxSize temp2 ;
 
25557
  PyObject * obj0 = 0 ;
 
25558
  PyObject * obj1 = 0 ;
 
25559
  char *  kwnames[] = {
 
25560
    (char *) "self",(char *) "size", NULL 
 
25561
  };
 
25562
  
 
25563
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetMargins",kwnames,&obj0,&obj1)) SWIG_fail;
 
25564
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25565
  if (!SWIG_IsOK(res1)) {
 
25566
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetMargins" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25567
  }
 
25568
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25569
  {
 
25570
    arg2 = &temp2;
 
25571
    if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
 
25572
  }
 
25573
  {
 
25574
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25575
    (arg1)->SetMargins((wxSize const &)*arg2);
 
25576
    wxPyEndAllowThreads(__tstate);
 
25577
    if (PyErr_Occurred()) SWIG_fail;
 
25578
  }
 
25579
  resultobj = SWIG_Py_Void();
 
25580
  return resultobj;
 
25581
fail:
 
25582
  return NULL;
 
25583
}
 
25584
 
 
25585
 
 
25586
SWIGINTERN PyObject *_wrap_ToolBarBase_SetToolPacking(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25587
  PyObject *resultobj = 0;
 
25588
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25589
  int arg2 ;
 
25590
  void *argp1 = 0 ;
 
25591
  int res1 = 0 ;
 
25592
  int val2 ;
 
25593
  int ecode2 = 0 ;
 
25594
  PyObject * obj0 = 0 ;
 
25595
  PyObject * obj1 = 0 ;
 
25596
  char *  kwnames[] = {
 
25597
    (char *) "self",(char *) "packing", NULL 
 
25598
  };
 
25599
  
 
25600
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetToolPacking",kwnames,&obj0,&obj1)) SWIG_fail;
 
25601
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25602
  if (!SWIG_IsOK(res1)) {
 
25603
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetToolPacking" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25604
  }
 
25605
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25606
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25607
  if (!SWIG_IsOK(ecode2)) {
 
25608
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_SetToolPacking" "', expected argument " "2"" of type '" "int""'");
 
25609
  } 
 
25610
  arg2 = static_cast< int >(val2);
 
25611
  {
 
25612
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25613
    (arg1)->SetToolPacking(arg2);
 
25614
    wxPyEndAllowThreads(__tstate);
 
25615
    if (PyErr_Occurred()) SWIG_fail;
 
25616
  }
 
25617
  resultobj = SWIG_Py_Void();
 
25618
  return resultobj;
 
25619
fail:
 
25620
  return NULL;
 
25621
}
 
25622
 
 
25623
 
 
25624
SWIGINTERN PyObject *_wrap_ToolBarBase_SetToolSeparation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25625
  PyObject *resultobj = 0;
 
25626
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25627
  int arg2 ;
 
25628
  void *argp1 = 0 ;
 
25629
  int res1 = 0 ;
 
25630
  int val2 ;
 
25631
  int ecode2 = 0 ;
 
25632
  PyObject * obj0 = 0 ;
 
25633
  PyObject * obj1 = 0 ;
 
25634
  char *  kwnames[] = {
 
25635
    (char *) "self",(char *) "separation", NULL 
 
25636
  };
 
25637
  
 
25638
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetToolSeparation",kwnames,&obj0,&obj1)) SWIG_fail;
 
25639
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25640
  if (!SWIG_IsOK(res1)) {
 
25641
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetToolSeparation" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25642
  }
 
25643
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25644
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25645
  if (!SWIG_IsOK(ecode2)) {
 
25646
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_SetToolSeparation" "', expected argument " "2"" of type '" "int""'");
 
25647
  } 
 
25648
  arg2 = static_cast< int >(val2);
 
25649
  {
 
25650
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25651
    (arg1)->SetToolSeparation(arg2);
 
25652
    wxPyEndAllowThreads(__tstate);
 
25653
    if (PyErr_Occurred()) SWIG_fail;
 
25654
  }
 
25655
  resultobj = SWIG_Py_Void();
 
25656
  return resultobj;
 
25657
fail:
 
25658
  return NULL;
 
25659
}
 
25660
 
 
25661
 
 
25662
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
25663
  PyObject *resultobj = 0;
 
25664
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25665
  wxSize result;
 
25666
  void *argp1 = 0 ;
 
25667
  int res1 = 0 ;
 
25668
  PyObject *swig_obj[1] ;
 
25669
  
 
25670
  if (!args) SWIG_fail;
 
25671
  swig_obj[0] = args;
 
25672
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25673
  if (!SWIG_IsOK(res1)) {
 
25674
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolMargins" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25675
  }
 
25676
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25677
  {
 
25678
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25679
    result = (arg1)->GetToolMargins();
 
25680
    wxPyEndAllowThreads(__tstate);
 
25681
    if (PyErr_Occurred()) SWIG_fail;
 
25682
  }
 
25683
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
25684
  return resultobj;
 
25685
fail:
 
25686
  return NULL;
 
25687
}
 
25688
 
 
25689
 
 
25690
SWIGINTERN PyObject *_wrap_ToolBarBase_GetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
25691
  PyObject *resultobj = 0;
 
25692
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25693
  wxSize result;
 
25694
  void *argp1 = 0 ;
 
25695
  int res1 = 0 ;
 
25696
  PyObject *swig_obj[1] ;
 
25697
  
 
25698
  if (!args) SWIG_fail;
 
25699
  swig_obj[0] = args;
 
25700
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25701
  if (!SWIG_IsOK(res1)) {
 
25702
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetMargins" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25703
  }
 
25704
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25705
  {
 
25706
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25707
    result = (arg1)->GetMargins();
 
25708
    wxPyEndAllowThreads(__tstate);
 
25709
    if (PyErr_Occurred()) SWIG_fail;
 
25710
  }
 
25711
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
25712
  return resultobj;
 
25713
fail:
 
25714
  return NULL;
 
25715
}
 
25716
 
 
25717
 
 
25718
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolPacking(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
25719
  PyObject *resultobj = 0;
 
25720
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25721
  int result;
 
25722
  void *argp1 = 0 ;
 
25723
  int res1 = 0 ;
 
25724
  PyObject *swig_obj[1] ;
 
25725
  
 
25726
  if (!args) SWIG_fail;
 
25727
  swig_obj[0] = args;
 
25728
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25729
  if (!SWIG_IsOK(res1)) {
 
25730
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolPacking" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25731
  }
 
25732
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25733
  {
 
25734
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25735
    result = (int)(arg1)->GetToolPacking();
 
25736
    wxPyEndAllowThreads(__tstate);
 
25737
    if (PyErr_Occurred()) SWIG_fail;
 
25738
  }
 
25739
  resultobj = SWIG_From_int(static_cast< int >(result));
 
25740
  return resultobj;
 
25741
fail:
 
25742
  return NULL;
 
25743
}
 
25744
 
 
25745
 
 
25746
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolSeparation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
25747
  PyObject *resultobj = 0;
 
25748
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25749
  int result;
 
25750
  void *argp1 = 0 ;
 
25751
  int res1 = 0 ;
 
25752
  PyObject *swig_obj[1] ;
 
25753
  
 
25754
  if (!args) SWIG_fail;
 
25755
  swig_obj[0] = args;
 
25756
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25757
  if (!SWIG_IsOK(res1)) {
 
25758
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolSeparation" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25759
  }
 
25760
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25761
  {
 
25762
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25763
    result = (int)(arg1)->GetToolSeparation();
 
25764
    wxPyEndAllowThreads(__tstate);
 
25765
    if (PyErr_Occurred()) SWIG_fail;
 
25766
  }
 
25767
  resultobj = SWIG_From_int(static_cast< int >(result));
 
25768
  return resultobj;
 
25769
fail:
 
25770
  return NULL;
 
25771
}
 
25772
 
 
25773
 
 
25774
SWIGINTERN PyObject *_wrap_ToolBarBase_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25775
  PyObject *resultobj = 0;
 
25776
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25777
  int arg2 ;
 
25778
  void *argp1 = 0 ;
 
25779
  int res1 = 0 ;
 
25780
  int val2 ;
 
25781
  int ecode2 = 0 ;
 
25782
  PyObject * obj0 = 0 ;
 
25783
  PyObject * obj1 = 0 ;
 
25784
  char *  kwnames[] = {
 
25785
    (char *) "self",(char *) "nRows", NULL 
 
25786
  };
 
25787
  
 
25788
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
 
25789
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25790
  if (!SWIG_IsOK(res1)) {
 
25791
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetRows" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25792
  }
 
25793
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25794
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25795
  if (!SWIG_IsOK(ecode2)) {
 
25796
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_SetRows" "', expected argument " "2"" of type '" "int""'");
 
25797
  } 
 
25798
  arg2 = static_cast< int >(val2);
 
25799
  {
 
25800
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25801
    (arg1)->SetRows(arg2);
 
25802
    wxPyEndAllowThreads(__tstate);
 
25803
    if (PyErr_Occurred()) SWIG_fail;
 
25804
  }
 
25805
  resultobj = SWIG_Py_Void();
 
25806
  return resultobj;
 
25807
fail:
 
25808
  return NULL;
 
25809
}
 
25810
 
 
25811
 
 
25812
SWIGINTERN PyObject *_wrap_ToolBarBase_SetMaxRowsCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25813
  PyObject *resultobj = 0;
 
25814
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25815
  int arg2 ;
 
25816
  int arg3 ;
 
25817
  void *argp1 = 0 ;
 
25818
  int res1 = 0 ;
 
25819
  int val2 ;
 
25820
  int ecode2 = 0 ;
 
25821
  int val3 ;
 
25822
  int ecode3 = 0 ;
 
25823
  PyObject * obj0 = 0 ;
 
25824
  PyObject * obj1 = 0 ;
 
25825
  PyObject * obj2 = 0 ;
 
25826
  char *  kwnames[] = {
 
25827
    (char *) "self",(char *) "rows",(char *) "cols", NULL 
 
25828
  };
 
25829
  
 
25830
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetMaxRowsCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
25831
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25832
  if (!SWIG_IsOK(res1)) {
 
25833
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetMaxRowsCols" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25834
  }
 
25835
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25836
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
25837
  if (!SWIG_IsOK(ecode2)) {
 
25838
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_SetMaxRowsCols" "', expected argument " "2"" of type '" "int""'");
 
25839
  } 
 
25840
  arg2 = static_cast< int >(val2);
 
25841
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
25842
  if (!SWIG_IsOK(ecode3)) {
 
25843
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ToolBarBase_SetMaxRowsCols" "', expected argument " "3"" of type '" "int""'");
 
25844
  } 
 
25845
  arg3 = static_cast< int >(val3);
 
25846
  {
 
25847
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25848
    (arg1)->SetMaxRowsCols(arg2,arg3);
 
25849
    wxPyEndAllowThreads(__tstate);
 
25850
    if (PyErr_Occurred()) SWIG_fail;
 
25851
  }
 
25852
  resultobj = SWIG_Py_Void();
 
25853
  return resultobj;
 
25854
fail:
 
25855
  return NULL;
 
25856
}
 
25857
 
 
25858
 
 
25859
SWIGINTERN PyObject *_wrap_ToolBarBase_GetMaxRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
25860
  PyObject *resultobj = 0;
 
25861
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25862
  int result;
 
25863
  void *argp1 = 0 ;
 
25864
  int res1 = 0 ;
 
25865
  PyObject *swig_obj[1] ;
 
25866
  
 
25867
  if (!args) SWIG_fail;
 
25868
  swig_obj[0] = args;
 
25869
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25870
  if (!SWIG_IsOK(res1)) {
 
25871
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetMaxRows" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25872
  }
 
25873
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25874
  {
 
25875
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25876
    result = (int)(arg1)->GetMaxRows();
 
25877
    wxPyEndAllowThreads(__tstate);
 
25878
    if (PyErr_Occurred()) SWIG_fail;
 
25879
  }
 
25880
  resultobj = SWIG_From_int(static_cast< int >(result));
 
25881
  return resultobj;
 
25882
fail:
 
25883
  return NULL;
 
25884
}
 
25885
 
 
25886
 
 
25887
SWIGINTERN PyObject *_wrap_ToolBarBase_GetMaxCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
25888
  PyObject *resultobj = 0;
 
25889
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25890
  int result;
 
25891
  void *argp1 = 0 ;
 
25892
  int res1 = 0 ;
 
25893
  PyObject *swig_obj[1] ;
 
25894
  
 
25895
  if (!args) SWIG_fail;
 
25896
  swig_obj[0] = args;
 
25897
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25898
  if (!SWIG_IsOK(res1)) {
 
25899
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetMaxCols" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25900
  }
 
25901
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25902
  {
 
25903
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25904
    result = (int)(arg1)->GetMaxCols();
 
25905
    wxPyEndAllowThreads(__tstate);
 
25906
    if (PyErr_Occurred()) SWIG_fail;
 
25907
  }
 
25908
  resultobj = SWIG_From_int(static_cast< int >(result));
 
25909
  return resultobj;
 
25910
fail:
 
25911
  return NULL;
 
25912
}
 
25913
 
 
25914
 
 
25915
SWIGINTERN PyObject *_wrap_ToolBarBase_SetToolBitmapSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
25916
  PyObject *resultobj = 0;
 
25917
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25918
  wxSize *arg2 = 0 ;
 
25919
  void *argp1 = 0 ;
 
25920
  int res1 = 0 ;
 
25921
  wxSize temp2 ;
 
25922
  PyObject * obj0 = 0 ;
 
25923
  PyObject * obj1 = 0 ;
 
25924
  char *  kwnames[] = {
 
25925
    (char *) "self",(char *) "size", NULL 
 
25926
  };
 
25927
  
 
25928
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_SetToolBitmapSize",kwnames,&obj0,&obj1)) SWIG_fail;
 
25929
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25930
  if (!SWIG_IsOK(res1)) {
 
25931
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetToolBitmapSize" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25932
  }
 
25933
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25934
  {
 
25935
    arg2 = &temp2;
 
25936
    if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
 
25937
  }
 
25938
  {
 
25939
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25940
    (arg1)->SetToolBitmapSize((wxSize const &)*arg2);
 
25941
    wxPyEndAllowThreads(__tstate);
 
25942
    if (PyErr_Occurred()) SWIG_fail;
 
25943
  }
 
25944
  resultobj = SWIG_Py_Void();
 
25945
  return resultobj;
 
25946
fail:
 
25947
  return NULL;
 
25948
}
 
25949
 
 
25950
 
 
25951
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolBitmapSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
25952
  PyObject *resultobj = 0;
 
25953
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25954
  wxSize result;
 
25955
  void *argp1 = 0 ;
 
25956
  int res1 = 0 ;
 
25957
  PyObject *swig_obj[1] ;
 
25958
  
 
25959
  if (!args) SWIG_fail;
 
25960
  swig_obj[0] = args;
 
25961
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25962
  if (!SWIG_IsOK(res1)) {
 
25963
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolBitmapSize" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25964
  }
 
25965
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25966
  {
 
25967
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25968
    result = (arg1)->GetToolBitmapSize();
 
25969
    wxPyEndAllowThreads(__tstate);
 
25970
    if (PyErr_Occurred()) SWIG_fail;
 
25971
  }
 
25972
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
25973
  return resultobj;
 
25974
fail:
 
25975
  return NULL;
 
25976
}
 
25977
 
 
25978
 
 
25979
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
25980
  PyObject *resultobj = 0;
 
25981
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
25982
  wxSize result;
 
25983
  void *argp1 = 0 ;
 
25984
  int res1 = 0 ;
 
25985
  PyObject *swig_obj[1] ;
 
25986
  
 
25987
  if (!args) SWIG_fail;
 
25988
  swig_obj[0] = args;
 
25989
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
25990
  if (!SWIG_IsOK(res1)) {
 
25991
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolSize" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
25992
  }
 
25993
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
25994
  {
 
25995
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
25996
    result = (arg1)->GetToolSize();
 
25997
    wxPyEndAllowThreads(__tstate);
 
25998
    if (PyErr_Occurred()) SWIG_fail;
 
25999
  }
 
26000
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
26001
  return resultobj;
 
26002
fail:
 
26003
  return NULL;
 
26004
}
 
26005
 
 
26006
 
 
26007
SWIGINTERN PyObject *_wrap_ToolBarBase_FindToolForPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26008
  PyObject *resultobj = 0;
 
26009
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
26010
  int arg2 ;
 
26011
  int arg3 ;
 
26012
  wxToolBarToolBase *result = 0 ;
 
26013
  void *argp1 = 0 ;
 
26014
  int res1 = 0 ;
 
26015
  int val2 ;
 
26016
  int ecode2 = 0 ;
 
26017
  int val3 ;
 
26018
  int ecode3 = 0 ;
 
26019
  PyObject * obj0 = 0 ;
 
26020
  PyObject * obj1 = 0 ;
 
26021
  PyObject * obj2 = 0 ;
 
26022
  char *  kwnames[] = {
 
26023
    (char *) "self",(char *) "x",(char *) "y", NULL 
 
26024
  };
 
26025
  
 
26026
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_FindToolForPosition",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
26027
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
26028
  if (!SWIG_IsOK(res1)) {
 
26029
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_FindToolForPosition" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
26030
  }
 
26031
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
26032
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
26033
  if (!SWIG_IsOK(ecode2)) {
 
26034
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_FindToolForPosition" "', expected argument " "2"" of type '" "int""'");
 
26035
  } 
 
26036
  arg2 = static_cast< int >(val2);
 
26037
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
26038
  if (!SWIG_IsOK(ecode3)) {
 
26039
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ToolBarBase_FindToolForPosition" "', expected argument " "3"" of type '" "int""'");
 
26040
  } 
 
26041
  arg3 = static_cast< int >(val3);
 
26042
  {
 
26043
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26044
    result = (wxToolBarToolBase *)(arg1)->FindToolForPosition(arg2,arg3);
 
26045
    wxPyEndAllowThreads(__tstate);
 
26046
    if (PyErr_Occurred()) SWIG_fail;
 
26047
  }
 
26048
  {
 
26049
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
26050
  }
 
26051
  return resultobj;
 
26052
fail:
 
26053
  return NULL;
 
26054
}
 
26055
 
 
26056
 
 
26057
SWIGINTERN PyObject *_wrap_ToolBarBase_FindById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26058
  PyObject *resultobj = 0;
 
26059
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
26060
  int arg2 ;
 
26061
  wxToolBarToolBase *result = 0 ;
 
26062
  void *argp1 = 0 ;
 
26063
  int res1 = 0 ;
 
26064
  int val2 ;
 
26065
  int ecode2 = 0 ;
 
26066
  PyObject * obj0 = 0 ;
 
26067
  PyObject * obj1 = 0 ;
 
26068
  char *  kwnames[] = {
 
26069
    (char *) "self",(char *) "toolid", NULL 
 
26070
  };
 
26071
  
 
26072
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_FindById",kwnames,&obj0,&obj1)) SWIG_fail;
 
26073
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
26074
  if (!SWIG_IsOK(res1)) {
 
26075
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_FindById" "', expected argument " "1"" of type '" "wxToolBarBase const *""'"); 
 
26076
  }
 
26077
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
26078
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
26079
  if (!SWIG_IsOK(ecode2)) {
 
26080
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_FindById" "', expected argument " "2"" of type '" "int""'");
 
26081
  } 
 
26082
  arg2 = static_cast< int >(val2);
 
26083
  {
 
26084
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26085
    result = (wxToolBarToolBase *)((wxToolBarBase const *)arg1)->FindById(arg2);
 
26086
    wxPyEndAllowThreads(__tstate);
 
26087
    if (PyErr_Occurred()) SWIG_fail;
 
26088
  }
 
26089
  {
 
26090
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
26091
  }
 
26092
  return resultobj;
 
26093
fail:
 
26094
  return NULL;
 
26095
}
 
26096
 
 
26097
 
 
26098
SWIGINTERN PyObject *_wrap_ToolBarBase_IsVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26099
  PyObject *resultobj = 0;
 
26100
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
26101
  bool result;
 
26102
  void *argp1 = 0 ;
 
26103
  int res1 = 0 ;
 
26104
  PyObject *swig_obj[1] ;
 
26105
  
 
26106
  if (!args) SWIG_fail;
 
26107
  swig_obj[0] = args;
 
26108
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
26109
  if (!SWIG_IsOK(res1)) {
 
26110
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_IsVertical" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
26111
  }
 
26112
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
26113
  {
 
26114
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26115
    result = (bool)(arg1)->IsVertical();
 
26116
    wxPyEndAllowThreads(__tstate);
 
26117
    if (PyErr_Occurred()) SWIG_fail;
 
26118
  }
 
26119
  {
 
26120
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
26121
  }
 
26122
  return resultobj;
 
26123
fail:
 
26124
  return NULL;
 
26125
}
 
26126
 
 
26127
 
 
26128
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26129
  PyObject *resultobj = 0;
 
26130
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
26131
  size_t result;
 
26132
  void *argp1 = 0 ;
 
26133
  int res1 = 0 ;
 
26134
  PyObject *swig_obj[1] ;
 
26135
  
 
26136
  if (!args) SWIG_fail;
 
26137
  swig_obj[0] = args;
 
26138
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
26139
  if (!SWIG_IsOK(res1)) {
 
26140
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolsCount" "', expected argument " "1"" of type '" "wxToolBarBase const *""'"); 
 
26141
  }
 
26142
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
26143
  {
 
26144
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26145
    result = (size_t)((wxToolBarBase const *)arg1)->GetToolsCount();
 
26146
    wxPyEndAllowThreads(__tstate);
 
26147
    if (PyErr_Occurred()) SWIG_fail;
 
26148
  }
 
26149
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
 
26150
  return resultobj;
 
26151
fail:
 
26152
  return NULL;
 
26153
}
 
26154
 
 
26155
 
 
26156
SWIGINTERN PyObject *_wrap_ToolBarBase_GetToolByPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26157
  PyObject *resultobj = 0;
 
26158
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
26159
  int arg2 ;
 
26160
  wxToolBarToolBase *result = 0 ;
 
26161
  void *argp1 = 0 ;
 
26162
  int res1 = 0 ;
 
26163
  int val2 ;
 
26164
  int ecode2 = 0 ;
 
26165
  PyObject * obj0 = 0 ;
 
26166
  PyObject * obj1 = 0 ;
 
26167
  char *  kwnames[] = {
 
26168
    (char *) "self",(char *) "pos", NULL 
 
26169
  };
 
26170
  
 
26171
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_GetToolByPos",kwnames,&obj0,&obj1)) SWIG_fail;
 
26172
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
26173
  if (!SWIG_IsOK(res1)) {
 
26174
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_GetToolByPos" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
26175
  }
 
26176
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
26177
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
26178
  if (!SWIG_IsOK(ecode2)) {
 
26179
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_GetToolByPos" "', expected argument " "2"" of type '" "int""'");
 
26180
  } 
 
26181
  arg2 = static_cast< int >(val2);
 
26182
  {
 
26183
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26184
    result = (wxToolBarToolBase *)(arg1)->GetToolByPos(arg2);
 
26185
    wxPyEndAllowThreads(__tstate);
 
26186
    if (PyErr_Occurred()) SWIG_fail;
 
26187
  }
 
26188
  {
 
26189
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
26190
  }
 
26191
  return resultobj;
 
26192
fail:
 
26193
  return NULL;
 
26194
}
 
26195
 
 
26196
 
 
26197
SWIGINTERN PyObject *_wrap_ToolBarBase_SetDropdownMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26198
  PyObject *resultobj = 0;
 
26199
  wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
 
26200
  int arg2 ;
 
26201
  wxMenu *arg3 = (wxMenu *) 0 ;
 
26202
  bool result;
 
26203
  void *argp1 = 0 ;
 
26204
  int res1 = 0 ;
 
26205
  int val2 ;
 
26206
  int ecode2 = 0 ;
 
26207
  void *argp3 = 0 ;
 
26208
  int res3 = 0 ;
 
26209
  PyObject * obj0 = 0 ;
 
26210
  PyObject * obj1 = 0 ;
 
26211
  PyObject * obj2 = 0 ;
 
26212
  char *  kwnames[] = {
 
26213
    (char *) "self",(char *) "toolid",(char *) "menu", NULL 
 
26214
  };
 
26215
  
 
26216
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_SetDropdownMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
26217
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBarBase, 0 |  0 );
 
26218
  if (!SWIG_IsOK(res1)) {
 
26219
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBarBase_SetDropdownMenu" "', expected argument " "1"" of type '" "wxToolBarBase *""'"); 
 
26220
  }
 
26221
  arg1 = reinterpret_cast< wxToolBarBase * >(argp1);
 
26222
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
26223
  if (!SWIG_IsOK(ecode2)) {
 
26224
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBarBase_SetDropdownMenu" "', expected argument " "2"" of type '" "int""'");
 
26225
  } 
 
26226
  arg2 = static_cast< int >(val2);
 
26227
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 |  0 );
 
26228
  if (!SWIG_IsOK(res3)) {
 
26229
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ToolBarBase_SetDropdownMenu" "', expected argument " "3"" of type '" "wxMenu *""'"); 
 
26230
  }
 
26231
  arg3 = reinterpret_cast< wxMenu * >(argp3);
 
26232
  {
 
26233
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26234
    result = (bool)(arg1)->SetDropdownMenu(arg2,arg3);
 
26235
    wxPyEndAllowThreads(__tstate);
 
26236
    if (PyErr_Occurred()) SWIG_fail;
 
26237
  }
 
26238
  {
 
26239
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
26240
  }
 
26241
  return resultobj;
 
26242
fail:
 
26243
  return NULL;
 
26244
}
 
26245
 
 
26246
 
 
26247
SWIGINTERN PyObject *ToolBarBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26248
  PyObject *obj;
 
26249
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
26250
  SWIG_TypeNewClientData(SWIGTYPE_p_wxToolBarBase, SWIG_NewClientData(obj));
 
26251
  return SWIG_Py_Void();
 
26252
}
 
26253
 
 
26254
SWIGINTERN PyObject *_wrap_new_ToolBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26255
  PyObject *resultobj = 0;
 
26256
  wxWindow *arg1 = (wxWindow *) 0 ;
 
26257
  int arg2 = (int) -1 ;
 
26258
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
26259
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
26260
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
26261
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
26262
  long arg5 = (long) wxNO_BORDER|wxTB_HORIZONTAL ;
 
26263
  wxString const &arg6_defvalue = wxPyToolBarNameStr ;
 
26264
  wxString *arg6 = (wxString *) &arg6_defvalue ;
 
26265
  wxToolBar *result = 0 ;
 
26266
  void *argp1 = 0 ;
 
26267
  int res1 = 0 ;
 
26268
  int val2 ;
 
26269
  int ecode2 = 0 ;
 
26270
  wxPoint temp3 ;
 
26271
  wxSize temp4 ;
 
26272
  long val5 ;
 
26273
  int ecode5 = 0 ;
 
26274
  bool temp6 = false ;
 
26275
  PyObject * obj0 = 0 ;
 
26276
  PyObject * obj1 = 0 ;
 
26277
  PyObject * obj2 = 0 ;
 
26278
  PyObject * obj3 = 0 ;
 
26279
  PyObject * obj4 = 0 ;
 
26280
  PyObject * obj5 = 0 ;
 
26281
  char *  kwnames[] = {
 
26282
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
26283
  };
 
26284
  
 
26285
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_ToolBar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
26286
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
26287
  if (!SWIG_IsOK(res1)) {
 
26288
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ToolBar" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
26289
  }
 
26290
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
26291
  if (obj1) {
 
26292
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
26293
    if (!SWIG_IsOK(ecode2)) {
 
26294
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ToolBar" "', expected argument " "2"" of type '" "int""'");
 
26295
    } 
 
26296
    arg2 = static_cast< int >(val2);
 
26297
  }
 
26298
  if (obj2) {
 
26299
    {
 
26300
      arg3 = &temp3;
 
26301
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
26302
    }
 
26303
  }
 
26304
  if (obj3) {
 
26305
    {
 
26306
      arg4 = &temp4;
 
26307
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
26308
    }
 
26309
  }
 
26310
  if (obj4) {
 
26311
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
26312
    if (!SWIG_IsOK(ecode5)) {
 
26313
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ToolBar" "', expected argument " "5"" of type '" "long""'");
 
26314
    } 
 
26315
    arg5 = static_cast< long >(val5);
 
26316
  }
 
26317
  if (obj5) {
 
26318
    {
 
26319
      arg6 = wxString_in_helper(obj5);
 
26320
      if (arg6 == NULL) SWIG_fail;
 
26321
      temp6 = true;
 
26322
    }
 
26323
  }
 
26324
  {
 
26325
    if (!wxPyCheckForApp()) SWIG_fail;
 
26326
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26327
    result = (wxToolBar *)new wxToolBar(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
 
26328
    wxPyEndAllowThreads(__tstate);
 
26329
    if (PyErr_Occurred()) SWIG_fail;
 
26330
  }
 
26331
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolBar, SWIG_POINTER_NEW |  0 );
 
26332
  {
 
26333
    if (temp6)
 
26334
    delete arg6;
 
26335
  }
 
26336
  return resultobj;
 
26337
fail:
 
26338
  {
 
26339
    if (temp6)
 
26340
    delete arg6;
 
26341
  }
 
26342
  return NULL;
 
26343
}
 
26344
 
 
26345
 
 
26346
SWIGINTERN PyObject *_wrap_new_PreToolBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26347
  PyObject *resultobj = 0;
 
26348
  wxToolBar *result = 0 ;
 
26349
  
 
26350
  if (!SWIG_Python_UnpackTuple(args,"new_PreToolBar",0,0,0)) SWIG_fail;
 
26351
  {
 
26352
    if (!wxPyCheckForApp()) SWIG_fail;
 
26353
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26354
    result = (wxToolBar *)new wxToolBar();
 
26355
    wxPyEndAllowThreads(__tstate);
 
26356
    if (PyErr_Occurred()) SWIG_fail;
 
26357
  }
 
26358
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolBar, SWIG_POINTER_OWN |  0 );
 
26359
  return resultobj;
 
26360
fail:
 
26361
  return NULL;
 
26362
}
 
26363
 
 
26364
 
 
26365
SWIGINTERN PyObject *_wrap_ToolBar_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26366
  PyObject *resultobj = 0;
 
26367
  wxToolBar *arg1 = (wxToolBar *) 0 ;
 
26368
  wxWindow *arg2 = (wxWindow *) 0 ;
 
26369
  int arg3 = (int) -1 ;
 
26370
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
26371
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
26372
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
26373
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
26374
  long arg6 = (long) wxNO_BORDER|wxTB_HORIZONTAL ;
 
26375
  wxString const &arg7_defvalue = wxPyToolBarNameStr ;
 
26376
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
26377
  bool result;
 
26378
  void *argp1 = 0 ;
 
26379
  int res1 = 0 ;
 
26380
  void *argp2 = 0 ;
 
26381
  int res2 = 0 ;
 
26382
  int val3 ;
 
26383
  int ecode3 = 0 ;
 
26384
  wxPoint temp4 ;
 
26385
  wxSize temp5 ;
 
26386
  long val6 ;
 
26387
  int ecode6 = 0 ;
 
26388
  bool temp7 = false ;
 
26389
  PyObject * obj0 = 0 ;
 
26390
  PyObject * obj1 = 0 ;
 
26391
  PyObject * obj2 = 0 ;
 
26392
  PyObject * obj3 = 0 ;
 
26393
  PyObject * obj4 = 0 ;
 
26394
  PyObject * obj5 = 0 ;
 
26395
  PyObject * obj6 = 0 ;
 
26396
  char *  kwnames[] = {
 
26397
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
26398
  };
 
26399
  
 
26400
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:ToolBar_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
26401
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBar, 0 |  0 );
 
26402
  if (!SWIG_IsOK(res1)) {
 
26403
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBar_Create" "', expected argument " "1"" of type '" "wxToolBar *""'"); 
 
26404
  }
 
26405
  arg1 = reinterpret_cast< wxToolBar * >(argp1);
 
26406
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
26407
  if (!SWIG_IsOK(res2)) {
 
26408
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ToolBar_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
26409
  }
 
26410
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
26411
  if (obj2) {
 
26412
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
26413
    if (!SWIG_IsOK(ecode3)) {
 
26414
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ToolBar_Create" "', expected argument " "3"" of type '" "int""'");
 
26415
    } 
 
26416
    arg3 = static_cast< int >(val3);
 
26417
  }
 
26418
  if (obj3) {
 
26419
    {
 
26420
      arg4 = &temp4;
 
26421
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
26422
    }
 
26423
  }
 
26424
  if (obj4) {
 
26425
    {
 
26426
      arg5 = &temp5;
 
26427
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
26428
    }
 
26429
  }
 
26430
  if (obj5) {
 
26431
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
26432
    if (!SWIG_IsOK(ecode6)) {
 
26433
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ToolBar_Create" "', expected argument " "6"" of type '" "long""'");
 
26434
    } 
 
26435
    arg6 = static_cast< long >(val6);
 
26436
  }
 
26437
  if (obj6) {
 
26438
    {
 
26439
      arg7 = wxString_in_helper(obj6);
 
26440
      if (arg7 == NULL) SWIG_fail;
 
26441
      temp7 = true;
 
26442
    }
 
26443
  }
 
26444
  {
 
26445
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26446
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
 
26447
    wxPyEndAllowThreads(__tstate);
 
26448
    if (PyErr_Occurred()) SWIG_fail;
 
26449
  }
 
26450
  {
 
26451
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
26452
  }
 
26453
  {
 
26454
    if (temp7)
 
26455
    delete arg7;
 
26456
  }
 
26457
  return resultobj;
 
26458
fail:
 
26459
  {
 
26460
    if (temp7)
 
26461
    delete arg7;
 
26462
  }
 
26463
  return NULL;
 
26464
}
 
26465
 
 
26466
 
 
26467
SWIGINTERN PyObject *_wrap_ToolBar_SetToolNormalBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26468
  PyObject *resultobj = 0;
 
26469
  wxToolBar *arg1 = (wxToolBar *) 0 ;
 
26470
  int arg2 ;
 
26471
  wxBitmap *arg3 = 0 ;
 
26472
  void *argp1 = 0 ;
 
26473
  int res1 = 0 ;
 
26474
  int val2 ;
 
26475
  int ecode2 = 0 ;
 
26476
  void *argp3 = 0 ;
 
26477
  int res3 = 0 ;
 
26478
  PyObject * obj0 = 0 ;
 
26479
  PyObject * obj1 = 0 ;
 
26480
  PyObject * obj2 = 0 ;
 
26481
  char *  kwnames[] = {
 
26482
    (char *) "self",(char *) "id",(char *) "bitmap", NULL 
 
26483
  };
 
26484
  
 
26485
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBar_SetToolNormalBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
26486
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBar, 0 |  0 );
 
26487
  if (!SWIG_IsOK(res1)) {
 
26488
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBar_SetToolNormalBitmap" "', expected argument " "1"" of type '" "wxToolBar *""'"); 
 
26489
  }
 
26490
  arg1 = reinterpret_cast< wxToolBar * >(argp1);
 
26491
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
26492
  if (!SWIG_IsOK(ecode2)) {
 
26493
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBar_SetToolNormalBitmap" "', expected argument " "2"" of type '" "int""'");
 
26494
  } 
 
26495
  arg2 = static_cast< int >(val2);
 
26496
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap,  0  | 0);
 
26497
  if (!SWIG_IsOK(res3)) {
 
26498
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ToolBar_SetToolNormalBitmap" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
26499
  }
 
26500
  if (!argp3) {
 
26501
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ToolBar_SetToolNormalBitmap" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
26502
  }
 
26503
  arg3 = reinterpret_cast< wxBitmap * >(argp3);
 
26504
  {
 
26505
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26506
    (arg1)->SetToolNormalBitmap(arg2,(wxBitmap const &)*arg3);
 
26507
    wxPyEndAllowThreads(__tstate);
 
26508
    if (PyErr_Occurred()) SWIG_fail;
 
26509
  }
 
26510
  resultobj = SWIG_Py_Void();
 
26511
  return resultobj;
 
26512
fail:
 
26513
  return NULL;
 
26514
}
 
26515
 
 
26516
 
 
26517
SWIGINTERN PyObject *_wrap_ToolBar_SetToolDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26518
  PyObject *resultobj = 0;
 
26519
  wxToolBar *arg1 = (wxToolBar *) 0 ;
 
26520
  int arg2 ;
 
26521
  wxBitmap *arg3 = 0 ;
 
26522
  void *argp1 = 0 ;
 
26523
  int res1 = 0 ;
 
26524
  int val2 ;
 
26525
  int ecode2 = 0 ;
 
26526
  void *argp3 = 0 ;
 
26527
  int res3 = 0 ;
 
26528
  PyObject * obj0 = 0 ;
 
26529
  PyObject * obj1 = 0 ;
 
26530
  PyObject * obj2 = 0 ;
 
26531
  char *  kwnames[] = {
 
26532
    (char *) "self",(char *) "id",(char *) "bitmap", NULL 
 
26533
  };
 
26534
  
 
26535
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBar_SetToolDisabledBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
26536
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolBar, 0 |  0 );
 
26537
  if (!SWIG_IsOK(res1)) {
 
26538
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolBar_SetToolDisabledBitmap" "', expected argument " "1"" of type '" "wxToolBar *""'"); 
 
26539
  }
 
26540
  arg1 = reinterpret_cast< wxToolBar * >(argp1);
 
26541
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
26542
  if (!SWIG_IsOK(ecode2)) {
 
26543
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ToolBar_SetToolDisabledBitmap" "', expected argument " "2"" of type '" "int""'");
 
26544
  } 
 
26545
  arg2 = static_cast< int >(val2);
 
26546
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap,  0  | 0);
 
26547
  if (!SWIG_IsOK(res3)) {
 
26548
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ToolBar_SetToolDisabledBitmap" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
26549
  }
 
26550
  if (!argp3) {
 
26551
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ToolBar_SetToolDisabledBitmap" "', expected argument " "3"" of type '" "wxBitmap const &""'"); 
 
26552
  }
 
26553
  arg3 = reinterpret_cast< wxBitmap * >(argp3);
 
26554
  {
 
26555
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26556
    (arg1)->SetToolDisabledBitmap(arg2,(wxBitmap const &)*arg3);
 
26557
    wxPyEndAllowThreads(__tstate);
 
26558
    if (PyErr_Occurred()) SWIG_fail;
 
26559
  }
 
26560
  resultobj = SWIG_Py_Void();
 
26561
  return resultobj;
 
26562
fail:
 
26563
  return NULL;
 
26564
}
 
26565
 
 
26566
 
 
26567
SWIGINTERN PyObject *_wrap_ToolBar_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26568
  PyObject *resultobj = 0;
 
26569
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
26570
  SwigValueWrapper<wxVisualAttributes > result;
 
26571
  int val1 ;
 
26572
  int ecode1 = 0 ;
 
26573
  PyObject * obj0 = 0 ;
 
26574
  char *  kwnames[] = {
 
26575
    (char *) "variant", NULL 
 
26576
  };
 
26577
  
 
26578
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ToolBar_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
26579
  if (obj0) {
 
26580
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
26581
    if (!SWIG_IsOK(ecode1)) {
 
26582
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolBar_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
26583
    } 
 
26584
    arg1 = static_cast< wxWindowVariant >(val1);
 
26585
  }
 
26586
  {
 
26587
    if (!wxPyCheckForApp()) SWIG_fail;
 
26588
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26589
    result = wxToolBar::GetClassDefaultAttributes(arg1);
 
26590
    wxPyEndAllowThreads(__tstate);
 
26591
    if (PyErr_Occurred()) SWIG_fail;
 
26592
  }
 
26593
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
26594
  return resultobj;
 
26595
fail:
 
26596
  return NULL;
 
26597
}
 
26598
 
 
26599
 
 
26600
SWIGINTERN PyObject *ToolBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26601
  PyObject *obj;
 
26602
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
26603
  SWIG_TypeNewClientData(SWIGTYPE_p_wxToolBar, SWIG_NewClientData(obj));
 
26604
  return SWIG_Py_Void();
 
26605
}
 
26606
 
 
26607
SWIGINTERN PyObject *ToolBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26608
  return SWIG_Python_InitShadowInstance(args);
 
26609
}
 
26610
 
 
26611
SWIGINTERN int ListCtrlNameStr_set(PyObject *) {
 
26612
  SWIG_Error(SWIG_AttributeError,"Variable ListCtrlNameStr is read-only.");
 
26613
  return 1;
 
26614
}
 
26615
 
 
26616
 
 
26617
SWIGINTERN PyObject *ListCtrlNameStr_get(void) {
 
26618
  PyObject *pyobj = 0;
 
26619
  
 
26620
  {
 
26621
#if wxUSE_UNICODE
 
26622
    pyobj = PyUnicode_FromWideChar((&wxPyListCtrlNameStr)->c_str(), (&wxPyListCtrlNameStr)->Len());
 
26623
#else
 
26624
    pyobj = PyString_FromStringAndSize((&wxPyListCtrlNameStr)->c_str(), (&wxPyListCtrlNameStr)->Len());
 
26625
#endif
 
26626
  }
 
26627
  return pyobj;
 
26628
}
 
26629
 
 
26630
 
 
26631
SWIGINTERN PyObject *_wrap_new_ListItemAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26632
  PyObject *resultobj = 0;
 
26633
  wxColour const &arg1_defvalue = wxNullColour ;
 
26634
  wxColour *arg1 = (wxColour *) &arg1_defvalue ;
 
26635
  wxColour const &arg2_defvalue = wxNullColour ;
 
26636
  wxColour *arg2 = (wxColour *) &arg2_defvalue ;
 
26637
  wxFont const &arg3_defvalue = wxNullFont ;
 
26638
  wxFont *arg3 = (wxFont *) &arg3_defvalue ;
 
26639
  wxListItemAttr *result = 0 ;
 
26640
  wxColour temp1 ;
 
26641
  wxColour temp2 ;
 
26642
  void *argp3 = 0 ;
 
26643
  int res3 = 0 ;
 
26644
  PyObject * obj0 = 0 ;
 
26645
  PyObject * obj1 = 0 ;
 
26646
  PyObject * obj2 = 0 ;
 
26647
  char *  kwnames[] = {
 
26648
    (char *) "colText",(char *) "colBack",(char *) "font", NULL 
 
26649
  };
 
26650
  
 
26651
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ListItemAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
26652
  if (obj0) {
 
26653
    {
 
26654
      arg1 = &temp1;
 
26655
      if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
 
26656
    }
 
26657
  }
 
26658
  if (obj1) {
 
26659
    {
 
26660
      arg2 = &temp2;
 
26661
      if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
26662
    }
 
26663
  }
 
26664
  if (obj2) {
 
26665
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxFont,  0  | 0);
 
26666
    if (!SWIG_IsOK(res3)) {
 
26667
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ListItemAttr" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
26668
    }
 
26669
    if (!argp3) {
 
26670
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListItemAttr" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
26671
    }
 
26672
    arg3 = reinterpret_cast< wxFont * >(argp3);
 
26673
  }
 
26674
  {
 
26675
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26676
    result = (wxListItemAttr *)new wxListItemAttr((wxColour const &)*arg1,(wxColour const &)*arg2,(wxFont const &)*arg3);
 
26677
    wxPyEndAllowThreads(__tstate);
 
26678
    if (PyErr_Occurred()) SWIG_fail;
 
26679
  }
 
26680
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_NEW |  0 );
 
26681
  return resultobj;
 
26682
fail:
 
26683
  return NULL;
 
26684
}
 
26685
 
 
26686
 
 
26687
SWIGINTERN PyObject *_wrap_delete_ListItemAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26688
  PyObject *resultobj = 0;
 
26689
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
26690
  void *argp1 = 0 ;
 
26691
  int res1 = 0 ;
 
26692
  PyObject *swig_obj[1] ;
 
26693
  
 
26694
  if (!args) SWIG_fail;
 
26695
  swig_obj[0] = args;
 
26696
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItemAttr, SWIG_POINTER_DISOWN |  0 );
 
26697
  if (!SWIG_IsOK(res1)) {
 
26698
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListItemAttr" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
26699
  }
 
26700
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
26701
  {
 
26702
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26703
    delete arg1;
 
26704
    
 
26705
    wxPyEndAllowThreads(__tstate);
 
26706
    if (PyErr_Occurred()) SWIG_fail;
 
26707
  }
 
26708
  resultobj = SWIG_Py_Void();
 
26709
  return resultobj;
 
26710
fail:
 
26711
  return NULL;
 
26712
}
 
26713
 
 
26714
 
 
26715
SWIGINTERN PyObject *_wrap_ListItemAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26716
  PyObject *resultobj = 0;
 
26717
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
26718
  wxColour *arg2 = 0 ;
 
26719
  void *argp1 = 0 ;
 
26720
  int res1 = 0 ;
 
26721
  wxColour temp2 ;
 
26722
  PyObject * obj0 = 0 ;
 
26723
  PyObject * obj1 = 0 ;
 
26724
  char *  kwnames[] = {
 
26725
    (char *) "self",(char *) "colText", NULL 
 
26726
  };
 
26727
  
 
26728
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItemAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
26729
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
26730
  if (!SWIG_IsOK(res1)) {
 
26731
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_SetTextColour" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
26732
  }
 
26733
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
26734
  {
 
26735
    arg2 = &temp2;
 
26736
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
26737
  }
 
26738
  {
 
26739
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26740
    (arg1)->SetTextColour((wxColour const &)*arg2);
 
26741
    wxPyEndAllowThreads(__tstate);
 
26742
    if (PyErr_Occurred()) SWIG_fail;
 
26743
  }
 
26744
  resultobj = SWIG_Py_Void();
 
26745
  return resultobj;
 
26746
fail:
 
26747
  return NULL;
 
26748
}
 
26749
 
 
26750
 
 
26751
SWIGINTERN PyObject *_wrap_ListItemAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26752
  PyObject *resultobj = 0;
 
26753
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
26754
  wxColour *arg2 = 0 ;
 
26755
  void *argp1 = 0 ;
 
26756
  int res1 = 0 ;
 
26757
  wxColour temp2 ;
 
26758
  PyObject * obj0 = 0 ;
 
26759
  PyObject * obj1 = 0 ;
 
26760
  char *  kwnames[] = {
 
26761
    (char *) "self",(char *) "colBack", NULL 
 
26762
  };
 
26763
  
 
26764
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItemAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
26765
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
26766
  if (!SWIG_IsOK(res1)) {
 
26767
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
26768
  }
 
26769
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
26770
  {
 
26771
    arg2 = &temp2;
 
26772
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
26773
  }
 
26774
  {
 
26775
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26776
    (arg1)->SetBackgroundColour((wxColour const &)*arg2);
 
26777
    wxPyEndAllowThreads(__tstate);
 
26778
    if (PyErr_Occurred()) SWIG_fail;
 
26779
  }
 
26780
  resultobj = SWIG_Py_Void();
 
26781
  return resultobj;
 
26782
fail:
 
26783
  return NULL;
 
26784
}
 
26785
 
 
26786
 
 
26787
SWIGINTERN PyObject *_wrap_ListItemAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
26788
  PyObject *resultobj = 0;
 
26789
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
26790
  wxFont *arg2 = 0 ;
 
26791
  void *argp1 = 0 ;
 
26792
  int res1 = 0 ;
 
26793
  void *argp2 = 0 ;
 
26794
  int res2 = 0 ;
 
26795
  PyObject * obj0 = 0 ;
 
26796
  PyObject * obj1 = 0 ;
 
26797
  char *  kwnames[] = {
 
26798
    (char *) "self",(char *) "font", NULL 
 
26799
  };
 
26800
  
 
26801
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItemAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
 
26802
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
26803
  if (!SWIG_IsOK(res1)) {
 
26804
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_SetFont" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
26805
  }
 
26806
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
26807
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont,  0  | 0);
 
26808
  if (!SWIG_IsOK(res2)) {
 
26809
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListItemAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
26810
  }
 
26811
  if (!argp2) {
 
26812
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListItemAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
26813
  }
 
26814
  arg2 = reinterpret_cast< wxFont * >(argp2);
 
26815
  {
 
26816
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26817
    (arg1)->SetFont((wxFont const &)*arg2);
 
26818
    wxPyEndAllowThreads(__tstate);
 
26819
    if (PyErr_Occurred()) SWIG_fail;
 
26820
  }
 
26821
  resultobj = SWIG_Py_Void();
 
26822
  return resultobj;
 
26823
fail:
 
26824
  return NULL;
 
26825
}
 
26826
 
 
26827
 
 
26828
SWIGINTERN PyObject *_wrap_ListItemAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26829
  PyObject *resultobj = 0;
 
26830
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
26831
  bool result;
 
26832
  void *argp1 = 0 ;
 
26833
  int res1 = 0 ;
 
26834
  PyObject *swig_obj[1] ;
 
26835
  
 
26836
  if (!args) SWIG_fail;
 
26837
  swig_obj[0] = args;
 
26838
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
26839
  if (!SWIG_IsOK(res1)) {
 
26840
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_HasTextColour" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
26841
  }
 
26842
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
26843
  {
 
26844
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26845
    result = (bool)(arg1)->HasTextColour();
 
26846
    wxPyEndAllowThreads(__tstate);
 
26847
    if (PyErr_Occurred()) SWIG_fail;
 
26848
  }
 
26849
  {
 
26850
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
26851
  }
 
26852
  return resultobj;
 
26853
fail:
 
26854
  return NULL;
 
26855
}
 
26856
 
 
26857
 
 
26858
SWIGINTERN PyObject *_wrap_ListItemAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26859
  PyObject *resultobj = 0;
 
26860
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
26861
  bool result;
 
26862
  void *argp1 = 0 ;
 
26863
  int res1 = 0 ;
 
26864
  PyObject *swig_obj[1] ;
 
26865
  
 
26866
  if (!args) SWIG_fail;
 
26867
  swig_obj[0] = args;
 
26868
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
26869
  if (!SWIG_IsOK(res1)) {
 
26870
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
26871
  }
 
26872
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
26873
  {
 
26874
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26875
    result = (bool)(arg1)->HasBackgroundColour();
 
26876
    wxPyEndAllowThreads(__tstate);
 
26877
    if (PyErr_Occurred()) SWIG_fail;
 
26878
  }
 
26879
  {
 
26880
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
26881
  }
 
26882
  return resultobj;
 
26883
fail:
 
26884
  return NULL;
 
26885
}
 
26886
 
 
26887
 
 
26888
SWIGINTERN PyObject *_wrap_ListItemAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26889
  PyObject *resultobj = 0;
 
26890
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
26891
  bool result;
 
26892
  void *argp1 = 0 ;
 
26893
  int res1 = 0 ;
 
26894
  PyObject *swig_obj[1] ;
 
26895
  
 
26896
  if (!args) SWIG_fail;
 
26897
  swig_obj[0] = args;
 
26898
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
26899
  if (!SWIG_IsOK(res1)) {
 
26900
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_HasFont" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
26901
  }
 
26902
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
26903
  {
 
26904
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26905
    result = (bool)(arg1)->HasFont();
 
26906
    wxPyEndAllowThreads(__tstate);
 
26907
    if (PyErr_Occurred()) SWIG_fail;
 
26908
  }
 
26909
  {
 
26910
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
26911
  }
 
26912
  return resultobj;
 
26913
fail:
 
26914
  return NULL;
 
26915
}
 
26916
 
 
26917
 
 
26918
SWIGINTERN PyObject *_wrap_ListItemAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26919
  PyObject *resultobj = 0;
 
26920
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
26921
  wxColour result;
 
26922
  void *argp1 = 0 ;
 
26923
  int res1 = 0 ;
 
26924
  PyObject *swig_obj[1] ;
 
26925
  
 
26926
  if (!args) SWIG_fail;
 
26927
  swig_obj[0] = args;
 
26928
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
26929
  if (!SWIG_IsOK(res1)) {
 
26930
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_GetTextColour" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
26931
  }
 
26932
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
26933
  {
 
26934
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26935
    result = (arg1)->GetTextColour();
 
26936
    wxPyEndAllowThreads(__tstate);
 
26937
    if (PyErr_Occurred()) SWIG_fail;
 
26938
  }
 
26939
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
26940
  return resultobj;
 
26941
fail:
 
26942
  return NULL;
 
26943
}
 
26944
 
 
26945
 
 
26946
SWIGINTERN PyObject *_wrap_ListItemAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26947
  PyObject *resultobj = 0;
 
26948
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
26949
  wxColour result;
 
26950
  void *argp1 = 0 ;
 
26951
  int res1 = 0 ;
 
26952
  PyObject *swig_obj[1] ;
 
26953
  
 
26954
  if (!args) SWIG_fail;
 
26955
  swig_obj[0] = args;
 
26956
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
26957
  if (!SWIG_IsOK(res1)) {
 
26958
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
26959
  }
 
26960
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
26961
  {
 
26962
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26963
    result = (arg1)->GetBackgroundColour();
 
26964
    wxPyEndAllowThreads(__tstate);
 
26965
    if (PyErr_Occurred()) SWIG_fail;
 
26966
  }
 
26967
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
26968
  return resultobj;
 
26969
fail:
 
26970
  return NULL;
 
26971
}
 
26972
 
 
26973
 
 
26974
SWIGINTERN PyObject *_wrap_ListItemAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
26975
  PyObject *resultobj = 0;
 
26976
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
26977
  wxFont result;
 
26978
  void *argp1 = 0 ;
 
26979
  int res1 = 0 ;
 
26980
  PyObject *swig_obj[1] ;
 
26981
  
 
26982
  if (!args) SWIG_fail;
 
26983
  swig_obj[0] = args;
 
26984
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
26985
  if (!SWIG_IsOK(res1)) {
 
26986
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_GetFont" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
26987
  }
 
26988
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
26989
  {
 
26990
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
26991
    result = (arg1)->GetFont();
 
26992
    wxPyEndAllowThreads(__tstate);
 
26993
    if (PyErr_Occurred()) SWIG_fail;
 
26994
  }
 
26995
  resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN |  0 );
 
26996
  return resultobj;
 
26997
fail:
 
26998
  return NULL;
 
26999
}
 
27000
 
 
27001
 
 
27002
SWIGINTERN PyObject *_wrap_ListItemAttr_AssignFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27003
  PyObject *resultobj = 0;
 
27004
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
27005
  wxListItemAttr *arg2 = 0 ;
 
27006
  void *argp1 = 0 ;
 
27007
  int res1 = 0 ;
 
27008
  void *argp2 = 0 ;
 
27009
  int res2 = 0 ;
 
27010
  PyObject * obj0 = 0 ;
 
27011
  PyObject * obj1 = 0 ;
 
27012
  char *  kwnames[] = {
 
27013
    (char *) "self",(char *) "source", NULL 
 
27014
  };
 
27015
  
 
27016
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItemAttr_AssignFrom",kwnames,&obj0,&obj1)) SWIG_fail;
 
27017
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
27018
  if (!SWIG_IsOK(res1)) {
 
27019
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_AssignFrom" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
27020
  }
 
27021
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
27022
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxListItemAttr,  0  | 0);
 
27023
  if (!SWIG_IsOK(res2)) {
 
27024
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListItemAttr_AssignFrom" "', expected argument " "2"" of type '" "wxListItemAttr const &""'"); 
 
27025
  }
 
27026
  if (!argp2) {
 
27027
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListItemAttr_AssignFrom" "', expected argument " "2"" of type '" "wxListItemAttr const &""'"); 
 
27028
  }
 
27029
  arg2 = reinterpret_cast< wxListItemAttr * >(argp2);
 
27030
  {
 
27031
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27032
    (arg1)->AssignFrom((wxListItemAttr const &)*arg2);
 
27033
    wxPyEndAllowThreads(__tstate);
 
27034
    if (PyErr_Occurred()) SWIG_fail;
 
27035
  }
 
27036
  resultobj = SWIG_Py_Void();
 
27037
  return resultobj;
 
27038
fail:
 
27039
  return NULL;
 
27040
}
 
27041
 
 
27042
 
 
27043
SWIGINTERN PyObject *_wrap_ListItemAttr_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27044
  PyObject *resultobj = 0;
 
27045
  wxListItemAttr *arg1 = (wxListItemAttr *) 0 ;
 
27046
  void *argp1 = 0 ;
 
27047
  int res1 = 0 ;
 
27048
  PyObject *swig_obj[1] ;
 
27049
  
 
27050
  if (!args) SWIG_fail;
 
27051
  swig_obj[0] = args;
 
27052
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
27053
  if (!SWIG_IsOK(res1)) {
 
27054
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItemAttr_Destroy" "', expected argument " "1"" of type '" "wxListItemAttr *""'"); 
 
27055
  }
 
27056
  arg1 = reinterpret_cast< wxListItemAttr * >(argp1);
 
27057
  {
 
27058
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27059
    wxListItemAttr_Destroy(arg1);
 
27060
    wxPyEndAllowThreads(__tstate);
 
27061
    if (PyErr_Occurred()) SWIG_fail;
 
27062
  }
 
27063
  resultobj = SWIG_Py_Void();
 
27064
  return resultobj;
 
27065
fail:
 
27066
  return NULL;
 
27067
}
 
27068
 
 
27069
 
 
27070
SWIGINTERN PyObject *ListItemAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27071
  PyObject *obj;
 
27072
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
27073
  SWIG_TypeNewClientData(SWIGTYPE_p_wxListItemAttr, SWIG_NewClientData(obj));
 
27074
  return SWIG_Py_Void();
 
27075
}
 
27076
 
 
27077
SWIGINTERN PyObject *ListItemAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27078
  return SWIG_Python_InitShadowInstance(args);
 
27079
}
 
27080
 
 
27081
SWIGINTERN PyObject *_wrap_new_ListItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27082
  PyObject *resultobj = 0;
 
27083
  wxListItem *result = 0 ;
 
27084
  
 
27085
  if (!SWIG_Python_UnpackTuple(args,"new_ListItem",0,0,0)) SWIG_fail;
 
27086
  {
 
27087
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27088
    result = (wxListItem *)new wxListItem();
 
27089
    wxPyEndAllowThreads(__tstate);
 
27090
    if (PyErr_Occurred()) SWIG_fail;
 
27091
  }
 
27092
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListItem, SWIG_POINTER_NEW |  0 );
 
27093
  return resultobj;
 
27094
fail:
 
27095
  return NULL;
 
27096
}
 
27097
 
 
27098
 
 
27099
SWIGINTERN PyObject *_wrap_delete_ListItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27100
  PyObject *resultobj = 0;
 
27101
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27102
  void *argp1 = 0 ;
 
27103
  int res1 = 0 ;
 
27104
  PyObject *swig_obj[1] ;
 
27105
  
 
27106
  if (!args) SWIG_fail;
 
27107
  swig_obj[0] = args;
 
27108
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, SWIG_POINTER_DISOWN |  0 );
 
27109
  if (!SWIG_IsOK(res1)) {
 
27110
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListItem" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27111
  }
 
27112
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27113
  {
 
27114
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27115
    delete arg1;
 
27116
    
 
27117
    wxPyEndAllowThreads(__tstate);
 
27118
    if (PyErr_Occurred()) SWIG_fail;
 
27119
  }
 
27120
  resultobj = SWIG_Py_Void();
 
27121
  return resultobj;
 
27122
fail:
 
27123
  return NULL;
 
27124
}
 
27125
 
 
27126
 
 
27127
SWIGINTERN PyObject *_wrap_ListItem_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27128
  PyObject *resultobj = 0;
 
27129
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27130
  void *argp1 = 0 ;
 
27131
  int res1 = 0 ;
 
27132
  PyObject *swig_obj[1] ;
 
27133
  
 
27134
  if (!args) SWIG_fail;
 
27135
  swig_obj[0] = args;
 
27136
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27137
  if (!SWIG_IsOK(res1)) {
 
27138
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_Clear" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27139
  }
 
27140
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27141
  {
 
27142
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27143
    (arg1)->Clear();
 
27144
    wxPyEndAllowThreads(__tstate);
 
27145
    if (PyErr_Occurred()) SWIG_fail;
 
27146
  }
 
27147
  resultobj = SWIG_Py_Void();
 
27148
  return resultobj;
 
27149
fail:
 
27150
  return NULL;
 
27151
}
 
27152
 
 
27153
 
 
27154
SWIGINTERN PyObject *_wrap_ListItem_ClearAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27155
  PyObject *resultobj = 0;
 
27156
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27157
  void *argp1 = 0 ;
 
27158
  int res1 = 0 ;
 
27159
  PyObject *swig_obj[1] ;
 
27160
  
 
27161
  if (!args) SWIG_fail;
 
27162
  swig_obj[0] = args;
 
27163
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27164
  if (!SWIG_IsOK(res1)) {
 
27165
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_ClearAttributes" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27166
  }
 
27167
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27168
  {
 
27169
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27170
    (arg1)->ClearAttributes();
 
27171
    wxPyEndAllowThreads(__tstate);
 
27172
    if (PyErr_Occurred()) SWIG_fail;
 
27173
  }
 
27174
  resultobj = SWIG_Py_Void();
 
27175
  return resultobj;
 
27176
fail:
 
27177
  return NULL;
 
27178
}
 
27179
 
 
27180
 
 
27181
SWIGINTERN PyObject *_wrap_ListItem_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27182
  PyObject *resultobj = 0;
 
27183
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27184
  long arg2 ;
 
27185
  void *argp1 = 0 ;
 
27186
  int res1 = 0 ;
 
27187
  long val2 ;
 
27188
  int ecode2 = 0 ;
 
27189
  PyObject * obj0 = 0 ;
 
27190
  PyObject * obj1 = 0 ;
 
27191
  char *  kwnames[] = {
 
27192
    (char *) "self",(char *) "mask", NULL 
 
27193
  };
 
27194
  
 
27195
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
 
27196
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27197
  if (!SWIG_IsOK(res1)) {
 
27198
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetMask" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27199
  }
 
27200
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27201
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
27202
  if (!SWIG_IsOK(ecode2)) {
 
27203
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_SetMask" "', expected argument " "2"" of type '" "long""'");
 
27204
  } 
 
27205
  arg2 = static_cast< long >(val2);
 
27206
  {
 
27207
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27208
    (arg1)->SetMask(arg2);
 
27209
    wxPyEndAllowThreads(__tstate);
 
27210
    if (PyErr_Occurred()) SWIG_fail;
 
27211
  }
 
27212
  resultobj = SWIG_Py_Void();
 
27213
  return resultobj;
 
27214
fail:
 
27215
  return NULL;
 
27216
}
 
27217
 
 
27218
 
 
27219
SWIGINTERN PyObject *_wrap_ListItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27220
  PyObject *resultobj = 0;
 
27221
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27222
  long arg2 ;
 
27223
  void *argp1 = 0 ;
 
27224
  int res1 = 0 ;
 
27225
  long val2 ;
 
27226
  int ecode2 = 0 ;
 
27227
  PyObject * obj0 = 0 ;
 
27228
  PyObject * obj1 = 0 ;
 
27229
  char *  kwnames[] = {
 
27230
    (char *) "self",(char *) "id", NULL 
 
27231
  };
 
27232
  
 
27233
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
 
27234
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27235
  if (!SWIG_IsOK(res1)) {
 
27236
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetId" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27237
  }
 
27238
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27239
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
27240
  if (!SWIG_IsOK(ecode2)) {
 
27241
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_SetId" "', expected argument " "2"" of type '" "long""'");
 
27242
  } 
 
27243
  arg2 = static_cast< long >(val2);
 
27244
  {
 
27245
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27246
    (arg1)->SetId(arg2);
 
27247
    wxPyEndAllowThreads(__tstate);
 
27248
    if (PyErr_Occurred()) SWIG_fail;
 
27249
  }
 
27250
  resultobj = SWIG_Py_Void();
 
27251
  return resultobj;
 
27252
fail:
 
27253
  return NULL;
 
27254
}
 
27255
 
 
27256
 
 
27257
SWIGINTERN PyObject *_wrap_ListItem_SetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27258
  PyObject *resultobj = 0;
 
27259
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27260
  int arg2 ;
 
27261
  void *argp1 = 0 ;
 
27262
  int res1 = 0 ;
 
27263
  int val2 ;
 
27264
  int ecode2 = 0 ;
 
27265
  PyObject * obj0 = 0 ;
 
27266
  PyObject * obj1 = 0 ;
 
27267
  char *  kwnames[] = {
 
27268
    (char *) "self",(char *) "col", NULL 
 
27269
  };
 
27270
  
 
27271
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetColumn",kwnames,&obj0,&obj1)) SWIG_fail;
 
27272
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27273
  if (!SWIG_IsOK(res1)) {
 
27274
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetColumn" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27275
  }
 
27276
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27277
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
27278
  if (!SWIG_IsOK(ecode2)) {
 
27279
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_SetColumn" "', expected argument " "2"" of type '" "int""'");
 
27280
  } 
 
27281
  arg2 = static_cast< int >(val2);
 
27282
  {
 
27283
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27284
    (arg1)->SetColumn(arg2);
 
27285
    wxPyEndAllowThreads(__tstate);
 
27286
    if (PyErr_Occurred()) SWIG_fail;
 
27287
  }
 
27288
  resultobj = SWIG_Py_Void();
 
27289
  return resultobj;
 
27290
fail:
 
27291
  return NULL;
 
27292
}
 
27293
 
 
27294
 
 
27295
SWIGINTERN PyObject *_wrap_ListItem_SetState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27296
  PyObject *resultobj = 0;
 
27297
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27298
  long arg2 ;
 
27299
  void *argp1 = 0 ;
 
27300
  int res1 = 0 ;
 
27301
  long val2 ;
 
27302
  int ecode2 = 0 ;
 
27303
  PyObject * obj0 = 0 ;
 
27304
  PyObject * obj1 = 0 ;
 
27305
  char *  kwnames[] = {
 
27306
    (char *) "self",(char *) "state", NULL 
 
27307
  };
 
27308
  
 
27309
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetState",kwnames,&obj0,&obj1)) SWIG_fail;
 
27310
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27311
  if (!SWIG_IsOK(res1)) {
 
27312
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetState" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27313
  }
 
27314
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27315
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
27316
  if (!SWIG_IsOK(ecode2)) {
 
27317
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_SetState" "', expected argument " "2"" of type '" "long""'");
 
27318
  } 
 
27319
  arg2 = static_cast< long >(val2);
 
27320
  {
 
27321
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27322
    (arg1)->SetState(arg2);
 
27323
    wxPyEndAllowThreads(__tstate);
 
27324
    if (PyErr_Occurred()) SWIG_fail;
 
27325
  }
 
27326
  resultobj = SWIG_Py_Void();
 
27327
  return resultobj;
 
27328
fail:
 
27329
  return NULL;
 
27330
}
 
27331
 
 
27332
 
 
27333
SWIGINTERN PyObject *_wrap_ListItem_SetStateMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27334
  PyObject *resultobj = 0;
 
27335
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27336
  long arg2 ;
 
27337
  void *argp1 = 0 ;
 
27338
  int res1 = 0 ;
 
27339
  long val2 ;
 
27340
  int ecode2 = 0 ;
 
27341
  PyObject * obj0 = 0 ;
 
27342
  PyObject * obj1 = 0 ;
 
27343
  char *  kwnames[] = {
 
27344
    (char *) "self",(char *) "stateMask", NULL 
 
27345
  };
 
27346
  
 
27347
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetStateMask",kwnames,&obj0,&obj1)) SWIG_fail;
 
27348
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27349
  if (!SWIG_IsOK(res1)) {
 
27350
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetStateMask" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27351
  }
 
27352
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27353
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
27354
  if (!SWIG_IsOK(ecode2)) {
 
27355
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_SetStateMask" "', expected argument " "2"" of type '" "long""'");
 
27356
  } 
 
27357
  arg2 = static_cast< long >(val2);
 
27358
  {
 
27359
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27360
    (arg1)->SetStateMask(arg2);
 
27361
    wxPyEndAllowThreads(__tstate);
 
27362
    if (PyErr_Occurred()) SWIG_fail;
 
27363
  }
 
27364
  resultobj = SWIG_Py_Void();
 
27365
  return resultobj;
 
27366
fail:
 
27367
  return NULL;
 
27368
}
 
27369
 
 
27370
 
 
27371
SWIGINTERN PyObject *_wrap_ListItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27372
  PyObject *resultobj = 0;
 
27373
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27374
  wxString *arg2 = 0 ;
 
27375
  void *argp1 = 0 ;
 
27376
  int res1 = 0 ;
 
27377
  bool temp2 = false ;
 
27378
  PyObject * obj0 = 0 ;
 
27379
  PyObject * obj1 = 0 ;
 
27380
  char *  kwnames[] = {
 
27381
    (char *) "self",(char *) "text", NULL 
 
27382
  };
 
27383
  
 
27384
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
 
27385
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27386
  if (!SWIG_IsOK(res1)) {
 
27387
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetText" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27388
  }
 
27389
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27390
  {
 
27391
    arg2 = wxString_in_helper(obj1);
 
27392
    if (arg2 == NULL) SWIG_fail;
 
27393
    temp2 = true;
 
27394
  }
 
27395
  {
 
27396
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27397
    (arg1)->SetText((wxString const &)*arg2);
 
27398
    wxPyEndAllowThreads(__tstate);
 
27399
    if (PyErr_Occurred()) SWIG_fail;
 
27400
  }
 
27401
  resultobj = SWIG_Py_Void();
 
27402
  {
 
27403
    if (temp2)
 
27404
    delete arg2;
 
27405
  }
 
27406
  return resultobj;
 
27407
fail:
 
27408
  {
 
27409
    if (temp2)
 
27410
    delete arg2;
 
27411
  }
 
27412
  return NULL;
 
27413
}
 
27414
 
 
27415
 
 
27416
SWIGINTERN PyObject *_wrap_ListItem_SetImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27417
  PyObject *resultobj = 0;
 
27418
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27419
  int arg2 ;
 
27420
  void *argp1 = 0 ;
 
27421
  int res1 = 0 ;
 
27422
  int val2 ;
 
27423
  int ecode2 = 0 ;
 
27424
  PyObject * obj0 = 0 ;
 
27425
  PyObject * obj1 = 0 ;
 
27426
  char *  kwnames[] = {
 
27427
    (char *) "self",(char *) "image", NULL 
 
27428
  };
 
27429
  
 
27430
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetImage",kwnames,&obj0,&obj1)) SWIG_fail;
 
27431
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27432
  if (!SWIG_IsOK(res1)) {
 
27433
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetImage" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27434
  }
 
27435
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27436
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
27437
  if (!SWIG_IsOK(ecode2)) {
 
27438
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_SetImage" "', expected argument " "2"" of type '" "int""'");
 
27439
  } 
 
27440
  arg2 = static_cast< int >(val2);
 
27441
  {
 
27442
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27443
    (arg1)->SetImage(arg2);
 
27444
    wxPyEndAllowThreads(__tstate);
 
27445
    if (PyErr_Occurred()) SWIG_fail;
 
27446
  }
 
27447
  resultobj = SWIG_Py_Void();
 
27448
  return resultobj;
 
27449
fail:
 
27450
  return NULL;
 
27451
}
 
27452
 
 
27453
 
 
27454
SWIGINTERN PyObject *_wrap_ListItem_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27455
  PyObject *resultobj = 0;
 
27456
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27457
  long arg2 ;
 
27458
  void *argp1 = 0 ;
 
27459
  int res1 = 0 ;
 
27460
  long val2 ;
 
27461
  int ecode2 = 0 ;
 
27462
  PyObject * obj0 = 0 ;
 
27463
  PyObject * obj1 = 0 ;
 
27464
  char *  kwnames[] = {
 
27465
    (char *) "self",(char *) "data", NULL 
 
27466
  };
 
27467
  
 
27468
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
 
27469
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27470
  if (!SWIG_IsOK(res1)) {
 
27471
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetData" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27472
  }
 
27473
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27474
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
27475
  if (!SWIG_IsOK(ecode2)) {
 
27476
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_SetData" "', expected argument " "2"" of type '" "long""'");
 
27477
  } 
 
27478
  arg2 = static_cast< long >(val2);
 
27479
  {
 
27480
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27481
    (arg1)->SetData(arg2);
 
27482
    wxPyEndAllowThreads(__tstate);
 
27483
    if (PyErr_Occurred()) SWIG_fail;
 
27484
  }
 
27485
  resultobj = SWIG_Py_Void();
 
27486
  return resultobj;
 
27487
fail:
 
27488
  return NULL;
 
27489
}
 
27490
 
 
27491
 
 
27492
SWIGINTERN PyObject *_wrap_ListItem_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27493
  PyObject *resultobj = 0;
 
27494
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27495
  int arg2 ;
 
27496
  void *argp1 = 0 ;
 
27497
  int res1 = 0 ;
 
27498
  int val2 ;
 
27499
  int ecode2 = 0 ;
 
27500
  PyObject * obj0 = 0 ;
 
27501
  PyObject * obj1 = 0 ;
 
27502
  char *  kwnames[] = {
 
27503
    (char *) "self",(char *) "width", NULL 
 
27504
  };
 
27505
  
 
27506
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
 
27507
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27508
  if (!SWIG_IsOK(res1)) {
 
27509
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetWidth" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27510
  }
 
27511
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27512
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
27513
  if (!SWIG_IsOK(ecode2)) {
 
27514
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_SetWidth" "', expected argument " "2"" of type '" "int""'");
 
27515
  } 
 
27516
  arg2 = static_cast< int >(val2);
 
27517
  {
 
27518
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27519
    (arg1)->SetWidth(arg2);
 
27520
    wxPyEndAllowThreads(__tstate);
 
27521
    if (PyErr_Occurred()) SWIG_fail;
 
27522
  }
 
27523
  resultobj = SWIG_Py_Void();
 
27524
  return resultobj;
 
27525
fail:
 
27526
  return NULL;
 
27527
}
 
27528
 
 
27529
 
 
27530
SWIGINTERN PyObject *_wrap_ListItem_SetAlign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27531
  PyObject *resultobj = 0;
 
27532
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27533
  wxListColumnFormat arg2 ;
 
27534
  void *argp1 = 0 ;
 
27535
  int res1 = 0 ;
 
27536
  int val2 ;
 
27537
  int ecode2 = 0 ;
 
27538
  PyObject * obj0 = 0 ;
 
27539
  PyObject * obj1 = 0 ;
 
27540
  char *  kwnames[] = {
 
27541
    (char *) "self",(char *) "align", NULL 
 
27542
  };
 
27543
  
 
27544
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetAlign",kwnames,&obj0,&obj1)) SWIG_fail;
 
27545
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27546
  if (!SWIG_IsOK(res1)) {
 
27547
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetAlign" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27548
  }
 
27549
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27550
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
27551
  if (!SWIG_IsOK(ecode2)) {
 
27552
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_SetAlign" "', expected argument " "2"" of type '" "wxListColumnFormat""'");
 
27553
  } 
 
27554
  arg2 = static_cast< wxListColumnFormat >(val2);
 
27555
  {
 
27556
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27557
    (arg1)->SetAlign(arg2);
 
27558
    wxPyEndAllowThreads(__tstate);
 
27559
    if (PyErr_Occurred()) SWIG_fail;
 
27560
  }
 
27561
  resultobj = SWIG_Py_Void();
 
27562
  return resultobj;
 
27563
fail:
 
27564
  return NULL;
 
27565
}
 
27566
 
 
27567
 
 
27568
SWIGINTERN PyObject *_wrap_ListItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27569
  PyObject *resultobj = 0;
 
27570
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27571
  wxColour *arg2 = 0 ;
 
27572
  void *argp1 = 0 ;
 
27573
  int res1 = 0 ;
 
27574
  wxColour temp2 ;
 
27575
  PyObject * obj0 = 0 ;
 
27576
  PyObject * obj1 = 0 ;
 
27577
  char *  kwnames[] = {
 
27578
    (char *) "self",(char *) "colText", NULL 
 
27579
  };
 
27580
  
 
27581
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
27582
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27583
  if (!SWIG_IsOK(res1)) {
 
27584
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetTextColour" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27585
  }
 
27586
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27587
  {
 
27588
    arg2 = &temp2;
 
27589
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
27590
  }
 
27591
  {
 
27592
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27593
    (arg1)->SetTextColour((wxColour const &)*arg2);
 
27594
    wxPyEndAllowThreads(__tstate);
 
27595
    if (PyErr_Occurred()) SWIG_fail;
 
27596
  }
 
27597
  resultobj = SWIG_Py_Void();
 
27598
  return resultobj;
 
27599
fail:
 
27600
  return NULL;
 
27601
}
 
27602
 
 
27603
 
 
27604
SWIGINTERN PyObject *_wrap_ListItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27605
  PyObject *resultobj = 0;
 
27606
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27607
  wxColour *arg2 = 0 ;
 
27608
  void *argp1 = 0 ;
 
27609
  int res1 = 0 ;
 
27610
  wxColour temp2 ;
 
27611
  PyObject * obj0 = 0 ;
 
27612
  PyObject * obj1 = 0 ;
 
27613
  char *  kwnames[] = {
 
27614
    (char *) "self",(char *) "colBack", NULL 
 
27615
  };
 
27616
  
 
27617
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
27618
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27619
  if (!SWIG_IsOK(res1)) {
 
27620
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27621
  }
 
27622
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27623
  {
 
27624
    arg2 = &temp2;
 
27625
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
27626
  }
 
27627
  {
 
27628
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27629
    (arg1)->SetBackgroundColour((wxColour const &)*arg2);
 
27630
    wxPyEndAllowThreads(__tstate);
 
27631
    if (PyErr_Occurred()) SWIG_fail;
 
27632
  }
 
27633
  resultobj = SWIG_Py_Void();
 
27634
  return resultobj;
 
27635
fail:
 
27636
  return NULL;
 
27637
}
 
27638
 
 
27639
 
 
27640
SWIGINTERN PyObject *_wrap_ListItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
27641
  PyObject *resultobj = 0;
 
27642
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27643
  wxFont *arg2 = 0 ;
 
27644
  void *argp1 = 0 ;
 
27645
  int res1 = 0 ;
 
27646
  void *argp2 = 0 ;
 
27647
  int res2 = 0 ;
 
27648
  PyObject * obj0 = 0 ;
 
27649
  PyObject * obj1 = 0 ;
 
27650
  char *  kwnames[] = {
 
27651
    (char *) "self",(char *) "font", NULL 
 
27652
  };
 
27653
  
 
27654
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
 
27655
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27656
  if (!SWIG_IsOK(res1)) {
 
27657
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_SetFont" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27658
  }
 
27659
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27660
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont,  0  | 0);
 
27661
  if (!SWIG_IsOK(res2)) {
 
27662
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
27663
  }
 
27664
  if (!argp2) {
 
27665
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
27666
  }
 
27667
  arg2 = reinterpret_cast< wxFont * >(argp2);
 
27668
  {
 
27669
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27670
    (arg1)->SetFont((wxFont const &)*arg2);
 
27671
    wxPyEndAllowThreads(__tstate);
 
27672
    if (PyErr_Occurred()) SWIG_fail;
 
27673
  }
 
27674
  resultobj = SWIG_Py_Void();
 
27675
  return resultobj;
 
27676
fail:
 
27677
  return NULL;
 
27678
}
 
27679
 
 
27680
 
 
27681
SWIGINTERN PyObject *_wrap_ListItem_GetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27682
  PyObject *resultobj = 0;
 
27683
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27684
  long result;
 
27685
  void *argp1 = 0 ;
 
27686
  int res1 = 0 ;
 
27687
  PyObject *swig_obj[1] ;
 
27688
  
 
27689
  if (!args) SWIG_fail;
 
27690
  swig_obj[0] = args;
 
27691
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27692
  if (!SWIG_IsOK(res1)) {
 
27693
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetMask" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27694
  }
 
27695
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27696
  {
 
27697
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27698
    result = (long)(arg1)->GetMask();
 
27699
    wxPyEndAllowThreads(__tstate);
 
27700
    if (PyErr_Occurred()) SWIG_fail;
 
27701
  }
 
27702
  resultobj = SWIG_From_long(static_cast< long >(result));
 
27703
  return resultobj;
 
27704
fail:
 
27705
  return NULL;
 
27706
}
 
27707
 
 
27708
 
 
27709
SWIGINTERN PyObject *_wrap_ListItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27710
  PyObject *resultobj = 0;
 
27711
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27712
  long result;
 
27713
  void *argp1 = 0 ;
 
27714
  int res1 = 0 ;
 
27715
  PyObject *swig_obj[1] ;
 
27716
  
 
27717
  if (!args) SWIG_fail;
 
27718
  swig_obj[0] = args;
 
27719
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27720
  if (!SWIG_IsOK(res1)) {
 
27721
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetId" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27722
  }
 
27723
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27724
  {
 
27725
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27726
    result = (long)(arg1)->GetId();
 
27727
    wxPyEndAllowThreads(__tstate);
 
27728
    if (PyErr_Occurred()) SWIG_fail;
 
27729
  }
 
27730
  resultobj = SWIG_From_long(static_cast< long >(result));
 
27731
  return resultobj;
 
27732
fail:
 
27733
  return NULL;
 
27734
}
 
27735
 
 
27736
 
 
27737
SWIGINTERN PyObject *_wrap_ListItem_GetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27738
  PyObject *resultobj = 0;
 
27739
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27740
  int result;
 
27741
  void *argp1 = 0 ;
 
27742
  int res1 = 0 ;
 
27743
  PyObject *swig_obj[1] ;
 
27744
  
 
27745
  if (!args) SWIG_fail;
 
27746
  swig_obj[0] = args;
 
27747
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27748
  if (!SWIG_IsOK(res1)) {
 
27749
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetColumn" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27750
  }
 
27751
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27752
  {
 
27753
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27754
    result = (int)(arg1)->GetColumn();
 
27755
    wxPyEndAllowThreads(__tstate);
 
27756
    if (PyErr_Occurred()) SWIG_fail;
 
27757
  }
 
27758
  resultobj = SWIG_From_int(static_cast< int >(result));
 
27759
  return resultobj;
 
27760
fail:
 
27761
  return NULL;
 
27762
}
 
27763
 
 
27764
 
 
27765
SWIGINTERN PyObject *_wrap_ListItem_GetState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27766
  PyObject *resultobj = 0;
 
27767
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27768
  long result;
 
27769
  void *argp1 = 0 ;
 
27770
  int res1 = 0 ;
 
27771
  PyObject *swig_obj[1] ;
 
27772
  
 
27773
  if (!args) SWIG_fail;
 
27774
  swig_obj[0] = args;
 
27775
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27776
  if (!SWIG_IsOK(res1)) {
 
27777
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetState" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27778
  }
 
27779
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27780
  {
 
27781
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27782
    result = (long)(arg1)->GetState();
 
27783
    wxPyEndAllowThreads(__tstate);
 
27784
    if (PyErr_Occurred()) SWIG_fail;
 
27785
  }
 
27786
  resultobj = SWIG_From_long(static_cast< long >(result));
 
27787
  return resultobj;
 
27788
fail:
 
27789
  return NULL;
 
27790
}
 
27791
 
 
27792
 
 
27793
SWIGINTERN PyObject *_wrap_ListItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27794
  PyObject *resultobj = 0;
 
27795
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27796
  wxString *result = 0 ;
 
27797
  void *argp1 = 0 ;
 
27798
  int res1 = 0 ;
 
27799
  PyObject *swig_obj[1] ;
 
27800
  
 
27801
  if (!args) SWIG_fail;
 
27802
  swig_obj[0] = args;
 
27803
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27804
  if (!SWIG_IsOK(res1)) {
 
27805
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetText" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27806
  }
 
27807
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27808
  {
 
27809
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27810
    {
 
27811
      wxString const &_result_ref = (arg1)->GetText();
 
27812
      result = (wxString *) &_result_ref;
 
27813
    }
 
27814
    wxPyEndAllowThreads(__tstate);
 
27815
    if (PyErr_Occurred()) SWIG_fail;
 
27816
  }
 
27817
  {
 
27818
#if wxUSE_UNICODE
 
27819
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
27820
#else
 
27821
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
27822
#endif
 
27823
  }
 
27824
  return resultobj;
 
27825
fail:
 
27826
  return NULL;
 
27827
}
 
27828
 
 
27829
 
 
27830
SWIGINTERN PyObject *_wrap_ListItem_GetImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27831
  PyObject *resultobj = 0;
 
27832
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27833
  int result;
 
27834
  void *argp1 = 0 ;
 
27835
  int res1 = 0 ;
 
27836
  PyObject *swig_obj[1] ;
 
27837
  
 
27838
  if (!args) SWIG_fail;
 
27839
  swig_obj[0] = args;
 
27840
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27841
  if (!SWIG_IsOK(res1)) {
 
27842
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetImage" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27843
  }
 
27844
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27845
  {
 
27846
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27847
    result = (int)(arg1)->GetImage();
 
27848
    wxPyEndAllowThreads(__tstate);
 
27849
    if (PyErr_Occurred()) SWIG_fail;
 
27850
  }
 
27851
  resultobj = SWIG_From_int(static_cast< int >(result));
 
27852
  return resultobj;
 
27853
fail:
 
27854
  return NULL;
 
27855
}
 
27856
 
 
27857
 
 
27858
SWIGINTERN PyObject *_wrap_ListItem_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27859
  PyObject *resultobj = 0;
 
27860
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27861
  long result;
 
27862
  void *argp1 = 0 ;
 
27863
  int res1 = 0 ;
 
27864
  PyObject *swig_obj[1] ;
 
27865
  
 
27866
  if (!args) SWIG_fail;
 
27867
  swig_obj[0] = args;
 
27868
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27869
  if (!SWIG_IsOK(res1)) {
 
27870
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetData" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27871
  }
 
27872
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27873
  {
 
27874
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27875
    result = (long)(arg1)->GetData();
 
27876
    wxPyEndAllowThreads(__tstate);
 
27877
    if (PyErr_Occurred()) SWIG_fail;
 
27878
  }
 
27879
  resultobj = SWIG_From_long(static_cast< long >(result));
 
27880
  return resultobj;
 
27881
fail:
 
27882
  return NULL;
 
27883
}
 
27884
 
 
27885
 
 
27886
SWIGINTERN PyObject *_wrap_ListItem_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27887
  PyObject *resultobj = 0;
 
27888
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27889
  int result;
 
27890
  void *argp1 = 0 ;
 
27891
  int res1 = 0 ;
 
27892
  PyObject *swig_obj[1] ;
 
27893
  
 
27894
  if (!args) SWIG_fail;
 
27895
  swig_obj[0] = args;
 
27896
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27897
  if (!SWIG_IsOK(res1)) {
 
27898
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetWidth" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27899
  }
 
27900
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27901
  {
 
27902
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27903
    result = (int)(arg1)->GetWidth();
 
27904
    wxPyEndAllowThreads(__tstate);
 
27905
    if (PyErr_Occurred()) SWIG_fail;
 
27906
  }
 
27907
  resultobj = SWIG_From_int(static_cast< int >(result));
 
27908
  return resultobj;
 
27909
fail:
 
27910
  return NULL;
 
27911
}
 
27912
 
 
27913
 
 
27914
SWIGINTERN PyObject *_wrap_ListItem_GetAlign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27915
  PyObject *resultobj = 0;
 
27916
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27917
  wxListColumnFormat result;
 
27918
  void *argp1 = 0 ;
 
27919
  int res1 = 0 ;
 
27920
  PyObject *swig_obj[1] ;
 
27921
  
 
27922
  if (!args) SWIG_fail;
 
27923
  swig_obj[0] = args;
 
27924
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27925
  if (!SWIG_IsOK(res1)) {
 
27926
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetAlign" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27927
  }
 
27928
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27929
  {
 
27930
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27931
    result = (wxListColumnFormat)(arg1)->GetAlign();
 
27932
    wxPyEndAllowThreads(__tstate);
 
27933
    if (PyErr_Occurred()) SWIG_fail;
 
27934
  }
 
27935
  resultobj = SWIG_From_int(static_cast< int >(result));
 
27936
  return resultobj;
 
27937
fail:
 
27938
  return NULL;
 
27939
}
 
27940
 
 
27941
 
 
27942
SWIGINTERN PyObject *_wrap_ListItem_GetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27943
  PyObject *resultobj = 0;
 
27944
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27945
  wxListItemAttr *result = 0 ;
 
27946
  void *argp1 = 0 ;
 
27947
  int res1 = 0 ;
 
27948
  PyObject *swig_obj[1] ;
 
27949
  
 
27950
  if (!args) SWIG_fail;
 
27951
  swig_obj[0] = args;
 
27952
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27953
  if (!SWIG_IsOK(res1)) {
 
27954
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetAttributes" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27955
  }
 
27956
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27957
  {
 
27958
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27959
    result = (wxListItemAttr *)(arg1)->GetAttributes();
 
27960
    wxPyEndAllowThreads(__tstate);
 
27961
    if (PyErr_Occurred()) SWIG_fail;
 
27962
  }
 
27963
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListItemAttr, 0 |  0 );
 
27964
  return resultobj;
 
27965
fail:
 
27966
  return NULL;
 
27967
}
 
27968
 
 
27969
 
 
27970
SWIGINTERN PyObject *_wrap_ListItem_HasAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
27971
  PyObject *resultobj = 0;
 
27972
  wxListItem *arg1 = (wxListItem *) 0 ;
 
27973
  bool result;
 
27974
  void *argp1 = 0 ;
 
27975
  int res1 = 0 ;
 
27976
  PyObject *swig_obj[1] ;
 
27977
  
 
27978
  if (!args) SWIG_fail;
 
27979
  swig_obj[0] = args;
 
27980
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
27981
  if (!SWIG_IsOK(res1)) {
 
27982
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_HasAttributes" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
27983
  }
 
27984
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
27985
  {
 
27986
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
27987
    result = (bool)(arg1)->HasAttributes();
 
27988
    wxPyEndAllowThreads(__tstate);
 
27989
    if (PyErr_Occurred()) SWIG_fail;
 
27990
  }
 
27991
  {
 
27992
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
27993
  }
 
27994
  return resultobj;
 
27995
fail:
 
27996
  return NULL;
 
27997
}
 
27998
 
 
27999
 
 
28000
SWIGINTERN PyObject *_wrap_ListItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28001
  PyObject *resultobj = 0;
 
28002
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28003
  wxColour result;
 
28004
  void *argp1 = 0 ;
 
28005
  int res1 = 0 ;
 
28006
  PyObject *swig_obj[1] ;
 
28007
  
 
28008
  if (!args) SWIG_fail;
 
28009
  swig_obj[0] = args;
 
28010
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28011
  if (!SWIG_IsOK(res1)) {
 
28012
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetTextColour" "', expected argument " "1"" of type '" "wxListItem const *""'"); 
 
28013
  }
 
28014
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28015
  {
 
28016
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
28017
    result = ((wxListItem const *)arg1)->GetTextColour();
 
28018
    wxPyEndAllowThreads(__tstate);
 
28019
    if (PyErr_Occurred()) SWIG_fail;
 
28020
  }
 
28021
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
28022
  return resultobj;
 
28023
fail:
 
28024
  return NULL;
 
28025
}
 
28026
 
 
28027
 
 
28028
SWIGINTERN PyObject *_wrap_ListItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28029
  PyObject *resultobj = 0;
 
28030
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28031
  wxColour result;
 
28032
  void *argp1 = 0 ;
 
28033
  int res1 = 0 ;
 
28034
  PyObject *swig_obj[1] ;
 
28035
  
 
28036
  if (!args) SWIG_fail;
 
28037
  swig_obj[0] = args;
 
28038
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28039
  if (!SWIG_IsOK(res1)) {
 
28040
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxListItem const *""'"); 
 
28041
  }
 
28042
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28043
  {
 
28044
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
28045
    result = ((wxListItem const *)arg1)->GetBackgroundColour();
 
28046
    wxPyEndAllowThreads(__tstate);
 
28047
    if (PyErr_Occurred()) SWIG_fail;
 
28048
  }
 
28049
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
28050
  return resultobj;
 
28051
fail:
 
28052
  return NULL;
 
28053
}
 
28054
 
 
28055
 
 
28056
SWIGINTERN PyObject *_wrap_ListItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28057
  PyObject *resultobj = 0;
 
28058
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28059
  wxFont result;
 
28060
  void *argp1 = 0 ;
 
28061
  int res1 = 0 ;
 
28062
  PyObject *swig_obj[1] ;
 
28063
  
 
28064
  if (!args) SWIG_fail;
 
28065
  swig_obj[0] = args;
 
28066
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28067
  if (!SWIG_IsOK(res1)) {
 
28068
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_GetFont" "', expected argument " "1"" of type '" "wxListItem const *""'"); 
 
28069
  }
 
28070
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28071
  {
 
28072
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
28073
    result = ((wxListItem const *)arg1)->GetFont();
 
28074
    wxPyEndAllowThreads(__tstate);
 
28075
    if (PyErr_Occurred()) SWIG_fail;
 
28076
  }
 
28077
  resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN |  0 );
 
28078
  return resultobj;
 
28079
fail:
 
28080
  return NULL;
 
28081
}
 
28082
 
 
28083
 
 
28084
SWIGINTERN PyObject *_wrap_ListItem_m_mask_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28085
  PyObject *resultobj = 0;
 
28086
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28087
  long arg2 ;
 
28088
  void *argp1 = 0 ;
 
28089
  int res1 = 0 ;
 
28090
  long val2 ;
 
28091
  int ecode2 = 0 ;
 
28092
  PyObject *swig_obj[2] ;
 
28093
  
 
28094
  if (!SWIG_Python_UnpackTuple(args,"ListItem_m_mask_set",2,2,swig_obj)) SWIG_fail;
 
28095
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28096
  if (!SWIG_IsOK(res1)) {
 
28097
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_mask_set" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28098
  }
 
28099
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28100
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
 
28101
  if (!SWIG_IsOK(ecode2)) {
 
28102
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_m_mask_set" "', expected argument " "2"" of type '" "long""'");
 
28103
  } 
 
28104
  arg2 = static_cast< long >(val2);
 
28105
  if (arg1) (arg1)->m_mask = arg2;
 
28106
  
 
28107
  resultobj = SWIG_Py_Void();
 
28108
  return resultobj;
 
28109
fail:
 
28110
  return NULL;
 
28111
}
 
28112
 
 
28113
 
 
28114
SWIGINTERN PyObject *_wrap_ListItem_m_mask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28115
  PyObject *resultobj = 0;
 
28116
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28117
  long result;
 
28118
  void *argp1 = 0 ;
 
28119
  int res1 = 0 ;
 
28120
  PyObject *swig_obj[1] ;
 
28121
  
 
28122
  if (!args) SWIG_fail;
 
28123
  swig_obj[0] = args;
 
28124
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28125
  if (!SWIG_IsOK(res1)) {
 
28126
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_mask_get" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28127
  }
 
28128
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28129
  result = (long) ((arg1)->m_mask);
 
28130
  resultobj = SWIG_From_long(static_cast< long >(result));
 
28131
  return resultobj;
 
28132
fail:
 
28133
  return NULL;
 
28134
}
 
28135
 
 
28136
 
 
28137
SWIGINTERN PyObject *_wrap_ListItem_m_itemId_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28138
  PyObject *resultobj = 0;
 
28139
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28140
  long arg2 ;
 
28141
  void *argp1 = 0 ;
 
28142
  int res1 = 0 ;
 
28143
  long val2 ;
 
28144
  int ecode2 = 0 ;
 
28145
  PyObject *swig_obj[2] ;
 
28146
  
 
28147
  if (!SWIG_Python_UnpackTuple(args,"ListItem_m_itemId_set",2,2,swig_obj)) SWIG_fail;
 
28148
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28149
  if (!SWIG_IsOK(res1)) {
 
28150
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_itemId_set" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28151
  }
 
28152
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28153
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
 
28154
  if (!SWIG_IsOK(ecode2)) {
 
28155
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_m_itemId_set" "', expected argument " "2"" of type '" "long""'");
 
28156
  } 
 
28157
  arg2 = static_cast< long >(val2);
 
28158
  if (arg1) (arg1)->m_itemId = arg2;
 
28159
  
 
28160
  resultobj = SWIG_Py_Void();
 
28161
  return resultobj;
 
28162
fail:
 
28163
  return NULL;
 
28164
}
 
28165
 
 
28166
 
 
28167
SWIGINTERN PyObject *_wrap_ListItem_m_itemId_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28168
  PyObject *resultobj = 0;
 
28169
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28170
  long result;
 
28171
  void *argp1 = 0 ;
 
28172
  int res1 = 0 ;
 
28173
  PyObject *swig_obj[1] ;
 
28174
  
 
28175
  if (!args) SWIG_fail;
 
28176
  swig_obj[0] = args;
 
28177
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28178
  if (!SWIG_IsOK(res1)) {
 
28179
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_itemId_get" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28180
  }
 
28181
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28182
  result = (long) ((arg1)->m_itemId);
 
28183
  resultobj = SWIG_From_long(static_cast< long >(result));
 
28184
  return resultobj;
 
28185
fail:
 
28186
  return NULL;
 
28187
}
 
28188
 
 
28189
 
 
28190
SWIGINTERN PyObject *_wrap_ListItem_m_col_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28191
  PyObject *resultobj = 0;
 
28192
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28193
  int arg2 ;
 
28194
  void *argp1 = 0 ;
 
28195
  int res1 = 0 ;
 
28196
  int val2 ;
 
28197
  int ecode2 = 0 ;
 
28198
  PyObject *swig_obj[2] ;
 
28199
  
 
28200
  if (!SWIG_Python_UnpackTuple(args,"ListItem_m_col_set",2,2,swig_obj)) SWIG_fail;
 
28201
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28202
  if (!SWIG_IsOK(res1)) {
 
28203
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_col_set" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28204
  }
 
28205
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28206
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
 
28207
  if (!SWIG_IsOK(ecode2)) {
 
28208
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_m_col_set" "', expected argument " "2"" of type '" "int""'");
 
28209
  } 
 
28210
  arg2 = static_cast< int >(val2);
 
28211
  if (arg1) (arg1)->m_col = arg2;
 
28212
  
 
28213
  resultobj = SWIG_Py_Void();
 
28214
  return resultobj;
 
28215
fail:
 
28216
  return NULL;
 
28217
}
 
28218
 
 
28219
 
 
28220
SWIGINTERN PyObject *_wrap_ListItem_m_col_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28221
  PyObject *resultobj = 0;
 
28222
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28223
  int result;
 
28224
  void *argp1 = 0 ;
 
28225
  int res1 = 0 ;
 
28226
  PyObject *swig_obj[1] ;
 
28227
  
 
28228
  if (!args) SWIG_fail;
 
28229
  swig_obj[0] = args;
 
28230
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28231
  if (!SWIG_IsOK(res1)) {
 
28232
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_col_get" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28233
  }
 
28234
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28235
  result = (int) ((arg1)->m_col);
 
28236
  resultobj = SWIG_From_int(static_cast< int >(result));
 
28237
  return resultobj;
 
28238
fail:
 
28239
  return NULL;
 
28240
}
 
28241
 
 
28242
 
 
28243
SWIGINTERN PyObject *_wrap_ListItem_m_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28244
  PyObject *resultobj = 0;
 
28245
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28246
  long arg2 ;
 
28247
  void *argp1 = 0 ;
 
28248
  int res1 = 0 ;
 
28249
  long val2 ;
 
28250
  int ecode2 = 0 ;
 
28251
  PyObject *swig_obj[2] ;
 
28252
  
 
28253
  if (!SWIG_Python_UnpackTuple(args,"ListItem_m_state_set",2,2,swig_obj)) SWIG_fail;
 
28254
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28255
  if (!SWIG_IsOK(res1)) {
 
28256
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_state_set" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28257
  }
 
28258
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28259
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
 
28260
  if (!SWIG_IsOK(ecode2)) {
 
28261
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_m_state_set" "', expected argument " "2"" of type '" "long""'");
 
28262
  } 
 
28263
  arg2 = static_cast< long >(val2);
 
28264
  if (arg1) (arg1)->m_state = arg2;
 
28265
  
 
28266
  resultobj = SWIG_Py_Void();
 
28267
  return resultobj;
 
28268
fail:
 
28269
  return NULL;
 
28270
}
 
28271
 
 
28272
 
 
28273
SWIGINTERN PyObject *_wrap_ListItem_m_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28274
  PyObject *resultobj = 0;
 
28275
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28276
  long result;
 
28277
  void *argp1 = 0 ;
 
28278
  int res1 = 0 ;
 
28279
  PyObject *swig_obj[1] ;
 
28280
  
 
28281
  if (!args) SWIG_fail;
 
28282
  swig_obj[0] = args;
 
28283
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28284
  if (!SWIG_IsOK(res1)) {
 
28285
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_state_get" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28286
  }
 
28287
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28288
  result = (long) ((arg1)->m_state);
 
28289
  resultobj = SWIG_From_long(static_cast< long >(result));
 
28290
  return resultobj;
 
28291
fail:
 
28292
  return NULL;
 
28293
}
 
28294
 
 
28295
 
 
28296
SWIGINTERN PyObject *_wrap_ListItem_m_stateMask_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28297
  PyObject *resultobj = 0;
 
28298
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28299
  long arg2 ;
 
28300
  void *argp1 = 0 ;
 
28301
  int res1 = 0 ;
 
28302
  long val2 ;
 
28303
  int ecode2 = 0 ;
 
28304
  PyObject *swig_obj[2] ;
 
28305
  
 
28306
  if (!SWIG_Python_UnpackTuple(args,"ListItem_m_stateMask_set",2,2,swig_obj)) SWIG_fail;
 
28307
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28308
  if (!SWIG_IsOK(res1)) {
 
28309
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_stateMask_set" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28310
  }
 
28311
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28312
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
 
28313
  if (!SWIG_IsOK(ecode2)) {
 
28314
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_m_stateMask_set" "', expected argument " "2"" of type '" "long""'");
 
28315
  } 
 
28316
  arg2 = static_cast< long >(val2);
 
28317
  if (arg1) (arg1)->m_stateMask = arg2;
 
28318
  
 
28319
  resultobj = SWIG_Py_Void();
 
28320
  return resultobj;
 
28321
fail:
 
28322
  return NULL;
 
28323
}
 
28324
 
 
28325
 
 
28326
SWIGINTERN PyObject *_wrap_ListItem_m_stateMask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28327
  PyObject *resultobj = 0;
 
28328
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28329
  long result;
 
28330
  void *argp1 = 0 ;
 
28331
  int res1 = 0 ;
 
28332
  PyObject *swig_obj[1] ;
 
28333
  
 
28334
  if (!args) SWIG_fail;
 
28335
  swig_obj[0] = args;
 
28336
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28337
  if (!SWIG_IsOK(res1)) {
 
28338
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_stateMask_get" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28339
  }
 
28340
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28341
  result = (long) ((arg1)->m_stateMask);
 
28342
  resultobj = SWIG_From_long(static_cast< long >(result));
 
28343
  return resultobj;
 
28344
fail:
 
28345
  return NULL;
 
28346
}
 
28347
 
 
28348
 
 
28349
SWIGINTERN PyObject *_wrap_ListItem_m_text_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28350
  PyObject *resultobj = 0;
 
28351
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28352
  wxString *arg2 = (wxString *) 0 ;
 
28353
  void *argp1 = 0 ;
 
28354
  int res1 = 0 ;
 
28355
  bool temp2 = false ;
 
28356
  PyObject *swig_obj[2] ;
 
28357
  
 
28358
  if (!SWIG_Python_UnpackTuple(args,"ListItem_m_text_set",2,2,swig_obj)) SWIG_fail;
 
28359
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28360
  if (!SWIG_IsOK(res1)) {
 
28361
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_text_set" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28362
  }
 
28363
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28364
  {
 
28365
    arg2 = wxString_in_helper(swig_obj[1]);
 
28366
    if (arg2 == NULL) SWIG_fail;
 
28367
    temp2 = true;
 
28368
  }
 
28369
  if (arg1) (arg1)->m_text = *arg2;
 
28370
  
 
28371
  resultobj = SWIG_Py_Void();
 
28372
  {
 
28373
    if (temp2)
 
28374
    delete arg2;
 
28375
  }
 
28376
  return resultobj;
 
28377
fail:
 
28378
  {
 
28379
    if (temp2)
 
28380
    delete arg2;
 
28381
  }
 
28382
  return NULL;
 
28383
}
 
28384
 
 
28385
 
 
28386
SWIGINTERN PyObject *_wrap_ListItem_m_text_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28387
  PyObject *resultobj = 0;
 
28388
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28389
  wxString *result = 0 ;
 
28390
  void *argp1 = 0 ;
 
28391
  int res1 = 0 ;
 
28392
  PyObject *swig_obj[1] ;
 
28393
  
 
28394
  if (!args) SWIG_fail;
 
28395
  swig_obj[0] = args;
 
28396
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28397
  if (!SWIG_IsOK(res1)) {
 
28398
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_text_get" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28399
  }
 
28400
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28401
  result = (wxString *)& ((arg1)->m_text);
 
28402
  {
 
28403
#if wxUSE_UNICODE
 
28404
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
28405
#else
 
28406
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
28407
#endif
 
28408
  }
 
28409
  return resultobj;
 
28410
fail:
 
28411
  return NULL;
 
28412
}
 
28413
 
 
28414
 
 
28415
SWIGINTERN PyObject *_wrap_ListItem_m_image_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28416
  PyObject *resultobj = 0;
 
28417
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28418
  int arg2 ;
 
28419
  void *argp1 = 0 ;
 
28420
  int res1 = 0 ;
 
28421
  int val2 ;
 
28422
  int ecode2 = 0 ;
 
28423
  PyObject *swig_obj[2] ;
 
28424
  
 
28425
  if (!SWIG_Python_UnpackTuple(args,"ListItem_m_image_set",2,2,swig_obj)) SWIG_fail;
 
28426
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28427
  if (!SWIG_IsOK(res1)) {
 
28428
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_image_set" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28429
  }
 
28430
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28431
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
 
28432
  if (!SWIG_IsOK(ecode2)) {
 
28433
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_m_image_set" "', expected argument " "2"" of type '" "int""'");
 
28434
  } 
 
28435
  arg2 = static_cast< int >(val2);
 
28436
  if (arg1) (arg1)->m_image = arg2;
 
28437
  
 
28438
  resultobj = SWIG_Py_Void();
 
28439
  return resultobj;
 
28440
fail:
 
28441
  return NULL;
 
28442
}
 
28443
 
 
28444
 
 
28445
SWIGINTERN PyObject *_wrap_ListItem_m_image_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28446
  PyObject *resultobj = 0;
 
28447
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28448
  int result;
 
28449
  void *argp1 = 0 ;
 
28450
  int res1 = 0 ;
 
28451
  PyObject *swig_obj[1] ;
 
28452
  
 
28453
  if (!args) SWIG_fail;
 
28454
  swig_obj[0] = args;
 
28455
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28456
  if (!SWIG_IsOK(res1)) {
 
28457
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_image_get" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28458
  }
 
28459
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28460
  result = (int) ((arg1)->m_image);
 
28461
  resultobj = SWIG_From_int(static_cast< int >(result));
 
28462
  return resultobj;
 
28463
fail:
 
28464
  return NULL;
 
28465
}
 
28466
 
 
28467
 
 
28468
SWIGINTERN PyObject *_wrap_ListItem_m_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28469
  PyObject *resultobj = 0;
 
28470
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28471
  long arg2 ;
 
28472
  void *argp1 = 0 ;
 
28473
  int res1 = 0 ;
 
28474
  long val2 ;
 
28475
  int ecode2 = 0 ;
 
28476
  PyObject *swig_obj[2] ;
 
28477
  
 
28478
  if (!SWIG_Python_UnpackTuple(args,"ListItem_m_data_set",2,2,swig_obj)) SWIG_fail;
 
28479
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28480
  if (!SWIG_IsOK(res1)) {
 
28481
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_data_set" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28482
  }
 
28483
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28484
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
 
28485
  if (!SWIG_IsOK(ecode2)) {
 
28486
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_m_data_set" "', expected argument " "2"" of type '" "long""'");
 
28487
  } 
 
28488
  arg2 = static_cast< long >(val2);
 
28489
  if (arg1) (arg1)->m_data = arg2;
 
28490
  
 
28491
  resultobj = SWIG_Py_Void();
 
28492
  return resultobj;
 
28493
fail:
 
28494
  return NULL;
 
28495
}
 
28496
 
 
28497
 
 
28498
SWIGINTERN PyObject *_wrap_ListItem_m_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28499
  PyObject *resultobj = 0;
 
28500
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28501
  long result;
 
28502
  void *argp1 = 0 ;
 
28503
  int res1 = 0 ;
 
28504
  PyObject *swig_obj[1] ;
 
28505
  
 
28506
  if (!args) SWIG_fail;
 
28507
  swig_obj[0] = args;
 
28508
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28509
  if (!SWIG_IsOK(res1)) {
 
28510
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_data_get" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28511
  }
 
28512
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28513
  result = (long) ((arg1)->m_data);
 
28514
  resultobj = SWIG_From_long(static_cast< long >(result));
 
28515
  return resultobj;
 
28516
fail:
 
28517
  return NULL;
 
28518
}
 
28519
 
 
28520
 
 
28521
SWIGINTERN PyObject *_wrap_ListItem_m_format_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28522
  PyObject *resultobj = 0;
 
28523
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28524
  int arg2 ;
 
28525
  void *argp1 = 0 ;
 
28526
  int res1 = 0 ;
 
28527
  int val2 ;
 
28528
  int ecode2 = 0 ;
 
28529
  PyObject *swig_obj[2] ;
 
28530
  
 
28531
  if (!SWIG_Python_UnpackTuple(args,"ListItem_m_format_set",2,2,swig_obj)) SWIG_fail;
 
28532
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28533
  if (!SWIG_IsOK(res1)) {
 
28534
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_format_set" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28535
  }
 
28536
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28537
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
 
28538
  if (!SWIG_IsOK(ecode2)) {
 
28539
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_m_format_set" "', expected argument " "2"" of type '" "int""'");
 
28540
  } 
 
28541
  arg2 = static_cast< int >(val2);
 
28542
  if (arg1) (arg1)->m_format = arg2;
 
28543
  
 
28544
  resultobj = SWIG_Py_Void();
 
28545
  return resultobj;
 
28546
fail:
 
28547
  return NULL;
 
28548
}
 
28549
 
 
28550
 
 
28551
SWIGINTERN PyObject *_wrap_ListItem_m_format_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28552
  PyObject *resultobj = 0;
 
28553
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28554
  int result;
 
28555
  void *argp1 = 0 ;
 
28556
  int res1 = 0 ;
 
28557
  PyObject *swig_obj[1] ;
 
28558
  
 
28559
  if (!args) SWIG_fail;
 
28560
  swig_obj[0] = args;
 
28561
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28562
  if (!SWIG_IsOK(res1)) {
 
28563
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_format_get" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28564
  }
 
28565
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28566
  result = (int) ((arg1)->m_format);
 
28567
  resultobj = SWIG_From_int(static_cast< int >(result));
 
28568
  return resultobj;
 
28569
fail:
 
28570
  return NULL;
 
28571
}
 
28572
 
 
28573
 
 
28574
SWIGINTERN PyObject *_wrap_ListItem_m_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28575
  PyObject *resultobj = 0;
 
28576
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28577
  int arg2 ;
 
28578
  void *argp1 = 0 ;
 
28579
  int res1 = 0 ;
 
28580
  int val2 ;
 
28581
  int ecode2 = 0 ;
 
28582
  PyObject *swig_obj[2] ;
 
28583
  
 
28584
  if (!SWIG_Python_UnpackTuple(args,"ListItem_m_width_set",2,2,swig_obj)) SWIG_fail;
 
28585
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28586
  if (!SWIG_IsOK(res1)) {
 
28587
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_width_set" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28588
  }
 
28589
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28590
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
 
28591
  if (!SWIG_IsOK(ecode2)) {
 
28592
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListItem_m_width_set" "', expected argument " "2"" of type '" "int""'");
 
28593
  } 
 
28594
  arg2 = static_cast< int >(val2);
 
28595
  if (arg1) (arg1)->m_width = arg2;
 
28596
  
 
28597
  resultobj = SWIG_Py_Void();
 
28598
  return resultobj;
 
28599
fail:
 
28600
  return NULL;
 
28601
}
 
28602
 
 
28603
 
 
28604
SWIGINTERN PyObject *_wrap_ListItem_m_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28605
  PyObject *resultobj = 0;
 
28606
  wxListItem *arg1 = (wxListItem *) 0 ;
 
28607
  int result;
 
28608
  void *argp1 = 0 ;
 
28609
  int res1 = 0 ;
 
28610
  PyObject *swig_obj[1] ;
 
28611
  
 
28612
  if (!args) SWIG_fail;
 
28613
  swig_obj[0] = args;
 
28614
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListItem, 0 |  0 );
 
28615
  if (!SWIG_IsOK(res1)) {
 
28616
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListItem_m_width_get" "', expected argument " "1"" of type '" "wxListItem *""'"); 
 
28617
  }
 
28618
  arg1 = reinterpret_cast< wxListItem * >(argp1);
 
28619
  result = (int) ((arg1)->m_width);
 
28620
  resultobj = SWIG_From_int(static_cast< int >(result));
 
28621
  return resultobj;
 
28622
fail:
 
28623
  return NULL;
 
28624
}
 
28625
 
 
28626
 
 
28627
SWIGINTERN PyObject *ListItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28628
  PyObject *obj;
 
28629
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
28630
  SWIG_TypeNewClientData(SWIGTYPE_p_wxListItem, SWIG_NewClientData(obj));
 
28631
  return SWIG_Py_Void();
 
28632
}
 
28633
 
 
28634
SWIGINTERN PyObject *ListItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28635
  return SWIG_Python_InitShadowInstance(args);
 
28636
}
 
28637
 
 
28638
SWIGINTERN PyObject *_wrap_new_ListEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
28639
  PyObject *resultobj = 0;
 
28640
  wxEventType arg1 = (wxEventType) wxEVT_NULL ;
 
28641
  int arg2 = (int) 0 ;
 
28642
  wxListEvent *result = 0 ;
 
28643
  int val1 ;
 
28644
  int ecode1 = 0 ;
 
28645
  int val2 ;
 
28646
  int ecode2 = 0 ;
 
28647
  PyObject * obj0 = 0 ;
 
28648
  PyObject * obj1 = 0 ;
 
28649
  char *  kwnames[] = {
 
28650
    (char *) "commandType",(char *) "id", NULL 
 
28651
  };
 
28652
  
 
28653
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ListEvent",kwnames,&obj0,&obj1)) SWIG_fail;
 
28654
  if (obj0) {
 
28655
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
28656
    if (!SWIG_IsOK(ecode1)) {
 
28657
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListEvent" "', expected argument " "1"" of type '" "wxEventType""'");
 
28658
    } 
 
28659
    arg1 = static_cast< wxEventType >(val1);
 
28660
  }
 
28661
  if (obj1) {
 
28662
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
28663
    if (!SWIG_IsOK(ecode2)) {
 
28664
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListEvent" "', expected argument " "2"" of type '" "int""'");
 
28665
    } 
 
28666
    arg2 = static_cast< int >(val2);
 
28667
  }
 
28668
  {
 
28669
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
28670
    result = (wxListEvent *)new wxListEvent(arg1,arg2);
 
28671
    wxPyEndAllowThreads(__tstate);
 
28672
    if (PyErr_Occurred()) SWIG_fail;
 
28673
  }
 
28674
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListEvent, SWIG_POINTER_NEW |  0 );
 
28675
  return resultobj;
 
28676
fail:
 
28677
  return NULL;
 
28678
}
 
28679
 
 
28680
 
 
28681
SWIGINTERN PyObject *_wrap_ListEvent_m_code_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28682
  PyObject *resultobj = 0;
 
28683
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28684
  int arg2 ;
 
28685
  void *argp1 = 0 ;
 
28686
  int res1 = 0 ;
 
28687
  int val2 ;
 
28688
  int ecode2 = 0 ;
 
28689
  PyObject *swig_obj[2] ;
 
28690
  
 
28691
  if (!SWIG_Python_UnpackTuple(args,"ListEvent_m_code_set",2,2,swig_obj)) SWIG_fail;
 
28692
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28693
  if (!SWIG_IsOK(res1)) {
 
28694
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_code_set" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28695
  }
 
28696
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28697
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
 
28698
  if (!SWIG_IsOK(ecode2)) {
 
28699
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListEvent_m_code_set" "', expected argument " "2"" of type '" "int""'");
 
28700
  } 
 
28701
  arg2 = static_cast< int >(val2);
 
28702
  if (arg1) (arg1)->m_code = arg2;
 
28703
  
 
28704
  resultobj = SWIG_Py_Void();
 
28705
  return resultobj;
 
28706
fail:
 
28707
  return NULL;
 
28708
}
 
28709
 
 
28710
 
 
28711
SWIGINTERN PyObject *_wrap_ListEvent_m_code_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28712
  PyObject *resultobj = 0;
 
28713
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28714
  int result;
 
28715
  void *argp1 = 0 ;
 
28716
  int res1 = 0 ;
 
28717
  PyObject *swig_obj[1] ;
 
28718
  
 
28719
  if (!args) SWIG_fail;
 
28720
  swig_obj[0] = args;
 
28721
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28722
  if (!SWIG_IsOK(res1)) {
 
28723
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_code_get" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28724
  }
 
28725
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28726
  result = (int) ((arg1)->m_code);
 
28727
  resultobj = SWIG_From_int(static_cast< int >(result));
 
28728
  return resultobj;
 
28729
fail:
 
28730
  return NULL;
 
28731
}
 
28732
 
 
28733
 
 
28734
SWIGINTERN PyObject *_wrap_ListEvent_m_oldItemIndex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28735
  PyObject *resultobj = 0;
 
28736
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28737
  long arg2 ;
 
28738
  void *argp1 = 0 ;
 
28739
  int res1 = 0 ;
 
28740
  long val2 ;
 
28741
  int ecode2 = 0 ;
 
28742
  PyObject *swig_obj[2] ;
 
28743
  
 
28744
  if (!SWIG_Python_UnpackTuple(args,"ListEvent_m_oldItemIndex_set",2,2,swig_obj)) SWIG_fail;
 
28745
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28746
  if (!SWIG_IsOK(res1)) {
 
28747
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_oldItemIndex_set" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28748
  }
 
28749
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28750
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
 
28751
  if (!SWIG_IsOK(ecode2)) {
 
28752
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListEvent_m_oldItemIndex_set" "', expected argument " "2"" of type '" "long""'");
 
28753
  } 
 
28754
  arg2 = static_cast< long >(val2);
 
28755
  if (arg1) (arg1)->m_oldItemIndex = arg2;
 
28756
  
 
28757
  resultobj = SWIG_Py_Void();
 
28758
  return resultobj;
 
28759
fail:
 
28760
  return NULL;
 
28761
}
 
28762
 
 
28763
 
 
28764
SWIGINTERN PyObject *_wrap_ListEvent_m_oldItemIndex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28765
  PyObject *resultobj = 0;
 
28766
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28767
  long result;
 
28768
  void *argp1 = 0 ;
 
28769
  int res1 = 0 ;
 
28770
  PyObject *swig_obj[1] ;
 
28771
  
 
28772
  if (!args) SWIG_fail;
 
28773
  swig_obj[0] = args;
 
28774
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28775
  if (!SWIG_IsOK(res1)) {
 
28776
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_oldItemIndex_get" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28777
  }
 
28778
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28779
  result = (long) ((arg1)->m_oldItemIndex);
 
28780
  resultobj = SWIG_From_long(static_cast< long >(result));
 
28781
  return resultobj;
 
28782
fail:
 
28783
  return NULL;
 
28784
}
 
28785
 
 
28786
 
 
28787
SWIGINTERN PyObject *_wrap_ListEvent_m_itemIndex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28788
  PyObject *resultobj = 0;
 
28789
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28790
  long arg2 ;
 
28791
  void *argp1 = 0 ;
 
28792
  int res1 = 0 ;
 
28793
  long val2 ;
 
28794
  int ecode2 = 0 ;
 
28795
  PyObject *swig_obj[2] ;
 
28796
  
 
28797
  if (!SWIG_Python_UnpackTuple(args,"ListEvent_m_itemIndex_set",2,2,swig_obj)) SWIG_fail;
 
28798
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28799
  if (!SWIG_IsOK(res1)) {
 
28800
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_itemIndex_set" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28801
  }
 
28802
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28803
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
 
28804
  if (!SWIG_IsOK(ecode2)) {
 
28805
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListEvent_m_itemIndex_set" "', expected argument " "2"" of type '" "long""'");
 
28806
  } 
 
28807
  arg2 = static_cast< long >(val2);
 
28808
  if (arg1) (arg1)->m_itemIndex = arg2;
 
28809
  
 
28810
  resultobj = SWIG_Py_Void();
 
28811
  return resultobj;
 
28812
fail:
 
28813
  return NULL;
 
28814
}
 
28815
 
 
28816
 
 
28817
SWIGINTERN PyObject *_wrap_ListEvent_m_itemIndex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28818
  PyObject *resultobj = 0;
 
28819
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28820
  long result;
 
28821
  void *argp1 = 0 ;
 
28822
  int res1 = 0 ;
 
28823
  PyObject *swig_obj[1] ;
 
28824
  
 
28825
  if (!args) SWIG_fail;
 
28826
  swig_obj[0] = args;
 
28827
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28828
  if (!SWIG_IsOK(res1)) {
 
28829
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_itemIndex_get" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28830
  }
 
28831
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28832
  result = (long) ((arg1)->m_itemIndex);
 
28833
  resultobj = SWIG_From_long(static_cast< long >(result));
 
28834
  return resultobj;
 
28835
fail:
 
28836
  return NULL;
 
28837
}
 
28838
 
 
28839
 
 
28840
SWIGINTERN PyObject *_wrap_ListEvent_m_col_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28841
  PyObject *resultobj = 0;
 
28842
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28843
  int arg2 ;
 
28844
  void *argp1 = 0 ;
 
28845
  int res1 = 0 ;
 
28846
  int val2 ;
 
28847
  int ecode2 = 0 ;
 
28848
  PyObject *swig_obj[2] ;
 
28849
  
 
28850
  if (!SWIG_Python_UnpackTuple(args,"ListEvent_m_col_set",2,2,swig_obj)) SWIG_fail;
 
28851
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28852
  if (!SWIG_IsOK(res1)) {
 
28853
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_col_set" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28854
  }
 
28855
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28856
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
 
28857
  if (!SWIG_IsOK(ecode2)) {
 
28858
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListEvent_m_col_set" "', expected argument " "2"" of type '" "int""'");
 
28859
  } 
 
28860
  arg2 = static_cast< int >(val2);
 
28861
  if (arg1) (arg1)->m_col = arg2;
 
28862
  
 
28863
  resultobj = SWIG_Py_Void();
 
28864
  return resultobj;
 
28865
fail:
 
28866
  return NULL;
 
28867
}
 
28868
 
 
28869
 
 
28870
SWIGINTERN PyObject *_wrap_ListEvent_m_col_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28871
  PyObject *resultobj = 0;
 
28872
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28873
  int result;
 
28874
  void *argp1 = 0 ;
 
28875
  int res1 = 0 ;
 
28876
  PyObject *swig_obj[1] ;
 
28877
  
 
28878
  if (!args) SWIG_fail;
 
28879
  swig_obj[0] = args;
 
28880
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28881
  if (!SWIG_IsOK(res1)) {
 
28882
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_col_get" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28883
  }
 
28884
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28885
  result = (int) ((arg1)->m_col);
 
28886
  resultobj = SWIG_From_int(static_cast< int >(result));
 
28887
  return resultobj;
 
28888
fail:
 
28889
  return NULL;
 
28890
}
 
28891
 
 
28892
 
 
28893
SWIGINTERN PyObject *_wrap_ListEvent_m_pointDrag_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28894
  PyObject *resultobj = 0;
 
28895
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28896
  wxPoint *arg2 = (wxPoint *) 0 ;
 
28897
  void *argp1 = 0 ;
 
28898
  int res1 = 0 ;
 
28899
  void *argp2 = 0 ;
 
28900
  int res2 = 0 ;
 
28901
  PyObject *swig_obj[2] ;
 
28902
  
 
28903
  if (!SWIG_Python_UnpackTuple(args,"ListEvent_m_pointDrag_set",2,2,swig_obj)) SWIG_fail;
 
28904
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28905
  if (!SWIG_IsOK(res1)) {
 
28906
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_pointDrag_set" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28907
  }
 
28908
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28909
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxPoint, 0 |  0 );
 
28910
  if (!SWIG_IsOK(res2)) {
 
28911
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListEvent_m_pointDrag_set" "', expected argument " "2"" of type '" "wxPoint *""'"); 
 
28912
  }
 
28913
  arg2 = reinterpret_cast< wxPoint * >(argp2);
 
28914
  if (arg1) (arg1)->m_pointDrag = *arg2;
 
28915
  
 
28916
  resultobj = SWIG_Py_Void();
 
28917
  return resultobj;
 
28918
fail:
 
28919
  return NULL;
 
28920
}
 
28921
 
 
28922
 
 
28923
SWIGINTERN PyObject *_wrap_ListEvent_m_pointDrag_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28924
  PyObject *resultobj = 0;
 
28925
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28926
  wxPoint *result = 0 ;
 
28927
  void *argp1 = 0 ;
 
28928
  int res1 = 0 ;
 
28929
  PyObject *swig_obj[1] ;
 
28930
  
 
28931
  if (!args) SWIG_fail;
 
28932
  swig_obj[0] = args;
 
28933
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28934
  if (!SWIG_IsOK(res1)) {
 
28935
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_pointDrag_get" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28936
  }
 
28937
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28938
  result = (wxPoint *)& ((arg1)->m_pointDrag);
 
28939
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 |  0 );
 
28940
  return resultobj;
 
28941
fail:
 
28942
  return NULL;
 
28943
}
 
28944
 
 
28945
 
 
28946
SWIGINTERN PyObject *_wrap_ListEvent_m_item_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28947
  PyObject *resultobj = 0;
 
28948
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28949
  wxListItem *result = 0 ;
 
28950
  void *argp1 = 0 ;
 
28951
  int res1 = 0 ;
 
28952
  PyObject *swig_obj[1] ;
 
28953
  
 
28954
  if (!args) SWIG_fail;
 
28955
  swig_obj[0] = args;
 
28956
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28957
  if (!SWIG_IsOK(res1)) {
 
28958
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_m_item_get" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28959
  }
 
28960
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28961
  result = (wxListItem *)& ((arg1)->m_item);
 
28962
  {
 
28963
    resultobj = wxPyMake_wxObject(result, 0); 
 
28964
  }
 
28965
  return resultobj;
 
28966
fail:
 
28967
  return NULL;
 
28968
}
 
28969
 
 
28970
 
 
28971
SWIGINTERN PyObject *_wrap_ListEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
28972
  PyObject *resultobj = 0;
 
28973
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
28974
  int result;
 
28975
  void *argp1 = 0 ;
 
28976
  int res1 = 0 ;
 
28977
  PyObject *swig_obj[1] ;
 
28978
  
 
28979
  if (!args) SWIG_fail;
 
28980
  swig_obj[0] = args;
 
28981
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
28982
  if (!SWIG_IsOK(res1)) {
 
28983
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
28984
  }
 
28985
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
28986
  {
 
28987
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
28988
    result = (int)(arg1)->GetKeyCode();
 
28989
    wxPyEndAllowThreads(__tstate);
 
28990
    if (PyErr_Occurred()) SWIG_fail;
 
28991
  }
 
28992
  resultobj = SWIG_From_int(static_cast< int >(result));
 
28993
  return resultobj;
 
28994
fail:
 
28995
  return NULL;
 
28996
}
 
28997
 
 
28998
 
 
28999
SWIGINTERN PyObject *_wrap_ListEvent_GetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29000
  PyObject *resultobj = 0;
 
29001
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29002
  long result;
 
29003
  void *argp1 = 0 ;
 
29004
  int res1 = 0 ;
 
29005
  PyObject *swig_obj[1] ;
 
29006
  
 
29007
  if (!args) SWIG_fail;
 
29008
  swig_obj[0] = args;
 
29009
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29010
  if (!SWIG_IsOK(res1)) {
 
29011
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetIndex" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29012
  }
 
29013
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29014
  {
 
29015
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29016
    result = (long)(arg1)->GetIndex();
 
29017
    wxPyEndAllowThreads(__tstate);
 
29018
    if (PyErr_Occurred()) SWIG_fail;
 
29019
  }
 
29020
  resultobj = SWIG_From_long(static_cast< long >(result));
 
29021
  return resultobj;
 
29022
fail:
 
29023
  return NULL;
 
29024
}
 
29025
 
 
29026
 
 
29027
SWIGINTERN PyObject *_wrap_ListEvent_GetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29028
  PyObject *resultobj = 0;
 
29029
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29030
  int result;
 
29031
  void *argp1 = 0 ;
 
29032
  int res1 = 0 ;
 
29033
  PyObject *swig_obj[1] ;
 
29034
  
 
29035
  if (!args) SWIG_fail;
 
29036
  swig_obj[0] = args;
 
29037
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29038
  if (!SWIG_IsOK(res1)) {
 
29039
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetColumn" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29040
  }
 
29041
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29042
  {
 
29043
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29044
    result = (int)(arg1)->GetColumn();
 
29045
    wxPyEndAllowThreads(__tstate);
 
29046
    if (PyErr_Occurred()) SWIG_fail;
 
29047
  }
 
29048
  resultobj = SWIG_From_int(static_cast< int >(result));
 
29049
  return resultobj;
 
29050
fail:
 
29051
  return NULL;
 
29052
}
 
29053
 
 
29054
 
 
29055
SWIGINTERN PyObject *_wrap_ListEvent_GetPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29056
  PyObject *resultobj = 0;
 
29057
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29058
  wxPoint result;
 
29059
  void *argp1 = 0 ;
 
29060
  int res1 = 0 ;
 
29061
  PyObject *swig_obj[1] ;
 
29062
  
 
29063
  if (!args) SWIG_fail;
 
29064
  swig_obj[0] = args;
 
29065
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29066
  if (!SWIG_IsOK(res1)) {
 
29067
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetPoint" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29068
  }
 
29069
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29070
  {
 
29071
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29072
    result = (arg1)->GetPoint();
 
29073
    wxPyEndAllowThreads(__tstate);
 
29074
    if (PyErr_Occurred()) SWIG_fail;
 
29075
  }
 
29076
  resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN |  0 );
 
29077
  return resultobj;
 
29078
fail:
 
29079
  return NULL;
 
29080
}
 
29081
 
 
29082
 
 
29083
SWIGINTERN PyObject *_wrap_ListEvent_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29084
  PyObject *resultobj = 0;
 
29085
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29086
  wxString *result = 0 ;
 
29087
  void *argp1 = 0 ;
 
29088
  int res1 = 0 ;
 
29089
  PyObject *swig_obj[1] ;
 
29090
  
 
29091
  if (!args) SWIG_fail;
 
29092
  swig_obj[0] = args;
 
29093
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29094
  if (!SWIG_IsOK(res1)) {
 
29095
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetLabel" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29096
  }
 
29097
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29098
  {
 
29099
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29100
    {
 
29101
      wxString const &_result_ref = (arg1)->GetLabel();
 
29102
      result = (wxString *) &_result_ref;
 
29103
    }
 
29104
    wxPyEndAllowThreads(__tstate);
 
29105
    if (PyErr_Occurred()) SWIG_fail;
 
29106
  }
 
29107
  {
 
29108
#if wxUSE_UNICODE
 
29109
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
29110
#else
 
29111
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
29112
#endif
 
29113
  }
 
29114
  return resultobj;
 
29115
fail:
 
29116
  return NULL;
 
29117
}
 
29118
 
 
29119
 
 
29120
SWIGINTERN PyObject *_wrap_ListEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29121
  PyObject *resultobj = 0;
 
29122
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29123
  wxString *result = 0 ;
 
29124
  void *argp1 = 0 ;
 
29125
  int res1 = 0 ;
 
29126
  PyObject *swig_obj[1] ;
 
29127
  
 
29128
  if (!args) SWIG_fail;
 
29129
  swig_obj[0] = args;
 
29130
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29131
  if (!SWIG_IsOK(res1)) {
 
29132
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetText" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29133
  }
 
29134
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29135
  {
 
29136
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29137
    {
 
29138
      wxString const &_result_ref = (arg1)->GetText();
 
29139
      result = (wxString *) &_result_ref;
 
29140
    }
 
29141
    wxPyEndAllowThreads(__tstate);
 
29142
    if (PyErr_Occurred()) SWIG_fail;
 
29143
  }
 
29144
  {
 
29145
#if wxUSE_UNICODE
 
29146
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
29147
#else
 
29148
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
29149
#endif
 
29150
  }
 
29151
  return resultobj;
 
29152
fail:
 
29153
  return NULL;
 
29154
}
 
29155
 
 
29156
 
 
29157
SWIGINTERN PyObject *_wrap_ListEvent_GetImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29158
  PyObject *resultobj = 0;
 
29159
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29160
  int result;
 
29161
  void *argp1 = 0 ;
 
29162
  int res1 = 0 ;
 
29163
  PyObject *swig_obj[1] ;
 
29164
  
 
29165
  if (!args) SWIG_fail;
 
29166
  swig_obj[0] = args;
 
29167
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29168
  if (!SWIG_IsOK(res1)) {
 
29169
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetImage" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29170
  }
 
29171
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29172
  {
 
29173
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29174
    result = (int)(arg1)->GetImage();
 
29175
    wxPyEndAllowThreads(__tstate);
 
29176
    if (PyErr_Occurred()) SWIG_fail;
 
29177
  }
 
29178
  resultobj = SWIG_From_int(static_cast< int >(result));
 
29179
  return resultobj;
 
29180
fail:
 
29181
  return NULL;
 
29182
}
 
29183
 
 
29184
 
 
29185
SWIGINTERN PyObject *_wrap_ListEvent_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29186
  PyObject *resultobj = 0;
 
29187
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29188
  long result;
 
29189
  void *argp1 = 0 ;
 
29190
  int res1 = 0 ;
 
29191
  PyObject *swig_obj[1] ;
 
29192
  
 
29193
  if (!args) SWIG_fail;
 
29194
  swig_obj[0] = args;
 
29195
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29196
  if (!SWIG_IsOK(res1)) {
 
29197
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetData" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29198
  }
 
29199
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29200
  {
 
29201
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29202
    result = (long)(arg1)->GetData();
 
29203
    wxPyEndAllowThreads(__tstate);
 
29204
    if (PyErr_Occurred()) SWIG_fail;
 
29205
  }
 
29206
  resultobj = SWIG_From_long(static_cast< long >(result));
 
29207
  return resultobj;
 
29208
fail:
 
29209
  return NULL;
 
29210
}
 
29211
 
 
29212
 
 
29213
SWIGINTERN PyObject *_wrap_ListEvent_GetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29214
  PyObject *resultobj = 0;
 
29215
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29216
  long result;
 
29217
  void *argp1 = 0 ;
 
29218
  int res1 = 0 ;
 
29219
  PyObject *swig_obj[1] ;
 
29220
  
 
29221
  if (!args) SWIG_fail;
 
29222
  swig_obj[0] = args;
 
29223
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29224
  if (!SWIG_IsOK(res1)) {
 
29225
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetMask" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29226
  }
 
29227
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29228
  {
 
29229
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29230
    result = (long)(arg1)->GetMask();
 
29231
    wxPyEndAllowThreads(__tstate);
 
29232
    if (PyErr_Occurred()) SWIG_fail;
 
29233
  }
 
29234
  resultobj = SWIG_From_long(static_cast< long >(result));
 
29235
  return resultobj;
 
29236
fail:
 
29237
  return NULL;
 
29238
}
 
29239
 
 
29240
 
 
29241
SWIGINTERN PyObject *_wrap_ListEvent_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29242
  PyObject *resultobj = 0;
 
29243
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29244
  wxListItem *result = 0 ;
 
29245
  void *argp1 = 0 ;
 
29246
  int res1 = 0 ;
 
29247
  PyObject *swig_obj[1] ;
 
29248
  
 
29249
  if (!args) SWIG_fail;
 
29250
  swig_obj[0] = args;
 
29251
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29252
  if (!SWIG_IsOK(res1)) {
 
29253
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetItem" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29254
  }
 
29255
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29256
  {
 
29257
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29258
    {
 
29259
      wxListItem const &_result_ref = (arg1)->GetItem();
 
29260
      result = (wxListItem *) &_result_ref;
 
29261
    }
 
29262
    wxPyEndAllowThreads(__tstate);
 
29263
    if (PyErr_Occurred()) SWIG_fail;
 
29264
  }
 
29265
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListItem, 0 |  0 );
 
29266
  return resultobj;
 
29267
fail:
 
29268
  return NULL;
 
29269
}
 
29270
 
 
29271
 
 
29272
SWIGINTERN PyObject *_wrap_ListEvent_GetCacheFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29273
  PyObject *resultobj = 0;
 
29274
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29275
  long result;
 
29276
  void *argp1 = 0 ;
 
29277
  int res1 = 0 ;
 
29278
  PyObject *swig_obj[1] ;
 
29279
  
 
29280
  if (!args) SWIG_fail;
 
29281
  swig_obj[0] = args;
 
29282
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29283
  if (!SWIG_IsOK(res1)) {
 
29284
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetCacheFrom" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29285
  }
 
29286
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29287
  {
 
29288
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29289
    result = (long)(arg1)->GetCacheFrom();
 
29290
    wxPyEndAllowThreads(__tstate);
 
29291
    if (PyErr_Occurred()) SWIG_fail;
 
29292
  }
 
29293
  resultobj = SWIG_From_long(static_cast< long >(result));
 
29294
  return resultobj;
 
29295
fail:
 
29296
  return NULL;
 
29297
}
 
29298
 
 
29299
 
 
29300
SWIGINTERN PyObject *_wrap_ListEvent_GetCacheTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29301
  PyObject *resultobj = 0;
 
29302
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29303
  long result;
 
29304
  void *argp1 = 0 ;
 
29305
  int res1 = 0 ;
 
29306
  PyObject *swig_obj[1] ;
 
29307
  
 
29308
  if (!args) SWIG_fail;
 
29309
  swig_obj[0] = args;
 
29310
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29311
  if (!SWIG_IsOK(res1)) {
 
29312
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_GetCacheTo" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29313
  }
 
29314
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29315
  {
 
29316
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29317
    result = (long)(arg1)->GetCacheTo();
 
29318
    wxPyEndAllowThreads(__tstate);
 
29319
    if (PyErr_Occurred()) SWIG_fail;
 
29320
  }
 
29321
  resultobj = SWIG_From_long(static_cast< long >(result));
 
29322
  return resultobj;
 
29323
fail:
 
29324
  return NULL;
 
29325
}
 
29326
 
 
29327
 
 
29328
SWIGINTERN PyObject *_wrap_ListEvent_IsEditCancelled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29329
  PyObject *resultobj = 0;
 
29330
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29331
  bool result;
 
29332
  void *argp1 = 0 ;
 
29333
  int res1 = 0 ;
 
29334
  PyObject *swig_obj[1] ;
 
29335
  
 
29336
  if (!args) SWIG_fail;
 
29337
  swig_obj[0] = args;
 
29338
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29339
  if (!SWIG_IsOK(res1)) {
 
29340
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_IsEditCancelled" "', expected argument " "1"" of type '" "wxListEvent const *""'"); 
 
29341
  }
 
29342
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29343
  {
 
29344
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29345
    result = (bool)((wxListEvent const *)arg1)->IsEditCancelled();
 
29346
    wxPyEndAllowThreads(__tstate);
 
29347
    if (PyErr_Occurred()) SWIG_fail;
 
29348
  }
 
29349
  {
 
29350
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
29351
  }
 
29352
  return resultobj;
 
29353
fail:
 
29354
  return NULL;
 
29355
}
 
29356
 
 
29357
 
 
29358
SWIGINTERN PyObject *_wrap_ListEvent_SetEditCanceled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29359
  PyObject *resultobj = 0;
 
29360
  wxListEvent *arg1 = (wxListEvent *) 0 ;
 
29361
  bool arg2 ;
 
29362
  void *argp1 = 0 ;
 
29363
  int res1 = 0 ;
 
29364
  bool val2 ;
 
29365
  int ecode2 = 0 ;
 
29366
  PyObject * obj0 = 0 ;
 
29367
  PyObject * obj1 = 0 ;
 
29368
  char *  kwnames[] = {
 
29369
    (char *) "self",(char *) "editCancelled", NULL 
 
29370
  };
 
29371
  
 
29372
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListEvent_SetEditCanceled",kwnames,&obj0,&obj1)) SWIG_fail;
 
29373
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListEvent, 0 |  0 );
 
29374
  if (!SWIG_IsOK(res1)) {
 
29375
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListEvent_SetEditCanceled" "', expected argument " "1"" of type '" "wxListEvent *""'"); 
 
29376
  }
 
29377
  arg1 = reinterpret_cast< wxListEvent * >(argp1);
 
29378
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
29379
  if (!SWIG_IsOK(ecode2)) {
 
29380
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListEvent_SetEditCanceled" "', expected argument " "2"" of type '" "bool""'");
 
29381
  } 
 
29382
  arg2 = static_cast< bool >(val2);
 
29383
  {
 
29384
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29385
    (arg1)->SetEditCanceled(arg2);
 
29386
    wxPyEndAllowThreads(__tstate);
 
29387
    if (PyErr_Occurred()) SWIG_fail;
 
29388
  }
 
29389
  resultobj = SWIG_Py_Void();
 
29390
  return resultobj;
 
29391
fail:
 
29392
  return NULL;
 
29393
}
 
29394
 
 
29395
 
 
29396
SWIGINTERN PyObject *ListEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29397
  PyObject *obj;
 
29398
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
29399
  SWIG_TypeNewClientData(SWIGTYPE_p_wxListEvent, SWIG_NewClientData(obj));
 
29400
  return SWIG_Py_Void();
 
29401
}
 
29402
 
 
29403
SWIGINTERN PyObject *ListEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29404
  return SWIG_Python_InitShadowInstance(args);
 
29405
}
 
29406
 
 
29407
SWIGINTERN PyObject *_wrap_new_ListCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29408
  PyObject *resultobj = 0;
 
29409
  wxWindow *arg1 = (wxWindow *) 0 ;
 
29410
  int arg2 = (int) -1 ;
 
29411
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
29412
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
29413
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
29414
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
29415
  long arg5 = (long) wxLC_ICON ;
 
29416
  wxValidator const &arg6_defvalue = wxDefaultValidator ;
 
29417
  wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
 
29418
  wxString const &arg7_defvalue = wxPyListCtrlNameStr ;
 
29419
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
29420
  wxPyListCtrl *result = 0 ;
 
29421
  void *argp1 = 0 ;
 
29422
  int res1 = 0 ;
 
29423
  int val2 ;
 
29424
  int ecode2 = 0 ;
 
29425
  wxPoint temp3 ;
 
29426
  wxSize temp4 ;
 
29427
  long val5 ;
 
29428
  int ecode5 = 0 ;
 
29429
  void *argp6 = 0 ;
 
29430
  int res6 = 0 ;
 
29431
  bool temp7 = false ;
 
29432
  PyObject * obj0 = 0 ;
 
29433
  PyObject * obj1 = 0 ;
 
29434
  PyObject * obj2 = 0 ;
 
29435
  PyObject * obj3 = 0 ;
 
29436
  PyObject * obj4 = 0 ;
 
29437
  PyObject * obj5 = 0 ;
 
29438
  PyObject * obj6 = 0 ;
 
29439
  char *  kwnames[] = {
 
29440
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
29441
  };
 
29442
  
 
29443
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_ListCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
29444
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
29445
  if (!SWIG_IsOK(res1)) {
 
29446
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
29447
  }
 
29448
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
29449
  if (obj1) {
 
29450
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
29451
    if (!SWIG_IsOK(ecode2)) {
 
29452
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListCtrl" "', expected argument " "2"" of type '" "int""'");
 
29453
    } 
 
29454
    arg2 = static_cast< int >(val2);
 
29455
  }
 
29456
  if (obj2) {
 
29457
    {
 
29458
      arg3 = &temp3;
 
29459
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
29460
    }
 
29461
  }
 
29462
  if (obj3) {
 
29463
    {
 
29464
      arg4 = &temp4;
 
29465
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
29466
    }
 
29467
  }
 
29468
  if (obj4) {
 
29469
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
29470
    if (!SWIG_IsOK(ecode5)) {
 
29471
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ListCtrl" "', expected argument " "5"" of type '" "long""'");
 
29472
    } 
 
29473
    arg5 = static_cast< long >(val5);
 
29474
  }
 
29475
  if (obj5) {
 
29476
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator,  0  | 0);
 
29477
    if (!SWIG_IsOK(res6)) {
 
29478
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ListCtrl" "', expected argument " "6"" of type '" "wxValidator const &""'"); 
 
29479
    }
 
29480
    if (!argp6) {
 
29481
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListCtrl" "', expected argument " "6"" of type '" "wxValidator const &""'"); 
 
29482
    }
 
29483
    arg6 = reinterpret_cast< wxValidator * >(argp6);
 
29484
  }
 
29485
  if (obj6) {
 
29486
    {
 
29487
      arg7 = wxString_in_helper(obj6);
 
29488
      if (arg7 == NULL) SWIG_fail;
 
29489
      temp7 = true;
 
29490
    }
 
29491
  }
 
29492
  {
 
29493
    if (!wxPyCheckForApp()) SWIG_fail;
 
29494
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29495
    result = (wxPyListCtrl *)new wxPyListCtrl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
 
29496
    wxPyEndAllowThreads(__tstate);
 
29497
    if (PyErr_Occurred()) SWIG_fail;
 
29498
  }
 
29499
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_NEW |  0 );
 
29500
  {
 
29501
    if (temp7)
 
29502
    delete arg7;
 
29503
  }
 
29504
  return resultobj;
 
29505
fail:
 
29506
  {
 
29507
    if (temp7)
 
29508
    delete arg7;
 
29509
  }
 
29510
  return NULL;
 
29511
}
 
29512
 
 
29513
 
 
29514
SWIGINTERN PyObject *_wrap_new_PreListCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29515
  PyObject *resultobj = 0;
 
29516
  wxPyListCtrl *result = 0 ;
 
29517
  
 
29518
  if (!SWIG_Python_UnpackTuple(args,"new_PreListCtrl",0,0,0)) SWIG_fail;
 
29519
  {
 
29520
    if (!wxPyCheckForApp()) SWIG_fail;
 
29521
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29522
    result = (wxPyListCtrl *)new wxPyListCtrl();
 
29523
    wxPyEndAllowThreads(__tstate);
 
29524
    if (PyErr_Occurred()) SWIG_fail;
 
29525
  }
 
29526
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyListCtrl, SWIG_POINTER_OWN |  0 );
 
29527
  return resultobj;
 
29528
fail:
 
29529
  return NULL;
 
29530
}
 
29531
 
 
29532
 
 
29533
SWIGINTERN PyObject *_wrap_ListCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29534
  PyObject *resultobj = 0;
 
29535
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
29536
  wxWindow *arg2 = (wxWindow *) 0 ;
 
29537
  int arg3 = (int) -1 ;
 
29538
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
29539
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
29540
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
29541
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
29542
  long arg6 = (long) wxLC_ICON ;
 
29543
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
29544
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
29545
  wxString const &arg8_defvalue = wxPyListCtrlNameStr ;
 
29546
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
29547
  bool result;
 
29548
  void *argp1 = 0 ;
 
29549
  int res1 = 0 ;
 
29550
  void *argp2 = 0 ;
 
29551
  int res2 = 0 ;
 
29552
  int val3 ;
 
29553
  int ecode3 = 0 ;
 
29554
  wxPoint temp4 ;
 
29555
  wxSize temp5 ;
 
29556
  long val6 ;
 
29557
  int ecode6 = 0 ;
 
29558
  void *argp7 = 0 ;
 
29559
  int res7 = 0 ;
 
29560
  bool temp8 = false ;
 
29561
  PyObject * obj0 = 0 ;
 
29562
  PyObject * obj1 = 0 ;
 
29563
  PyObject * obj2 = 0 ;
 
29564
  PyObject * obj3 = 0 ;
 
29565
  PyObject * obj4 = 0 ;
 
29566
  PyObject * obj5 = 0 ;
 
29567
  PyObject * obj6 = 0 ;
 
29568
  PyObject * obj7 = 0 ;
 
29569
  char *  kwnames[] = {
 
29570
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
29571
  };
 
29572
  
 
29573
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:ListCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
29574
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
29575
  if (!SWIG_IsOK(res1)) {
 
29576
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_Create" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
29577
  }
 
29578
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
29579
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
29580
  if (!SWIG_IsOK(res2)) {
 
29581
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
29582
  }
 
29583
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
29584
  if (obj2) {
 
29585
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
29586
    if (!SWIG_IsOK(ecode3)) {
 
29587
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
29588
    } 
 
29589
    arg3 = static_cast< int >(val3);
 
29590
  }
 
29591
  if (obj3) {
 
29592
    {
 
29593
      arg4 = &temp4;
 
29594
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
29595
    }
 
29596
  }
 
29597
  if (obj4) {
 
29598
    {
 
29599
      arg5 = &temp5;
 
29600
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
29601
    }
 
29602
  }
 
29603
  if (obj5) {
 
29604
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
29605
    if (!SWIG_IsOK(ecode6)) {
 
29606
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ListCtrl_Create" "', expected argument " "6"" of type '" "long""'");
 
29607
    } 
 
29608
    arg6 = static_cast< long >(val6);
 
29609
  }
 
29610
  if (obj6) {
 
29611
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
29612
    if (!SWIG_IsOK(res7)) {
 
29613
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ListCtrl_Create" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
29614
    }
 
29615
    if (!argp7) {
 
29616
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListCtrl_Create" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
29617
    }
 
29618
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
29619
  }
 
29620
  if (obj7) {
 
29621
    {
 
29622
      arg8 = wxString_in_helper(obj7);
 
29623
      if (arg8 == NULL) SWIG_fail;
 
29624
      temp8 = true;
 
29625
    }
 
29626
  }
 
29627
  {
 
29628
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29629
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
29630
    wxPyEndAllowThreads(__tstate);
 
29631
    if (PyErr_Occurred()) SWIG_fail;
 
29632
  }
 
29633
  {
 
29634
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
29635
  }
 
29636
  {
 
29637
    if (temp8)
 
29638
    delete arg8;
 
29639
  }
 
29640
  return resultobj;
 
29641
fail:
 
29642
  {
 
29643
    if (temp8)
 
29644
    delete arg8;
 
29645
  }
 
29646
  return NULL;
 
29647
}
 
29648
 
 
29649
 
 
29650
SWIGINTERN PyObject *_wrap_ListCtrl__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29651
  PyObject *resultobj = 0;
 
29652
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
29653
  PyObject *arg2 = (PyObject *) 0 ;
 
29654
  PyObject *arg3 = (PyObject *) 0 ;
 
29655
  void *argp1 = 0 ;
 
29656
  int res1 = 0 ;
 
29657
  PyObject * obj0 = 0 ;
 
29658
  PyObject * obj1 = 0 ;
 
29659
  PyObject * obj2 = 0 ;
 
29660
  char *  kwnames[] = {
 
29661
    (char *) "self",(char *) "self",(char *) "_class", NULL 
 
29662
  };
 
29663
  
 
29664
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
29665
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
29666
  if (!SWIG_IsOK(res1)) {
 
29667
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
29668
  }
 
29669
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
29670
  arg2 = obj1;
 
29671
  arg3 = obj2;
 
29672
  {
 
29673
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29674
    (arg1)->_setCallbackInfo(arg2,arg3);
 
29675
    wxPyEndAllowThreads(__tstate);
 
29676
    if (PyErr_Occurred()) SWIG_fail;
 
29677
  }
 
29678
  resultobj = SWIG_Py_Void();
 
29679
  return resultobj;
 
29680
fail:
 
29681
  return NULL;
 
29682
}
 
29683
 
 
29684
 
 
29685
SWIGINTERN PyObject *_wrap_ListCtrl_GetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29686
  PyObject *resultobj = 0;
 
29687
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
29688
  int arg2 ;
 
29689
  wxListItem *result = 0 ;
 
29690
  void *argp1 = 0 ;
 
29691
  int res1 = 0 ;
 
29692
  int val2 ;
 
29693
  int ecode2 = 0 ;
 
29694
  PyObject * obj0 = 0 ;
 
29695
  PyObject * obj1 = 0 ;
 
29696
  char *  kwnames[] = {
 
29697
    (char *) "self",(char *) "col", NULL 
 
29698
  };
 
29699
  
 
29700
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetColumn",kwnames,&obj0,&obj1)) SWIG_fail;
 
29701
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
29702
  if (!SWIG_IsOK(res1)) {
 
29703
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetColumn" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
29704
  }
 
29705
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
29706
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
29707
  if (!SWIG_IsOK(ecode2)) {
 
29708
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetColumn" "', expected argument " "2"" of type '" "int""'");
 
29709
  } 
 
29710
  arg2 = static_cast< int >(val2);
 
29711
  {
 
29712
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29713
    result = (wxListItem *)wxPyListCtrl_GetColumn(arg1,arg2);
 
29714
    wxPyEndAllowThreads(__tstate);
 
29715
    if (PyErr_Occurred()) SWIG_fail;
 
29716
  }
 
29717
  {
 
29718
    resultobj = wxPyMake_wxObject(result, 0); 
 
29719
  }
 
29720
  return resultobj;
 
29721
fail:
 
29722
  return NULL;
 
29723
}
 
29724
 
 
29725
 
 
29726
SWIGINTERN PyObject *_wrap_ListCtrl_SetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29727
  PyObject *resultobj = 0;
 
29728
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
29729
  int arg2 ;
 
29730
  wxListItem *arg3 = 0 ;
 
29731
  bool result;
 
29732
  void *argp1 = 0 ;
 
29733
  int res1 = 0 ;
 
29734
  int val2 ;
 
29735
  int ecode2 = 0 ;
 
29736
  void *argp3 = 0 ;
 
29737
  int res3 = 0 ;
 
29738
  PyObject * obj0 = 0 ;
 
29739
  PyObject * obj1 = 0 ;
 
29740
  PyObject * obj2 = 0 ;
 
29741
  char *  kwnames[] = {
 
29742
    (char *) "self",(char *) "col",(char *) "item", NULL 
 
29743
  };
 
29744
  
 
29745
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
29746
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
29747
  if (!SWIG_IsOK(res1)) {
 
29748
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetColumn" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
29749
  }
 
29750
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
29751
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
29752
  if (!SWIG_IsOK(ecode2)) {
 
29753
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetColumn" "', expected argument " "2"" of type '" "int""'");
 
29754
  } 
 
29755
  arg2 = static_cast< int >(val2);
 
29756
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxListItem,  0 );
 
29757
  if (!SWIG_IsOK(res3)) {
 
29758
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ListCtrl_SetColumn" "', expected argument " "3"" of type '" "wxListItem &""'"); 
 
29759
  }
 
29760
  if (!argp3) {
 
29761
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListCtrl_SetColumn" "', expected argument " "3"" of type '" "wxListItem &""'"); 
 
29762
  }
 
29763
  arg3 = reinterpret_cast< wxListItem * >(argp3);
 
29764
  {
 
29765
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29766
    result = (bool)(arg1)->SetColumn(arg2,*arg3);
 
29767
    wxPyEndAllowThreads(__tstate);
 
29768
    if (PyErr_Occurred()) SWIG_fail;
 
29769
  }
 
29770
  {
 
29771
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
29772
  }
 
29773
  return resultobj;
 
29774
fail:
 
29775
  return NULL;
 
29776
}
 
29777
 
 
29778
 
 
29779
SWIGINTERN PyObject *_wrap_ListCtrl_GetColumnWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29780
  PyObject *resultobj = 0;
 
29781
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
29782
  int arg2 ;
 
29783
  int result;
 
29784
  void *argp1 = 0 ;
 
29785
  int res1 = 0 ;
 
29786
  int val2 ;
 
29787
  int ecode2 = 0 ;
 
29788
  PyObject * obj0 = 0 ;
 
29789
  PyObject * obj1 = 0 ;
 
29790
  char *  kwnames[] = {
 
29791
    (char *) "self",(char *) "col", NULL 
 
29792
  };
 
29793
  
 
29794
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetColumnWidth",kwnames,&obj0,&obj1)) SWIG_fail;
 
29795
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
29796
  if (!SWIG_IsOK(res1)) {
 
29797
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetColumnWidth" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
29798
  }
 
29799
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
29800
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
29801
  if (!SWIG_IsOK(ecode2)) {
 
29802
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetColumnWidth" "', expected argument " "2"" of type '" "int""'");
 
29803
  } 
 
29804
  arg2 = static_cast< int >(val2);
 
29805
  {
 
29806
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29807
    result = (int)((wxPyListCtrl const *)arg1)->GetColumnWidth(arg2);
 
29808
    wxPyEndAllowThreads(__tstate);
 
29809
    if (PyErr_Occurred()) SWIG_fail;
 
29810
  }
 
29811
  resultobj = SWIG_From_int(static_cast< int >(result));
 
29812
  return resultobj;
 
29813
fail:
 
29814
  return NULL;
 
29815
}
 
29816
 
 
29817
 
 
29818
SWIGINTERN PyObject *_wrap_ListCtrl_SetColumnWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29819
  PyObject *resultobj = 0;
 
29820
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
29821
  int arg2 ;
 
29822
  int arg3 ;
 
29823
  bool result;
 
29824
  void *argp1 = 0 ;
 
29825
  int res1 = 0 ;
 
29826
  int val2 ;
 
29827
  int ecode2 = 0 ;
 
29828
  int val3 ;
 
29829
  int ecode3 = 0 ;
 
29830
  PyObject * obj0 = 0 ;
 
29831
  PyObject * obj1 = 0 ;
 
29832
  PyObject * obj2 = 0 ;
 
29833
  char *  kwnames[] = {
 
29834
    (char *) "self",(char *) "col",(char *) "width", NULL 
 
29835
  };
 
29836
  
 
29837
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetColumnWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
29838
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
29839
  if (!SWIG_IsOK(res1)) {
 
29840
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetColumnWidth" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
29841
  }
 
29842
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
29843
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
29844
  if (!SWIG_IsOK(ecode2)) {
 
29845
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetColumnWidth" "', expected argument " "2"" of type '" "int""'");
 
29846
  } 
 
29847
  arg2 = static_cast< int >(val2);
 
29848
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
29849
  if (!SWIG_IsOK(ecode3)) {
 
29850
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_SetColumnWidth" "', expected argument " "3"" of type '" "int""'");
 
29851
  } 
 
29852
  arg3 = static_cast< int >(val3);
 
29853
  {
 
29854
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29855
    result = (bool)(arg1)->SetColumnWidth(arg2,arg3);
 
29856
    wxPyEndAllowThreads(__tstate);
 
29857
    if (PyErr_Occurred()) SWIG_fail;
 
29858
  }
 
29859
  {
 
29860
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
29861
  }
 
29862
  return resultobj;
 
29863
fail:
 
29864
  return NULL;
 
29865
}
 
29866
 
 
29867
 
 
29868
SWIGINTERN PyObject *_wrap_ListCtrl_HasColumnOrderSupport(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29869
  PyObject *resultobj = 0;
 
29870
  bool result;
 
29871
  
 
29872
  if (!SWIG_Python_UnpackTuple(args,"ListCtrl_HasColumnOrderSupport",0,0,0)) SWIG_fail;
 
29873
  {
 
29874
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29875
    result = (bool)wxPyListCtrl_HasColumnOrderSupport();
 
29876
    wxPyEndAllowThreads(__tstate);
 
29877
    if (PyErr_Occurred()) SWIG_fail;
 
29878
  }
 
29879
  {
 
29880
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
29881
  }
 
29882
  return resultobj;
 
29883
fail:
 
29884
  return NULL;
 
29885
}
 
29886
 
 
29887
 
 
29888
SWIGINTERN PyObject *_wrap_ListCtrl_GetColumnOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29889
  PyObject *resultobj = 0;
 
29890
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
29891
  int arg2 ;
 
29892
  int result;
 
29893
  void *argp1 = 0 ;
 
29894
  int res1 = 0 ;
 
29895
  int val2 ;
 
29896
  int ecode2 = 0 ;
 
29897
  PyObject * obj0 = 0 ;
 
29898
  PyObject * obj1 = 0 ;
 
29899
  char *  kwnames[] = {
 
29900
    (char *) "self",(char *) "col", NULL 
 
29901
  };
 
29902
  
 
29903
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetColumnOrder",kwnames,&obj0,&obj1)) SWIG_fail;
 
29904
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
29905
  if (!SWIG_IsOK(res1)) {
 
29906
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetColumnOrder" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
29907
  }
 
29908
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
29909
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
29910
  if (!SWIG_IsOK(ecode2)) {
 
29911
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetColumnOrder" "', expected argument " "2"" of type '" "int""'");
 
29912
  } 
 
29913
  arg2 = static_cast< int >(val2);
 
29914
  {
 
29915
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29916
    result = (int)wxPyListCtrl_GetColumnOrder((wxPyListCtrl const *)arg1,arg2);
 
29917
    wxPyEndAllowThreads(__tstate);
 
29918
    if (PyErr_Occurred()) SWIG_fail;
 
29919
  }
 
29920
  resultobj = SWIG_From_int(static_cast< int >(result));
 
29921
  return resultobj;
 
29922
fail:
 
29923
  return NULL;
 
29924
}
 
29925
 
 
29926
 
 
29927
SWIGINTERN PyObject *_wrap_ListCtrl_GetColumnIndexFromOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29928
  PyObject *resultobj = 0;
 
29929
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
29930
  int arg2 ;
 
29931
  int result;
 
29932
  void *argp1 = 0 ;
 
29933
  int res1 = 0 ;
 
29934
  int val2 ;
 
29935
  int ecode2 = 0 ;
 
29936
  PyObject * obj0 = 0 ;
 
29937
  PyObject * obj1 = 0 ;
 
29938
  char *  kwnames[] = {
 
29939
    (char *) "self",(char *) "order", NULL 
 
29940
  };
 
29941
  
 
29942
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetColumnIndexFromOrder",kwnames,&obj0,&obj1)) SWIG_fail;
 
29943
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
29944
  if (!SWIG_IsOK(res1)) {
 
29945
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetColumnIndexFromOrder" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
29946
  }
 
29947
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
29948
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
29949
  if (!SWIG_IsOK(ecode2)) {
 
29950
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetColumnIndexFromOrder" "', expected argument " "2"" of type '" "int""'");
 
29951
  } 
 
29952
  arg2 = static_cast< int >(val2);
 
29953
  {
 
29954
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29955
    result = (int)wxPyListCtrl_GetColumnIndexFromOrder((wxPyListCtrl const *)arg1,arg2);
 
29956
    wxPyEndAllowThreads(__tstate);
 
29957
    if (PyErr_Occurred()) SWIG_fail;
 
29958
  }
 
29959
  resultobj = SWIG_From_int(static_cast< int >(result));
 
29960
  return resultobj;
 
29961
fail:
 
29962
  return NULL;
 
29963
}
 
29964
 
 
29965
 
 
29966
SWIGINTERN PyObject *_wrap_ListCtrl_GetColumnsOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
29967
  PyObject *resultobj = 0;
 
29968
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
29969
  wxArrayInt result;
 
29970
  void *argp1 = 0 ;
 
29971
  int res1 = 0 ;
 
29972
  PyObject *swig_obj[1] ;
 
29973
  
 
29974
  if (!args) SWIG_fail;
 
29975
  swig_obj[0] = args;
 
29976
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
29977
  if (!SWIG_IsOK(res1)) {
 
29978
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetColumnsOrder" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
29979
  }
 
29980
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
29981
  {
 
29982
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
29983
    result = wxPyListCtrl_GetColumnsOrder((wxPyListCtrl const *)arg1);
 
29984
    wxPyEndAllowThreads(__tstate);
 
29985
    if (PyErr_Occurred()) SWIG_fail;
 
29986
  }
 
29987
  {
 
29988
    resultobj = wxArrayInt2PyList_helper(result);
 
29989
  }
 
29990
  return resultobj;
 
29991
fail:
 
29992
  return NULL;
 
29993
}
 
29994
 
 
29995
 
 
29996
SWIGINTERN PyObject *_wrap_ListCtrl_SetColumnsOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
29997
  PyObject *resultobj = 0;
 
29998
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
29999
  wxArrayInt *arg2 = 0 ;
 
30000
  bool result;
 
30001
  void *argp1 = 0 ;
 
30002
  int res1 = 0 ;
 
30003
  bool temp2 = false ;
 
30004
  PyObject * obj0 = 0 ;
 
30005
  PyObject * obj1 = 0 ;
 
30006
  char *  kwnames[] = {
 
30007
    (char *) "self",(char *) "orders", NULL 
 
30008
  };
 
30009
  
 
30010
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetColumnsOrder",kwnames,&obj0,&obj1)) SWIG_fail;
 
30011
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30012
  if (!SWIG_IsOK(res1)) {
 
30013
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetColumnsOrder" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30014
  }
 
30015
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30016
  {
 
30017
    if (! PySequence_Check(obj1)) {
 
30018
      PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
 
30019
      SWIG_fail;
 
30020
    }
 
30021
    arg2 = new wxArrayInt;
 
30022
    temp2 = true;
 
30023
    int i, len=PySequence_Length(obj1);
 
30024
    for (i=0; i<len; i++) {
 
30025
      PyObject* item = PySequence_GetItem(obj1, i);
 
30026
      PyObject* number  = PyNumber_Int(item);
 
30027
      if (!number) {
 
30028
        PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");
 
30029
        SWIG_fail;
 
30030
      }       
 
30031
      arg2->Add(PyInt_AS_LONG(number));
 
30032
      Py_DECREF(item);
 
30033
      Py_DECREF(number);
 
30034
    }
 
30035
  }
 
30036
  {
 
30037
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30038
    result = (bool)wxPyListCtrl_SetColumnsOrder(arg1,(wxArrayInt const &)*arg2);
 
30039
    wxPyEndAllowThreads(__tstate);
 
30040
    if (PyErr_Occurred()) SWIG_fail;
 
30041
  }
 
30042
  {
 
30043
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
30044
  }
 
30045
  {
 
30046
    if (temp2) delete arg2;
 
30047
  }
 
30048
  return resultobj;
 
30049
fail:
 
30050
  {
 
30051
    if (temp2) delete arg2;
 
30052
  }
 
30053
  return NULL;
 
30054
}
 
30055
 
 
30056
 
 
30057
SWIGINTERN PyObject *_wrap_ListCtrl_GetCountPerPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
30058
  PyObject *resultobj = 0;
 
30059
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30060
  int result;
 
30061
  void *argp1 = 0 ;
 
30062
  int res1 = 0 ;
 
30063
  PyObject *swig_obj[1] ;
 
30064
  
 
30065
  if (!args) SWIG_fail;
 
30066
  swig_obj[0] = args;
 
30067
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30068
  if (!SWIG_IsOK(res1)) {
 
30069
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetCountPerPage" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
30070
  }
 
30071
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30072
  {
 
30073
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30074
    result = (int)((wxPyListCtrl const *)arg1)->GetCountPerPage();
 
30075
    wxPyEndAllowThreads(__tstate);
 
30076
    if (PyErr_Occurred()) SWIG_fail;
 
30077
  }
 
30078
  resultobj = SWIG_From_int(static_cast< int >(result));
 
30079
  return resultobj;
 
30080
fail:
 
30081
  return NULL;
 
30082
}
 
30083
 
 
30084
 
 
30085
SWIGINTERN PyObject *_wrap_ListCtrl_GetViewRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
30086
  PyObject *resultobj = 0;
 
30087
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30088
  wxRect result;
 
30089
  void *argp1 = 0 ;
 
30090
  int res1 = 0 ;
 
30091
  PyObject *swig_obj[1] ;
 
30092
  
 
30093
  if (!args) SWIG_fail;
 
30094
  swig_obj[0] = args;
 
30095
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30096
  if (!SWIG_IsOK(res1)) {
 
30097
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetViewRect" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
30098
  }
 
30099
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30100
  {
 
30101
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30102
    result = ((wxPyListCtrl const *)arg1)->GetViewRect();
 
30103
    wxPyEndAllowThreads(__tstate);
 
30104
    if (PyErr_Occurred()) SWIG_fail;
 
30105
  }
 
30106
  resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN |  0 );
 
30107
  return resultobj;
 
30108
fail:
 
30109
  return NULL;
 
30110
}
 
30111
 
 
30112
 
 
30113
SWIGINTERN PyObject *_wrap_ListCtrl_GetEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
30114
  PyObject *resultobj = 0;
 
30115
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30116
  wxTextCtrl *result = 0 ;
 
30117
  void *argp1 = 0 ;
 
30118
  int res1 = 0 ;
 
30119
  PyObject *swig_obj[1] ;
 
30120
  
 
30121
  if (!args) SWIG_fail;
 
30122
  swig_obj[0] = args;
 
30123
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30124
  if (!SWIG_IsOK(res1)) {
 
30125
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetEditControl" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
30126
  }
 
30127
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30128
  {
 
30129
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30130
    result = (wxTextCtrl *)((wxPyListCtrl const *)arg1)->GetEditControl();
 
30131
    wxPyEndAllowThreads(__tstate);
 
30132
    if (PyErr_Occurred()) SWIG_fail;
 
30133
  }
 
30134
  {
 
30135
    resultobj = wxPyMake_wxObject(result, 0); 
 
30136
  }
 
30137
  return resultobj;
 
30138
fail:
 
30139
  return NULL;
 
30140
}
 
30141
 
 
30142
 
 
30143
SWIGINTERN PyObject *_wrap_ListCtrl_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30144
  PyObject *resultobj = 0;
 
30145
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30146
  long arg2 ;
 
30147
  int arg3 = (int) 0 ;
 
30148
  wxListItem *result = 0 ;
 
30149
  void *argp1 = 0 ;
 
30150
  int res1 = 0 ;
 
30151
  long val2 ;
 
30152
  int ecode2 = 0 ;
 
30153
  int val3 ;
 
30154
  int ecode3 = 0 ;
 
30155
  PyObject * obj0 = 0 ;
 
30156
  PyObject * obj1 = 0 ;
 
30157
  PyObject * obj2 = 0 ;
 
30158
  char *  kwnames[] = {
 
30159
    (char *) "self",(char *) "itemId",(char *) "col", NULL 
 
30160
  };
 
30161
  
 
30162
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
30163
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30164
  if (!SWIG_IsOK(res1)) {
 
30165
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30166
  }
 
30167
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30168
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30169
  if (!SWIG_IsOK(ecode2)) {
 
30170
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetItem" "', expected argument " "2"" of type '" "long""'");
 
30171
  } 
 
30172
  arg2 = static_cast< long >(val2);
 
30173
  if (obj2) {
 
30174
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
30175
    if (!SWIG_IsOK(ecode3)) {
 
30176
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_GetItem" "', expected argument " "3"" of type '" "int""'");
 
30177
    } 
 
30178
    arg3 = static_cast< int >(val3);
 
30179
  }
 
30180
  {
 
30181
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30182
    result = (wxListItem *)wxPyListCtrl_GetItem(arg1,arg2,arg3);
 
30183
    wxPyEndAllowThreads(__tstate);
 
30184
    if (PyErr_Occurred()) SWIG_fail;
 
30185
  }
 
30186
  {
 
30187
    resultobj = wxPyMake_wxObject(result, 0); 
 
30188
  }
 
30189
  return resultobj;
 
30190
fail:
 
30191
  return NULL;
 
30192
}
 
30193
 
 
30194
 
 
30195
SWIGINTERN PyObject *_wrap_ListCtrl_SetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30196
  PyObject *resultobj = 0;
 
30197
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30198
  wxListItem *arg2 = 0 ;
 
30199
  bool result;
 
30200
  void *argp1 = 0 ;
 
30201
  int res1 = 0 ;
 
30202
  void *argp2 = 0 ;
 
30203
  int res2 = 0 ;
 
30204
  PyObject * obj0 = 0 ;
 
30205
  PyObject * obj1 = 0 ;
 
30206
  char *  kwnames[] = {
 
30207
    (char *) "self",(char *) "info", NULL 
 
30208
  };
 
30209
  
 
30210
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
30211
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30212
  if (!SWIG_IsOK(res1)) {
 
30213
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30214
  }
 
30215
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30216
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxListItem,  0 );
 
30217
  if (!SWIG_IsOK(res2)) {
 
30218
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListCtrl_SetItem" "', expected argument " "2"" of type '" "wxListItem &""'"); 
 
30219
  }
 
30220
  if (!argp2) {
 
30221
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListCtrl_SetItem" "', expected argument " "2"" of type '" "wxListItem &""'"); 
 
30222
  }
 
30223
  arg2 = reinterpret_cast< wxListItem * >(argp2);
 
30224
  {
 
30225
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30226
    result = (bool)(arg1)->SetItem(*arg2);
 
30227
    wxPyEndAllowThreads(__tstate);
 
30228
    if (PyErr_Occurred()) SWIG_fail;
 
30229
  }
 
30230
  {
 
30231
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
30232
  }
 
30233
  return resultobj;
 
30234
fail:
 
30235
  return NULL;
 
30236
}
 
30237
 
 
30238
 
 
30239
SWIGINTERN PyObject *_wrap_ListCtrl_SetStringItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30240
  PyObject *resultobj = 0;
 
30241
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30242
  long arg2 ;
 
30243
  int arg3 ;
 
30244
  wxString *arg4 = 0 ;
 
30245
  int arg5 = (int) -1 ;
 
30246
  long result;
 
30247
  void *argp1 = 0 ;
 
30248
  int res1 = 0 ;
 
30249
  long val2 ;
 
30250
  int ecode2 = 0 ;
 
30251
  int val3 ;
 
30252
  int ecode3 = 0 ;
 
30253
  bool temp4 = false ;
 
30254
  int val5 ;
 
30255
  int ecode5 = 0 ;
 
30256
  PyObject * obj0 = 0 ;
 
30257
  PyObject * obj1 = 0 ;
 
30258
  PyObject * obj2 = 0 ;
 
30259
  PyObject * obj3 = 0 ;
 
30260
  PyObject * obj4 = 0 ;
 
30261
  char *  kwnames[] = {
 
30262
    (char *) "self",(char *) "index",(char *) "col",(char *) "label",(char *) "imageId", NULL 
 
30263
  };
 
30264
  
 
30265
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:ListCtrl_SetStringItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
30266
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30267
  if (!SWIG_IsOK(res1)) {
 
30268
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetStringItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30269
  }
 
30270
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30271
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30272
  if (!SWIG_IsOK(ecode2)) {
 
30273
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetStringItem" "', expected argument " "2"" of type '" "long""'");
 
30274
  } 
 
30275
  arg2 = static_cast< long >(val2);
 
30276
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
30277
  if (!SWIG_IsOK(ecode3)) {
 
30278
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_SetStringItem" "', expected argument " "3"" of type '" "int""'");
 
30279
  } 
 
30280
  arg3 = static_cast< int >(val3);
 
30281
  {
 
30282
    arg4 = wxString_in_helper(obj3);
 
30283
    if (arg4 == NULL) SWIG_fail;
 
30284
    temp4 = true;
 
30285
  }
 
30286
  if (obj4) {
 
30287
    ecode5 = SWIG_AsVal_int(obj4, &val5);
 
30288
    if (!SWIG_IsOK(ecode5)) {
 
30289
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ListCtrl_SetStringItem" "', expected argument " "5"" of type '" "int""'");
 
30290
    } 
 
30291
    arg5 = static_cast< int >(val5);
 
30292
  }
 
30293
  {
 
30294
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30295
    result = (long)(arg1)->SetItem(arg2,arg3,(wxString const &)*arg4,arg5);
 
30296
    wxPyEndAllowThreads(__tstate);
 
30297
    if (PyErr_Occurred()) SWIG_fail;
 
30298
  }
 
30299
  resultobj = SWIG_From_long(static_cast< long >(result));
 
30300
  {
 
30301
    if (temp4)
 
30302
    delete arg4;
 
30303
  }
 
30304
  return resultobj;
 
30305
fail:
 
30306
  {
 
30307
    if (temp4)
 
30308
    delete arg4;
 
30309
  }
 
30310
  return NULL;
 
30311
}
 
30312
 
 
30313
 
 
30314
SWIGINTERN PyObject *_wrap_ListCtrl_GetItemState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30315
  PyObject *resultobj = 0;
 
30316
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30317
  long arg2 ;
 
30318
  long arg3 ;
 
30319
  int result;
 
30320
  void *argp1 = 0 ;
 
30321
  int res1 = 0 ;
 
30322
  long val2 ;
 
30323
  int ecode2 = 0 ;
 
30324
  long val3 ;
 
30325
  int ecode3 = 0 ;
 
30326
  PyObject * obj0 = 0 ;
 
30327
  PyObject * obj1 = 0 ;
 
30328
  PyObject * obj2 = 0 ;
 
30329
  char *  kwnames[] = {
 
30330
    (char *) "self",(char *) "item",(char *) "stateMask", NULL 
 
30331
  };
 
30332
  
 
30333
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_GetItemState",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
30334
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30335
  if (!SWIG_IsOK(res1)) {
 
30336
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItemState" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
30337
  }
 
30338
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30339
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30340
  if (!SWIG_IsOK(ecode2)) {
 
30341
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetItemState" "', expected argument " "2"" of type '" "long""'");
 
30342
  } 
 
30343
  arg2 = static_cast< long >(val2);
 
30344
  ecode3 = SWIG_AsVal_long(obj2, &val3);
 
30345
  if (!SWIG_IsOK(ecode3)) {
 
30346
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_GetItemState" "', expected argument " "3"" of type '" "long""'");
 
30347
  } 
 
30348
  arg3 = static_cast< long >(val3);
 
30349
  {
 
30350
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30351
    result = (int)((wxPyListCtrl const *)arg1)->GetItemState(arg2,arg3);
 
30352
    wxPyEndAllowThreads(__tstate);
 
30353
    if (PyErr_Occurred()) SWIG_fail;
 
30354
  }
 
30355
  resultobj = SWIG_From_int(static_cast< int >(result));
 
30356
  return resultobj;
 
30357
fail:
 
30358
  return NULL;
 
30359
}
 
30360
 
 
30361
 
 
30362
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30363
  PyObject *resultobj = 0;
 
30364
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30365
  long arg2 ;
 
30366
  long arg3 ;
 
30367
  long arg4 ;
 
30368
  bool result;
 
30369
  void *argp1 = 0 ;
 
30370
  int res1 = 0 ;
 
30371
  long val2 ;
 
30372
  int ecode2 = 0 ;
 
30373
  long val3 ;
 
30374
  int ecode3 = 0 ;
 
30375
  long val4 ;
 
30376
  int ecode4 = 0 ;
 
30377
  PyObject * obj0 = 0 ;
 
30378
  PyObject * obj1 = 0 ;
 
30379
  PyObject * obj2 = 0 ;
 
30380
  PyObject * obj3 = 0 ;
 
30381
  char *  kwnames[] = {
 
30382
    (char *) "self",(char *) "item",(char *) "state",(char *) "stateMask", NULL 
 
30383
  };
 
30384
  
 
30385
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ListCtrl_SetItemState",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
30386
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30387
  if (!SWIG_IsOK(res1)) {
 
30388
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemState" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30389
  }
 
30390
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30391
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30392
  if (!SWIG_IsOK(ecode2)) {
 
30393
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemState" "', expected argument " "2"" of type '" "long""'");
 
30394
  } 
 
30395
  arg2 = static_cast< long >(val2);
 
30396
  ecode3 = SWIG_AsVal_long(obj2, &val3);
 
30397
  if (!SWIG_IsOK(ecode3)) {
 
30398
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_SetItemState" "', expected argument " "3"" of type '" "long""'");
 
30399
  } 
 
30400
  arg3 = static_cast< long >(val3);
 
30401
  ecode4 = SWIG_AsVal_long(obj3, &val4);
 
30402
  if (!SWIG_IsOK(ecode4)) {
 
30403
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListCtrl_SetItemState" "', expected argument " "4"" of type '" "long""'");
 
30404
  } 
 
30405
  arg4 = static_cast< long >(val4);
 
30406
  {
 
30407
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30408
    result = (bool)(arg1)->SetItemState(arg2,arg3,arg4);
 
30409
    wxPyEndAllowThreads(__tstate);
 
30410
    if (PyErr_Occurred()) SWIG_fail;
 
30411
  }
 
30412
  {
 
30413
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
30414
  }
 
30415
  return resultobj;
 
30416
fail:
 
30417
  return NULL;
 
30418
}
 
30419
 
 
30420
 
 
30421
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30422
  PyObject *resultobj = 0;
 
30423
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30424
  long arg2 ;
 
30425
  int arg3 ;
 
30426
  int arg4 = (int) -1 ;
 
30427
  bool result;
 
30428
  void *argp1 = 0 ;
 
30429
  int res1 = 0 ;
 
30430
  long val2 ;
 
30431
  int ecode2 = 0 ;
 
30432
  int val3 ;
 
30433
  int ecode3 = 0 ;
 
30434
  int val4 ;
 
30435
  int ecode4 = 0 ;
 
30436
  PyObject * obj0 = 0 ;
 
30437
  PyObject * obj1 = 0 ;
 
30438
  PyObject * obj2 = 0 ;
 
30439
  PyObject * obj3 = 0 ;
 
30440
  char *  kwnames[] = {
 
30441
    (char *) "self",(char *) "item",(char *) "image",(char *) "selImage", NULL 
 
30442
  };
 
30443
  
 
30444
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ListCtrl_SetItemImage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
30445
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30446
  if (!SWIG_IsOK(res1)) {
 
30447
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemImage" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30448
  }
 
30449
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30450
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30451
  if (!SWIG_IsOK(ecode2)) {
 
30452
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemImage" "', expected argument " "2"" of type '" "long""'");
 
30453
  } 
 
30454
  arg2 = static_cast< long >(val2);
 
30455
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
30456
  if (!SWIG_IsOK(ecode3)) {
 
30457
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_SetItemImage" "', expected argument " "3"" of type '" "int""'");
 
30458
  } 
 
30459
  arg3 = static_cast< int >(val3);
 
30460
  if (obj3) {
 
30461
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
30462
    if (!SWIG_IsOK(ecode4)) {
 
30463
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListCtrl_SetItemImage" "', expected argument " "4"" of type '" "int""'");
 
30464
    } 
 
30465
    arg4 = static_cast< int >(val4);
 
30466
  }
 
30467
  {
 
30468
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30469
    result = (bool)(arg1)->SetItemImage(arg2,arg3,arg4);
 
30470
    wxPyEndAllowThreads(__tstate);
 
30471
    if (PyErr_Occurred()) SWIG_fail;
 
30472
  }
 
30473
  {
 
30474
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
30475
  }
 
30476
  return resultobj;
 
30477
fail:
 
30478
  return NULL;
 
30479
}
 
30480
 
 
30481
 
 
30482
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemColumnImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30483
  PyObject *resultobj = 0;
 
30484
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30485
  long arg2 ;
 
30486
  long arg3 ;
 
30487
  int arg4 ;
 
30488
  bool result;
 
30489
  void *argp1 = 0 ;
 
30490
  int res1 = 0 ;
 
30491
  long val2 ;
 
30492
  int ecode2 = 0 ;
 
30493
  long val3 ;
 
30494
  int ecode3 = 0 ;
 
30495
  int val4 ;
 
30496
  int ecode4 = 0 ;
 
30497
  PyObject * obj0 = 0 ;
 
30498
  PyObject * obj1 = 0 ;
 
30499
  PyObject * obj2 = 0 ;
 
30500
  PyObject * obj3 = 0 ;
 
30501
  char *  kwnames[] = {
 
30502
    (char *) "self",(char *) "item",(char *) "column",(char *) "image", NULL 
 
30503
  };
 
30504
  
 
30505
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ListCtrl_SetItemColumnImage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
30506
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30507
  if (!SWIG_IsOK(res1)) {
 
30508
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemColumnImage" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30509
  }
 
30510
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30511
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30512
  if (!SWIG_IsOK(ecode2)) {
 
30513
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemColumnImage" "', expected argument " "2"" of type '" "long""'");
 
30514
  } 
 
30515
  arg2 = static_cast< long >(val2);
 
30516
  ecode3 = SWIG_AsVal_long(obj2, &val3);
 
30517
  if (!SWIG_IsOK(ecode3)) {
 
30518
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_SetItemColumnImage" "', expected argument " "3"" of type '" "long""'");
 
30519
  } 
 
30520
  arg3 = static_cast< long >(val3);
 
30521
  ecode4 = SWIG_AsVal_int(obj3, &val4);
 
30522
  if (!SWIG_IsOK(ecode4)) {
 
30523
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListCtrl_SetItemColumnImage" "', expected argument " "4"" of type '" "int""'");
 
30524
  } 
 
30525
  arg4 = static_cast< int >(val4);
 
30526
  {
 
30527
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30528
    result = (bool)(arg1)->SetItemColumnImage(arg2,arg3,arg4);
 
30529
    wxPyEndAllowThreads(__tstate);
 
30530
    if (PyErr_Occurred()) SWIG_fail;
 
30531
  }
 
30532
  {
 
30533
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
30534
  }
 
30535
  return resultobj;
 
30536
fail:
 
30537
  return NULL;
 
30538
}
 
30539
 
 
30540
 
 
30541
SWIGINTERN PyObject *_wrap_ListCtrl_GetItemText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30542
  PyObject *resultobj = 0;
 
30543
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30544
  long arg2 ;
 
30545
  int arg3 = (int) 0 ;
 
30546
  wxString result;
 
30547
  void *argp1 = 0 ;
 
30548
  int res1 = 0 ;
 
30549
  long val2 ;
 
30550
  int ecode2 = 0 ;
 
30551
  int val3 ;
 
30552
  int ecode3 = 0 ;
 
30553
  PyObject * obj0 = 0 ;
 
30554
  PyObject * obj1 = 0 ;
 
30555
  PyObject * obj2 = 0 ;
 
30556
  char *  kwnames[] = {
 
30557
    (char *) "self",(char *) "item",(char *) "col", NULL 
 
30558
  };
 
30559
  
 
30560
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_GetItemText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
30561
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30562
  if (!SWIG_IsOK(res1)) {
 
30563
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItemText" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
30564
  }
 
30565
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30566
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30567
  if (!SWIG_IsOK(ecode2)) {
 
30568
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetItemText" "', expected argument " "2"" of type '" "long""'");
 
30569
  } 
 
30570
  arg2 = static_cast< long >(val2);
 
30571
  if (obj2) {
 
30572
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
30573
    if (!SWIG_IsOK(ecode3)) {
 
30574
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_GetItemText" "', expected argument " "3"" of type '" "int""'");
 
30575
    } 
 
30576
    arg3 = static_cast< int >(val3);
 
30577
  }
 
30578
  {
 
30579
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30580
    result = ((wxPyListCtrl const *)arg1)->GetItemText(arg2,arg3);
 
30581
    wxPyEndAllowThreads(__tstate);
 
30582
    if (PyErr_Occurred()) SWIG_fail;
 
30583
  }
 
30584
  {
 
30585
#if wxUSE_UNICODE
 
30586
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
30587
#else
 
30588
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
30589
#endif
 
30590
  }
 
30591
  return resultobj;
 
30592
fail:
 
30593
  return NULL;
 
30594
}
 
30595
 
 
30596
 
 
30597
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30598
  PyObject *resultobj = 0;
 
30599
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30600
  long arg2 ;
 
30601
  wxString *arg3 = 0 ;
 
30602
  void *argp1 = 0 ;
 
30603
  int res1 = 0 ;
 
30604
  long val2 ;
 
30605
  int ecode2 = 0 ;
 
30606
  bool temp3 = false ;
 
30607
  PyObject * obj0 = 0 ;
 
30608
  PyObject * obj1 = 0 ;
 
30609
  PyObject * obj2 = 0 ;
 
30610
  char *  kwnames[] = {
 
30611
    (char *) "self",(char *) "item",(char *) "str", NULL 
 
30612
  };
 
30613
  
 
30614
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
30615
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30616
  if (!SWIG_IsOK(res1)) {
 
30617
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemText" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30618
  }
 
30619
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30620
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30621
  if (!SWIG_IsOK(ecode2)) {
 
30622
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemText" "', expected argument " "2"" of type '" "long""'");
 
30623
  } 
 
30624
  arg2 = static_cast< long >(val2);
 
30625
  {
 
30626
    arg3 = wxString_in_helper(obj2);
 
30627
    if (arg3 == NULL) SWIG_fail;
 
30628
    temp3 = true;
 
30629
  }
 
30630
  {
 
30631
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30632
    (arg1)->SetItemText(arg2,(wxString const &)*arg3);
 
30633
    wxPyEndAllowThreads(__tstate);
 
30634
    if (PyErr_Occurred()) SWIG_fail;
 
30635
  }
 
30636
  resultobj = SWIG_Py_Void();
 
30637
  {
 
30638
    if (temp3)
 
30639
    delete arg3;
 
30640
  }
 
30641
  return resultobj;
 
30642
fail:
 
30643
  {
 
30644
    if (temp3)
 
30645
    delete arg3;
 
30646
  }
 
30647
  return NULL;
 
30648
}
 
30649
 
 
30650
 
 
30651
SWIGINTERN PyObject *_wrap_ListCtrl_GetItemData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30652
  PyObject *resultobj = 0;
 
30653
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30654
  long arg2 ;
 
30655
  long result;
 
30656
  void *argp1 = 0 ;
 
30657
  int res1 = 0 ;
 
30658
  long val2 ;
 
30659
  int ecode2 = 0 ;
 
30660
  PyObject * obj0 = 0 ;
 
30661
  PyObject * obj1 = 0 ;
 
30662
  char *  kwnames[] = {
 
30663
    (char *) "self",(char *) "item", NULL 
 
30664
  };
 
30665
  
 
30666
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemData",kwnames,&obj0,&obj1)) SWIG_fail;
 
30667
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30668
  if (!SWIG_IsOK(res1)) {
 
30669
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItemData" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
30670
  }
 
30671
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30672
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30673
  if (!SWIG_IsOK(ecode2)) {
 
30674
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetItemData" "', expected argument " "2"" of type '" "long""'");
 
30675
  } 
 
30676
  arg2 = static_cast< long >(val2);
 
30677
  {
 
30678
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30679
    result = (long)((wxPyListCtrl const *)arg1)->GetItemData(arg2);
 
30680
    wxPyEndAllowThreads(__tstate);
 
30681
    if (PyErr_Occurred()) SWIG_fail;
 
30682
  }
 
30683
  resultobj = SWIG_From_long(static_cast< long >(result));
 
30684
  return resultobj;
 
30685
fail:
 
30686
  return NULL;
 
30687
}
 
30688
 
 
30689
 
 
30690
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30691
  PyObject *resultobj = 0;
 
30692
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30693
  long arg2 ;
 
30694
  long arg3 ;
 
30695
  bool result;
 
30696
  void *argp1 = 0 ;
 
30697
  int res1 = 0 ;
 
30698
  long val2 ;
 
30699
  int ecode2 = 0 ;
 
30700
  long val3 ;
 
30701
  int ecode3 = 0 ;
 
30702
  PyObject * obj0 = 0 ;
 
30703
  PyObject * obj1 = 0 ;
 
30704
  PyObject * obj2 = 0 ;
 
30705
  char *  kwnames[] = {
 
30706
    (char *) "self",(char *) "item",(char *) "data", NULL 
 
30707
  };
 
30708
  
 
30709
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
30710
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30711
  if (!SWIG_IsOK(res1)) {
 
30712
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemData" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30713
  }
 
30714
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30715
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30716
  if (!SWIG_IsOK(ecode2)) {
 
30717
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemData" "', expected argument " "2"" of type '" "long""'");
 
30718
  } 
 
30719
  arg2 = static_cast< long >(val2);
 
30720
  ecode3 = SWIG_AsVal_long(obj2, &val3);
 
30721
  if (!SWIG_IsOK(ecode3)) {
 
30722
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_SetItemData" "', expected argument " "3"" of type '" "long""'");
 
30723
  } 
 
30724
  arg3 = static_cast< long >(val3);
 
30725
  {
 
30726
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30727
    result = (bool)(arg1)->SetItemData(arg2,arg3);
 
30728
    wxPyEndAllowThreads(__tstate);
 
30729
    if (PyErr_Occurred()) SWIG_fail;
 
30730
  }
 
30731
  {
 
30732
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
30733
  }
 
30734
  return resultobj;
 
30735
fail:
 
30736
  return NULL;
 
30737
}
 
30738
 
 
30739
 
 
30740
SWIGINTERN PyObject *_wrap_ListCtrl_GetItemPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30741
  PyObject *resultobj = 0;
 
30742
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30743
  long arg2 ;
 
30744
  wxPoint result;
 
30745
  void *argp1 = 0 ;
 
30746
  int res1 = 0 ;
 
30747
  long val2 ;
 
30748
  int ecode2 = 0 ;
 
30749
  PyObject * obj0 = 0 ;
 
30750
  PyObject * obj1 = 0 ;
 
30751
  char *  kwnames[] = {
 
30752
    (char *) "self",(char *) "item", NULL 
 
30753
  };
 
30754
  
 
30755
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemPosition",kwnames,&obj0,&obj1)) SWIG_fail;
 
30756
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30757
  if (!SWIG_IsOK(res1)) {
 
30758
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItemPosition" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30759
  }
 
30760
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30761
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30762
  if (!SWIG_IsOK(ecode2)) {
 
30763
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetItemPosition" "', expected argument " "2"" of type '" "long""'");
 
30764
  } 
 
30765
  arg2 = static_cast< long >(val2);
 
30766
  {
 
30767
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30768
    result = wxPyListCtrl_GetItemPosition(arg1,arg2);
 
30769
    wxPyEndAllowThreads(__tstate);
 
30770
    if (PyErr_Occurred()) SWIG_fail;
 
30771
  }
 
30772
  resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN |  0 );
 
30773
  return resultobj;
 
30774
fail:
 
30775
  return NULL;
 
30776
}
 
30777
 
 
30778
 
 
30779
SWIGINTERN PyObject *_wrap_ListCtrl_GetItemRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30780
  PyObject *resultobj = 0;
 
30781
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30782
  long arg2 ;
 
30783
  int arg3 = (int) wxLIST_RECT_BOUNDS ;
 
30784
  wxRect result;
 
30785
  void *argp1 = 0 ;
 
30786
  int res1 = 0 ;
 
30787
  long val2 ;
 
30788
  int ecode2 = 0 ;
 
30789
  int val3 ;
 
30790
  int ecode3 = 0 ;
 
30791
  PyObject * obj0 = 0 ;
 
30792
  PyObject * obj1 = 0 ;
 
30793
  PyObject * obj2 = 0 ;
 
30794
  char *  kwnames[] = {
 
30795
    (char *) "self",(char *) "item",(char *) "code", NULL 
 
30796
  };
 
30797
  
 
30798
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_GetItemRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
30799
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30800
  if (!SWIG_IsOK(res1)) {
 
30801
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItemRect" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30802
  }
 
30803
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30804
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30805
  if (!SWIG_IsOK(ecode2)) {
 
30806
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetItemRect" "', expected argument " "2"" of type '" "long""'");
 
30807
  } 
 
30808
  arg2 = static_cast< long >(val2);
 
30809
  if (obj2) {
 
30810
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
30811
    if (!SWIG_IsOK(ecode3)) {
 
30812
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_GetItemRect" "', expected argument " "3"" of type '" "int""'");
 
30813
    } 
 
30814
    arg3 = static_cast< int >(val3);
 
30815
  }
 
30816
  {
 
30817
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30818
    result = wxPyListCtrl_GetItemRect(arg1,arg2,arg3);
 
30819
    wxPyEndAllowThreads(__tstate);
 
30820
    if (PyErr_Occurred()) SWIG_fail;
 
30821
  }
 
30822
  resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN |  0 );
 
30823
  return resultobj;
 
30824
fail:
 
30825
  return NULL;
 
30826
}
 
30827
 
 
30828
 
 
30829
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30830
  PyObject *resultobj = 0;
 
30831
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30832
  long arg2 ;
 
30833
  wxPoint *arg3 = 0 ;
 
30834
  bool result;
 
30835
  void *argp1 = 0 ;
 
30836
  int res1 = 0 ;
 
30837
  long val2 ;
 
30838
  int ecode2 = 0 ;
 
30839
  wxPoint temp3 ;
 
30840
  PyObject * obj0 = 0 ;
 
30841
  PyObject * obj1 = 0 ;
 
30842
  PyObject * obj2 = 0 ;
 
30843
  char *  kwnames[] = {
 
30844
    (char *) "self",(char *) "item",(char *) "pos", NULL 
 
30845
  };
 
30846
  
 
30847
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemPosition",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
30848
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30849
  if (!SWIG_IsOK(res1)) {
 
30850
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemPosition" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30851
  }
 
30852
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30853
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
30854
  if (!SWIG_IsOK(ecode2)) {
 
30855
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemPosition" "', expected argument " "2"" of type '" "long""'");
 
30856
  } 
 
30857
  arg2 = static_cast< long >(val2);
 
30858
  {
 
30859
    arg3 = &temp3;
 
30860
    if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
30861
  }
 
30862
  {
 
30863
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30864
    result = (bool)(arg1)->SetItemPosition(arg2,(wxPoint const &)*arg3);
 
30865
    wxPyEndAllowThreads(__tstate);
 
30866
    if (PyErr_Occurred()) SWIG_fail;
 
30867
  }
 
30868
  {
 
30869
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
30870
  }
 
30871
  return resultobj;
 
30872
fail:
 
30873
  return NULL;
 
30874
}
 
30875
 
 
30876
 
 
30877
SWIGINTERN PyObject *_wrap_ListCtrl_GetItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
30878
  PyObject *resultobj = 0;
 
30879
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30880
  int result;
 
30881
  void *argp1 = 0 ;
 
30882
  int res1 = 0 ;
 
30883
  PyObject *swig_obj[1] ;
 
30884
  
 
30885
  if (!args) SWIG_fail;
 
30886
  swig_obj[0] = args;
 
30887
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30888
  if (!SWIG_IsOK(res1)) {
 
30889
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItemCount" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
30890
  }
 
30891
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30892
  {
 
30893
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30894
    result = (int)((wxPyListCtrl const *)arg1)->GetItemCount();
 
30895
    wxPyEndAllowThreads(__tstate);
 
30896
    if (PyErr_Occurred()) SWIG_fail;
 
30897
  }
 
30898
  resultobj = SWIG_From_int(static_cast< int >(result));
 
30899
  return resultobj;
 
30900
fail:
 
30901
  return NULL;
 
30902
}
 
30903
 
 
30904
 
 
30905
SWIGINTERN PyObject *_wrap_ListCtrl_GetColumnCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
30906
  PyObject *resultobj = 0;
 
30907
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30908
  int result;
 
30909
  void *argp1 = 0 ;
 
30910
  int res1 = 0 ;
 
30911
  PyObject *swig_obj[1] ;
 
30912
  
 
30913
  if (!args) SWIG_fail;
 
30914
  swig_obj[0] = args;
 
30915
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30916
  if (!SWIG_IsOK(res1)) {
 
30917
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetColumnCount" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
30918
  }
 
30919
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30920
  {
 
30921
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30922
    result = (int)((wxPyListCtrl const *)arg1)->GetColumnCount();
 
30923
    wxPyEndAllowThreads(__tstate);
 
30924
    if (PyErr_Occurred()) SWIG_fail;
 
30925
  }
 
30926
  resultobj = SWIG_From_int(static_cast< int >(result));
 
30927
  return resultobj;
 
30928
fail:
 
30929
  return NULL;
 
30930
}
 
30931
 
 
30932
 
 
30933
SWIGINTERN PyObject *_wrap_ListCtrl_GetItemSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
30934
  PyObject *resultobj = 0;
 
30935
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30936
  wxSize result;
 
30937
  void *argp1 = 0 ;
 
30938
  int res1 = 0 ;
 
30939
  PyObject *swig_obj[1] ;
 
30940
  
 
30941
  if (!args) SWIG_fail;
 
30942
  swig_obj[0] = args;
 
30943
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30944
  if (!SWIG_IsOK(res1)) {
 
30945
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItemSpacing" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
30946
  }
 
30947
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30948
  {
 
30949
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30950
    result = ((wxPyListCtrl const *)arg1)->GetItemSpacing();
 
30951
    wxPyEndAllowThreads(__tstate);
 
30952
    if (PyErr_Occurred()) SWIG_fail;
 
30953
  }
 
30954
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
30955
  return resultobj;
 
30956
fail:
 
30957
  return NULL;
 
30958
}
 
30959
 
 
30960
 
 
30961
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
30962
  PyObject *resultobj = 0;
 
30963
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
30964
  int arg2 ;
 
30965
  bool arg3 = (bool) false ;
 
30966
  void *argp1 = 0 ;
 
30967
  int res1 = 0 ;
 
30968
  int val2 ;
 
30969
  int ecode2 = 0 ;
 
30970
  bool val3 ;
 
30971
  int ecode3 = 0 ;
 
30972
  PyObject * obj0 = 0 ;
 
30973
  PyObject * obj1 = 0 ;
 
30974
  PyObject * obj2 = 0 ;
 
30975
  char *  kwnames[] = {
 
30976
    (char *) "self",(char *) "spacing",(char *) "isSmall", NULL 
 
30977
  };
 
30978
  
 
30979
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_SetItemSpacing",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
30980
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
30981
  if (!SWIG_IsOK(res1)) {
 
30982
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemSpacing" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
30983
  }
 
30984
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
30985
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
30986
  if (!SWIG_IsOK(ecode2)) {
 
30987
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemSpacing" "', expected argument " "2"" of type '" "int""'");
 
30988
  } 
 
30989
  arg2 = static_cast< int >(val2);
 
30990
  if (obj2) {
 
30991
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
30992
    if (!SWIG_IsOK(ecode3)) {
 
30993
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_SetItemSpacing" "', expected argument " "3"" of type '" "bool""'");
 
30994
    } 
 
30995
    arg3 = static_cast< bool >(val3);
 
30996
  }
 
30997
  {
 
30998
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
30999
    (arg1)->SetItemSpacing(arg2,arg3);
 
31000
    wxPyEndAllowThreads(__tstate);
 
31001
    if (PyErr_Occurred()) SWIG_fail;
 
31002
  }
 
31003
  resultobj = SWIG_Py_Void();
 
31004
  return resultobj;
 
31005
fail:
 
31006
  return NULL;
 
31007
}
 
31008
 
 
31009
 
 
31010
SWIGINTERN PyObject *_wrap_ListCtrl_GetSelectedItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
31011
  PyObject *resultobj = 0;
 
31012
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31013
  int result;
 
31014
  void *argp1 = 0 ;
 
31015
  int res1 = 0 ;
 
31016
  PyObject *swig_obj[1] ;
 
31017
  
 
31018
  if (!args) SWIG_fail;
 
31019
  swig_obj[0] = args;
 
31020
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31021
  if (!SWIG_IsOK(res1)) {
 
31022
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetSelectedItemCount" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
31023
  }
 
31024
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31025
  {
 
31026
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31027
    result = (int)((wxPyListCtrl const *)arg1)->GetSelectedItemCount();
 
31028
    wxPyEndAllowThreads(__tstate);
 
31029
    if (PyErr_Occurred()) SWIG_fail;
 
31030
  }
 
31031
  resultobj = SWIG_From_int(static_cast< int >(result));
 
31032
  return resultobj;
 
31033
fail:
 
31034
  return NULL;
 
31035
}
 
31036
 
 
31037
 
 
31038
SWIGINTERN PyObject *_wrap_ListCtrl_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
31039
  PyObject *resultobj = 0;
 
31040
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31041
  wxColour result;
 
31042
  void *argp1 = 0 ;
 
31043
  int res1 = 0 ;
 
31044
  PyObject *swig_obj[1] ;
 
31045
  
 
31046
  if (!args) SWIG_fail;
 
31047
  swig_obj[0] = args;
 
31048
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31049
  if (!SWIG_IsOK(res1)) {
 
31050
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetTextColour" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
31051
  }
 
31052
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31053
  {
 
31054
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31055
    result = ((wxPyListCtrl const *)arg1)->GetTextColour();
 
31056
    wxPyEndAllowThreads(__tstate);
 
31057
    if (PyErr_Occurred()) SWIG_fail;
 
31058
  }
 
31059
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
31060
  return resultobj;
 
31061
fail:
 
31062
  return NULL;
 
31063
}
 
31064
 
 
31065
 
 
31066
SWIGINTERN PyObject *_wrap_ListCtrl_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31067
  PyObject *resultobj = 0;
 
31068
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31069
  wxColour *arg2 = 0 ;
 
31070
  void *argp1 = 0 ;
 
31071
  int res1 = 0 ;
 
31072
  wxColour temp2 ;
 
31073
  PyObject * obj0 = 0 ;
 
31074
  PyObject * obj1 = 0 ;
 
31075
  char *  kwnames[] = {
 
31076
    (char *) "self",(char *) "col", NULL 
 
31077
  };
 
31078
  
 
31079
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
31080
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31081
  if (!SWIG_IsOK(res1)) {
 
31082
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetTextColour" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31083
  }
 
31084
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31085
  {
 
31086
    arg2 = &temp2;
 
31087
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
31088
  }
 
31089
  {
 
31090
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31091
    (arg1)->SetTextColour((wxColour const &)*arg2);
 
31092
    wxPyEndAllowThreads(__tstate);
 
31093
    if (PyErr_Occurred()) SWIG_fail;
 
31094
  }
 
31095
  resultobj = SWIG_Py_Void();
 
31096
  return resultobj;
 
31097
fail:
 
31098
  return NULL;
 
31099
}
 
31100
 
 
31101
 
 
31102
SWIGINTERN PyObject *_wrap_ListCtrl_GetTopItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
31103
  PyObject *resultobj = 0;
 
31104
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31105
  long result;
 
31106
  void *argp1 = 0 ;
 
31107
  int res1 = 0 ;
 
31108
  PyObject *swig_obj[1] ;
 
31109
  
 
31110
  if (!args) SWIG_fail;
 
31111
  swig_obj[0] = args;
 
31112
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31113
  if (!SWIG_IsOK(res1)) {
 
31114
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetTopItem" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
31115
  }
 
31116
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31117
  {
 
31118
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31119
    result = (long)((wxPyListCtrl const *)arg1)->GetTopItem();
 
31120
    wxPyEndAllowThreads(__tstate);
 
31121
    if (PyErr_Occurred()) SWIG_fail;
 
31122
  }
 
31123
  resultobj = SWIG_From_long(static_cast< long >(result));
 
31124
  return resultobj;
 
31125
fail:
 
31126
  return NULL;
 
31127
}
 
31128
 
 
31129
 
 
31130
SWIGINTERN PyObject *_wrap_ListCtrl_SetSingleStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31131
  PyObject *resultobj = 0;
 
31132
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31133
  long arg2 ;
 
31134
  bool arg3 = (bool) true ;
 
31135
  void *argp1 = 0 ;
 
31136
  int res1 = 0 ;
 
31137
  long val2 ;
 
31138
  int ecode2 = 0 ;
 
31139
  bool val3 ;
 
31140
  int ecode3 = 0 ;
 
31141
  PyObject * obj0 = 0 ;
 
31142
  PyObject * obj1 = 0 ;
 
31143
  PyObject * obj2 = 0 ;
 
31144
  char *  kwnames[] = {
 
31145
    (char *) "self",(char *) "style",(char *) "add", NULL 
 
31146
  };
 
31147
  
 
31148
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListCtrl_SetSingleStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
31149
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31150
  if (!SWIG_IsOK(res1)) {
 
31151
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetSingleStyle" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31152
  }
 
31153
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31154
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
31155
  if (!SWIG_IsOK(ecode2)) {
 
31156
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetSingleStyle" "', expected argument " "2"" of type '" "long""'");
 
31157
  } 
 
31158
  arg2 = static_cast< long >(val2);
 
31159
  if (obj2) {
 
31160
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
31161
    if (!SWIG_IsOK(ecode3)) {
 
31162
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_SetSingleStyle" "', expected argument " "3"" of type '" "bool""'");
 
31163
    } 
 
31164
    arg3 = static_cast< bool >(val3);
 
31165
  }
 
31166
  {
 
31167
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31168
    (arg1)->SetSingleStyle(arg2,arg3);
 
31169
    wxPyEndAllowThreads(__tstate);
 
31170
    if (PyErr_Occurred()) SWIG_fail;
 
31171
  }
 
31172
  resultobj = SWIG_Py_Void();
 
31173
  return resultobj;
 
31174
fail:
 
31175
  return NULL;
 
31176
}
 
31177
 
 
31178
 
 
31179
SWIGINTERN PyObject *_wrap_ListCtrl_GetNextItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31180
  PyObject *resultobj = 0;
 
31181
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31182
  long arg2 ;
 
31183
  int arg3 = (int) wxLIST_NEXT_ALL ;
 
31184
  int arg4 = (int) wxLIST_STATE_DONTCARE ;
 
31185
  long result;
 
31186
  void *argp1 = 0 ;
 
31187
  int res1 = 0 ;
 
31188
  long val2 ;
 
31189
  int ecode2 = 0 ;
 
31190
  int val3 ;
 
31191
  int ecode3 = 0 ;
 
31192
  int val4 ;
 
31193
  int ecode4 = 0 ;
 
31194
  PyObject * obj0 = 0 ;
 
31195
  PyObject * obj1 = 0 ;
 
31196
  PyObject * obj2 = 0 ;
 
31197
  PyObject * obj3 = 0 ;
 
31198
  char *  kwnames[] = {
 
31199
    (char *) "self",(char *) "item",(char *) "geometry",(char *) "state", NULL 
 
31200
  };
 
31201
  
 
31202
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:ListCtrl_GetNextItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
31203
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31204
  if (!SWIG_IsOK(res1)) {
 
31205
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetNextItem" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
31206
  }
 
31207
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31208
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
31209
  if (!SWIG_IsOK(ecode2)) {
 
31210
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetNextItem" "', expected argument " "2"" of type '" "long""'");
 
31211
  } 
 
31212
  arg2 = static_cast< long >(val2);
 
31213
  if (obj2) {
 
31214
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
31215
    if (!SWIG_IsOK(ecode3)) {
 
31216
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_GetNextItem" "', expected argument " "3"" of type '" "int""'");
 
31217
    } 
 
31218
    arg3 = static_cast< int >(val3);
 
31219
  }
 
31220
  if (obj3) {
 
31221
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
31222
    if (!SWIG_IsOK(ecode4)) {
 
31223
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListCtrl_GetNextItem" "', expected argument " "4"" of type '" "int""'");
 
31224
    } 
 
31225
    arg4 = static_cast< int >(val4);
 
31226
  }
 
31227
  {
 
31228
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31229
    result = (long)((wxPyListCtrl const *)arg1)->GetNextItem(arg2,arg3,arg4);
 
31230
    wxPyEndAllowThreads(__tstate);
 
31231
    if (PyErr_Occurred()) SWIG_fail;
 
31232
  }
 
31233
  resultobj = SWIG_From_long(static_cast< long >(result));
 
31234
  return resultobj;
 
31235
fail:
 
31236
  return NULL;
 
31237
}
 
31238
 
 
31239
 
 
31240
SWIGINTERN PyObject *_wrap_ListCtrl_GetImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31241
  PyObject *resultobj = 0;
 
31242
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31243
  int arg2 ;
 
31244
  wxImageList *result = 0 ;
 
31245
  void *argp1 = 0 ;
 
31246
  int res1 = 0 ;
 
31247
  int val2 ;
 
31248
  int ecode2 = 0 ;
 
31249
  PyObject * obj0 = 0 ;
 
31250
  PyObject * obj1 = 0 ;
 
31251
  char *  kwnames[] = {
 
31252
    (char *) "self",(char *) "which", NULL 
 
31253
  };
 
31254
  
 
31255
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetImageList",kwnames,&obj0,&obj1)) SWIG_fail;
 
31256
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31257
  if (!SWIG_IsOK(res1)) {
 
31258
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetImageList" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
31259
  }
 
31260
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31261
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
31262
  if (!SWIG_IsOK(ecode2)) {
 
31263
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetImageList" "', expected argument " "2"" of type '" "int""'");
 
31264
  } 
 
31265
  arg2 = static_cast< int >(val2);
 
31266
  {
 
31267
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31268
    result = (wxImageList *)((wxPyListCtrl const *)arg1)->GetImageList(arg2);
 
31269
    wxPyEndAllowThreads(__tstate);
 
31270
    if (PyErr_Occurred()) SWIG_fail;
 
31271
  }
 
31272
  {
 
31273
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
31274
  }
 
31275
  return resultobj;
 
31276
fail:
 
31277
  return NULL;
 
31278
}
 
31279
 
 
31280
 
 
31281
SWIGINTERN PyObject *_wrap_ListCtrl_SetImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31282
  PyObject *resultobj = 0;
 
31283
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31284
  wxImageList *arg2 = (wxImageList *) 0 ;
 
31285
  int arg3 ;
 
31286
  void *argp1 = 0 ;
 
31287
  int res1 = 0 ;
 
31288
  void *argp2 = 0 ;
 
31289
  int res2 = 0 ;
 
31290
  int val3 ;
 
31291
  int ecode3 = 0 ;
 
31292
  PyObject * obj0 = 0 ;
 
31293
  PyObject * obj1 = 0 ;
 
31294
  PyObject * obj2 = 0 ;
 
31295
  char *  kwnames[] = {
 
31296
    (char *) "self",(char *) "imageList",(char *) "which", NULL 
 
31297
  };
 
31298
  
 
31299
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetImageList",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
31300
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31301
  if (!SWIG_IsOK(res1)) {
 
31302
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetImageList" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31303
  }
 
31304
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31305
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxImageList, 0 |  0 );
 
31306
  if (!SWIG_IsOK(res2)) {
 
31307
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListCtrl_SetImageList" "', expected argument " "2"" of type '" "wxImageList *""'"); 
 
31308
  }
 
31309
  arg2 = reinterpret_cast< wxImageList * >(argp2);
 
31310
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
31311
  if (!SWIG_IsOK(ecode3)) {
 
31312
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_SetImageList" "', expected argument " "3"" of type '" "int""'");
 
31313
  } 
 
31314
  arg3 = static_cast< int >(val3);
 
31315
  {
 
31316
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31317
    (arg1)->SetImageList(arg2,arg3);
 
31318
    wxPyEndAllowThreads(__tstate);
 
31319
    if (PyErr_Occurred()) SWIG_fail;
 
31320
  }
 
31321
  resultobj = SWIG_Py_Void();
 
31322
  return resultobj;
 
31323
fail:
 
31324
  return NULL;
 
31325
}
 
31326
 
 
31327
 
 
31328
SWIGINTERN PyObject *_wrap_ListCtrl_AssignImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31329
  PyObject *resultobj = 0;
 
31330
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31331
  wxImageList *arg2 = (wxImageList *) 0 ;
 
31332
  int arg3 ;
 
31333
  void *argp1 = 0 ;
 
31334
  int res1 = 0 ;
 
31335
  int res2 = 0 ;
 
31336
  int val3 ;
 
31337
  int ecode3 = 0 ;
 
31338
  PyObject * obj0 = 0 ;
 
31339
  PyObject * obj1 = 0 ;
 
31340
  PyObject * obj2 = 0 ;
 
31341
  char *  kwnames[] = {
 
31342
    (char *) "self",(char *) "imageList",(char *) "which", NULL 
 
31343
  };
 
31344
  
 
31345
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_AssignImageList",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
31346
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31347
  if (!SWIG_IsOK(res1)) {
 
31348
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_AssignImageList" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31349
  }
 
31350
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31351
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxImageList, SWIG_POINTER_DISOWN |  0 );
 
31352
  if (!SWIG_IsOK(res2)) {
 
31353
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListCtrl_AssignImageList" "', expected argument " "2"" of type '" "wxImageList *""'");
 
31354
  }
 
31355
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
31356
  if (!SWIG_IsOK(ecode3)) {
 
31357
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_AssignImageList" "', expected argument " "3"" of type '" "int""'");
 
31358
  } 
 
31359
  arg3 = static_cast< int >(val3);
 
31360
  {
 
31361
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31362
    (arg1)->AssignImageList(arg2,arg3);
 
31363
    wxPyEndAllowThreads(__tstate);
 
31364
    if (PyErr_Occurred()) SWIG_fail;
 
31365
  }
 
31366
  resultobj = SWIG_Py_Void();
 
31367
  return resultobj;
 
31368
fail:
 
31369
  return NULL;
 
31370
}
 
31371
 
 
31372
 
 
31373
SWIGINTERN PyObject *_wrap_ListCtrl_InReportView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
31374
  PyObject *resultobj = 0;
 
31375
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31376
  bool result;
 
31377
  void *argp1 = 0 ;
 
31378
  int res1 = 0 ;
 
31379
  PyObject *swig_obj[1] ;
 
31380
  
 
31381
  if (!args) SWIG_fail;
 
31382
  swig_obj[0] = args;
 
31383
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31384
  if (!SWIG_IsOK(res1)) {
 
31385
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_InReportView" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
31386
  }
 
31387
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31388
  {
 
31389
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31390
    result = (bool)((wxPyListCtrl const *)arg1)->InReportView();
 
31391
    wxPyEndAllowThreads(__tstate);
 
31392
    if (PyErr_Occurred()) SWIG_fail;
 
31393
  }
 
31394
  {
 
31395
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
31396
  }
 
31397
  return resultobj;
 
31398
fail:
 
31399
  return NULL;
 
31400
}
 
31401
 
 
31402
 
 
31403
SWIGINTERN PyObject *_wrap_ListCtrl_IsVirtual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
31404
  PyObject *resultobj = 0;
 
31405
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31406
  bool result;
 
31407
  void *argp1 = 0 ;
 
31408
  int res1 = 0 ;
 
31409
  PyObject *swig_obj[1] ;
 
31410
  
 
31411
  if (!args) SWIG_fail;
 
31412
  swig_obj[0] = args;
 
31413
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31414
  if (!SWIG_IsOK(res1)) {
 
31415
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_IsVirtual" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
31416
  }
 
31417
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31418
  {
 
31419
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31420
    result = (bool)((wxPyListCtrl const *)arg1)->IsVirtual();
 
31421
    wxPyEndAllowThreads(__tstate);
 
31422
    if (PyErr_Occurred()) SWIG_fail;
 
31423
  }
 
31424
  {
 
31425
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
31426
  }
 
31427
  return resultobj;
 
31428
fail:
 
31429
  return NULL;
 
31430
}
 
31431
 
 
31432
 
 
31433
SWIGINTERN PyObject *_wrap_ListCtrl_RefreshItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31434
  PyObject *resultobj = 0;
 
31435
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31436
  long arg2 ;
 
31437
  void *argp1 = 0 ;
 
31438
  int res1 = 0 ;
 
31439
  long val2 ;
 
31440
  int ecode2 = 0 ;
 
31441
  PyObject * obj0 = 0 ;
 
31442
  PyObject * obj1 = 0 ;
 
31443
  char *  kwnames[] = {
 
31444
    (char *) "self",(char *) "item", NULL 
 
31445
  };
 
31446
  
 
31447
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_RefreshItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
31448
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31449
  if (!SWIG_IsOK(res1)) {
 
31450
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_RefreshItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31451
  }
 
31452
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31453
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
31454
  if (!SWIG_IsOK(ecode2)) {
 
31455
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_RefreshItem" "', expected argument " "2"" of type '" "long""'");
 
31456
  } 
 
31457
  arg2 = static_cast< long >(val2);
 
31458
  {
 
31459
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31460
    (arg1)->RefreshItem(arg2);
 
31461
    wxPyEndAllowThreads(__tstate);
 
31462
    if (PyErr_Occurred()) SWIG_fail;
 
31463
  }
 
31464
  resultobj = SWIG_Py_Void();
 
31465
  return resultobj;
 
31466
fail:
 
31467
  return NULL;
 
31468
}
 
31469
 
 
31470
 
 
31471
SWIGINTERN PyObject *_wrap_ListCtrl_RefreshItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31472
  PyObject *resultobj = 0;
 
31473
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31474
  long arg2 ;
 
31475
  long arg3 ;
 
31476
  void *argp1 = 0 ;
 
31477
  int res1 = 0 ;
 
31478
  long val2 ;
 
31479
  int ecode2 = 0 ;
 
31480
  long val3 ;
 
31481
  int ecode3 = 0 ;
 
31482
  PyObject * obj0 = 0 ;
 
31483
  PyObject * obj1 = 0 ;
 
31484
  PyObject * obj2 = 0 ;
 
31485
  char *  kwnames[] = {
 
31486
    (char *) "self",(char *) "itemFrom",(char *) "itemTo", NULL 
 
31487
  };
 
31488
  
 
31489
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_RefreshItems",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
31490
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31491
  if (!SWIG_IsOK(res1)) {
 
31492
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_RefreshItems" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31493
  }
 
31494
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31495
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
31496
  if (!SWIG_IsOK(ecode2)) {
 
31497
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_RefreshItems" "', expected argument " "2"" of type '" "long""'");
 
31498
  } 
 
31499
  arg2 = static_cast< long >(val2);
 
31500
  ecode3 = SWIG_AsVal_long(obj2, &val3);
 
31501
  if (!SWIG_IsOK(ecode3)) {
 
31502
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_RefreshItems" "', expected argument " "3"" of type '" "long""'");
 
31503
  } 
 
31504
  arg3 = static_cast< long >(val3);
 
31505
  {
 
31506
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31507
    (arg1)->RefreshItems(arg2,arg3);
 
31508
    wxPyEndAllowThreads(__tstate);
 
31509
    if (PyErr_Occurred()) SWIG_fail;
 
31510
  }
 
31511
  resultobj = SWIG_Py_Void();
 
31512
  return resultobj;
 
31513
fail:
 
31514
  return NULL;
 
31515
}
 
31516
 
 
31517
 
 
31518
SWIGINTERN PyObject *_wrap_ListCtrl_Arrange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31519
  PyObject *resultobj = 0;
 
31520
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31521
  int arg2 = (int) wxLIST_ALIGN_DEFAULT ;
 
31522
  bool result;
 
31523
  void *argp1 = 0 ;
 
31524
  int res1 = 0 ;
 
31525
  int val2 ;
 
31526
  int ecode2 = 0 ;
 
31527
  PyObject * obj0 = 0 ;
 
31528
  PyObject * obj1 = 0 ;
 
31529
  char *  kwnames[] = {
 
31530
    (char *) "self",(char *) "flag", NULL 
 
31531
  };
 
31532
  
 
31533
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ListCtrl_Arrange",kwnames,&obj0,&obj1)) SWIG_fail;
 
31534
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31535
  if (!SWIG_IsOK(res1)) {
 
31536
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_Arrange" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31537
  }
 
31538
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31539
  if (obj1) {
 
31540
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
31541
    if (!SWIG_IsOK(ecode2)) {
 
31542
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_Arrange" "', expected argument " "2"" of type '" "int""'");
 
31543
    } 
 
31544
    arg2 = static_cast< int >(val2);
 
31545
  }
 
31546
  {
 
31547
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31548
    result = (bool)(arg1)->Arrange(arg2);
 
31549
    wxPyEndAllowThreads(__tstate);
 
31550
    if (PyErr_Occurred()) SWIG_fail;
 
31551
  }
 
31552
  {
 
31553
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
31554
  }
 
31555
  return resultobj;
 
31556
fail:
 
31557
  return NULL;
 
31558
}
 
31559
 
 
31560
 
 
31561
SWIGINTERN PyObject *_wrap_ListCtrl_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31562
  PyObject *resultobj = 0;
 
31563
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31564
  long arg2 ;
 
31565
  bool result;
 
31566
  void *argp1 = 0 ;
 
31567
  int res1 = 0 ;
 
31568
  long val2 ;
 
31569
  int ecode2 = 0 ;
 
31570
  PyObject * obj0 = 0 ;
 
31571
  PyObject * obj1 = 0 ;
 
31572
  char *  kwnames[] = {
 
31573
    (char *) "self",(char *) "item", NULL 
 
31574
  };
 
31575
  
 
31576
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
31577
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31578
  if (!SWIG_IsOK(res1)) {
 
31579
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_DeleteItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31580
  }
 
31581
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31582
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
31583
  if (!SWIG_IsOK(ecode2)) {
 
31584
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_DeleteItem" "', expected argument " "2"" of type '" "long""'");
 
31585
  } 
 
31586
  arg2 = static_cast< long >(val2);
 
31587
  {
 
31588
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31589
    result = (bool)(arg1)->DeleteItem(arg2);
 
31590
    wxPyEndAllowThreads(__tstate);
 
31591
    if (PyErr_Occurred()) SWIG_fail;
 
31592
  }
 
31593
  {
 
31594
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
31595
  }
 
31596
  return resultobj;
 
31597
fail:
 
31598
  return NULL;
 
31599
}
 
31600
 
 
31601
 
 
31602
SWIGINTERN PyObject *_wrap_ListCtrl_DeleteAllItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
31603
  PyObject *resultobj = 0;
 
31604
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31605
  bool result;
 
31606
  void *argp1 = 0 ;
 
31607
  int res1 = 0 ;
 
31608
  PyObject *swig_obj[1] ;
 
31609
  
 
31610
  if (!args) SWIG_fail;
 
31611
  swig_obj[0] = args;
 
31612
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31613
  if (!SWIG_IsOK(res1)) {
 
31614
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_DeleteAllItems" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31615
  }
 
31616
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31617
  {
 
31618
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31619
    result = (bool)(arg1)->DeleteAllItems();
 
31620
    wxPyEndAllowThreads(__tstate);
 
31621
    if (PyErr_Occurred()) SWIG_fail;
 
31622
  }
 
31623
  {
 
31624
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
31625
  }
 
31626
  return resultobj;
 
31627
fail:
 
31628
  return NULL;
 
31629
}
 
31630
 
 
31631
 
 
31632
SWIGINTERN PyObject *_wrap_ListCtrl_DeleteColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31633
  PyObject *resultobj = 0;
 
31634
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31635
  int arg2 ;
 
31636
  bool result;
 
31637
  void *argp1 = 0 ;
 
31638
  int res1 = 0 ;
 
31639
  int val2 ;
 
31640
  int ecode2 = 0 ;
 
31641
  PyObject * obj0 = 0 ;
 
31642
  PyObject * obj1 = 0 ;
 
31643
  char *  kwnames[] = {
 
31644
    (char *) "self",(char *) "col", NULL 
 
31645
  };
 
31646
  
 
31647
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_DeleteColumn",kwnames,&obj0,&obj1)) SWIG_fail;
 
31648
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31649
  if (!SWIG_IsOK(res1)) {
 
31650
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_DeleteColumn" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31651
  }
 
31652
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31653
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
31654
  if (!SWIG_IsOK(ecode2)) {
 
31655
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_DeleteColumn" "', expected argument " "2"" of type '" "int""'");
 
31656
  } 
 
31657
  arg2 = static_cast< int >(val2);
 
31658
  {
 
31659
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31660
    result = (bool)(arg1)->DeleteColumn(arg2);
 
31661
    wxPyEndAllowThreads(__tstate);
 
31662
    if (PyErr_Occurred()) SWIG_fail;
 
31663
  }
 
31664
  {
 
31665
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
31666
  }
 
31667
  return resultobj;
 
31668
fail:
 
31669
  return NULL;
 
31670
}
 
31671
 
 
31672
 
 
31673
SWIGINTERN PyObject *_wrap_ListCtrl_DeleteAllColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
31674
  PyObject *resultobj = 0;
 
31675
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31676
  bool result;
 
31677
  void *argp1 = 0 ;
 
31678
  int res1 = 0 ;
 
31679
  PyObject *swig_obj[1] ;
 
31680
  
 
31681
  if (!args) SWIG_fail;
 
31682
  swig_obj[0] = args;
 
31683
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31684
  if (!SWIG_IsOK(res1)) {
 
31685
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_DeleteAllColumns" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31686
  }
 
31687
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31688
  {
 
31689
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31690
    result = (bool)(arg1)->DeleteAllColumns();
 
31691
    wxPyEndAllowThreads(__tstate);
 
31692
    if (PyErr_Occurred()) SWIG_fail;
 
31693
  }
 
31694
  {
 
31695
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
31696
  }
 
31697
  return resultobj;
 
31698
fail:
 
31699
  return NULL;
 
31700
}
 
31701
 
 
31702
 
 
31703
SWIGINTERN PyObject *_wrap_ListCtrl_ClearAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
31704
  PyObject *resultobj = 0;
 
31705
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31706
  void *argp1 = 0 ;
 
31707
  int res1 = 0 ;
 
31708
  PyObject *swig_obj[1] ;
 
31709
  
 
31710
  if (!args) SWIG_fail;
 
31711
  swig_obj[0] = args;
 
31712
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31713
  if (!SWIG_IsOK(res1)) {
 
31714
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_ClearAll" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31715
  }
 
31716
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31717
  {
 
31718
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31719
    (arg1)->ClearAll();
 
31720
    wxPyEndAllowThreads(__tstate);
 
31721
    if (PyErr_Occurred()) SWIG_fail;
 
31722
  }
 
31723
  resultobj = SWIG_Py_Void();
 
31724
  return resultobj;
 
31725
fail:
 
31726
  return NULL;
 
31727
}
 
31728
 
 
31729
 
 
31730
SWIGINTERN PyObject *_wrap_ListCtrl_EditLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31731
  PyObject *resultobj = 0;
 
31732
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31733
  long arg2 ;
 
31734
  void *argp1 = 0 ;
 
31735
  int res1 = 0 ;
 
31736
  long val2 ;
 
31737
  int ecode2 = 0 ;
 
31738
  PyObject * obj0 = 0 ;
 
31739
  PyObject * obj1 = 0 ;
 
31740
  char *  kwnames[] = {
 
31741
    (char *) "self",(char *) "item", NULL 
 
31742
  };
 
31743
  
 
31744
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_EditLabel",kwnames,&obj0,&obj1)) SWIG_fail;
 
31745
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31746
  if (!SWIG_IsOK(res1)) {
 
31747
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_EditLabel" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31748
  }
 
31749
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31750
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
31751
  if (!SWIG_IsOK(ecode2)) {
 
31752
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_EditLabel" "', expected argument " "2"" of type '" "long""'");
 
31753
  } 
 
31754
  arg2 = static_cast< long >(val2);
 
31755
  {
 
31756
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31757
    (arg1)->EditLabel(arg2);
 
31758
    wxPyEndAllowThreads(__tstate);
 
31759
    if (PyErr_Occurred()) SWIG_fail;
 
31760
  }
 
31761
  resultobj = SWIG_Py_Void();
 
31762
  return resultobj;
 
31763
fail:
 
31764
  return NULL;
 
31765
}
 
31766
 
 
31767
 
 
31768
SWIGINTERN PyObject *_wrap_ListCtrl_EnsureVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31769
  PyObject *resultobj = 0;
 
31770
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31771
  long arg2 ;
 
31772
  bool result;
 
31773
  void *argp1 = 0 ;
 
31774
  int res1 = 0 ;
 
31775
  long val2 ;
 
31776
  int ecode2 = 0 ;
 
31777
  PyObject * obj0 = 0 ;
 
31778
  PyObject * obj1 = 0 ;
 
31779
  char *  kwnames[] = {
 
31780
    (char *) "self",(char *) "item", NULL 
 
31781
  };
 
31782
  
 
31783
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_EnsureVisible",kwnames,&obj0,&obj1)) SWIG_fail;
 
31784
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31785
  if (!SWIG_IsOK(res1)) {
 
31786
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_EnsureVisible" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31787
  }
 
31788
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31789
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
31790
  if (!SWIG_IsOK(ecode2)) {
 
31791
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_EnsureVisible" "', expected argument " "2"" of type '" "long""'");
 
31792
  } 
 
31793
  arg2 = static_cast< long >(val2);
 
31794
  {
 
31795
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31796
    result = (bool)(arg1)->EnsureVisible(arg2);
 
31797
    wxPyEndAllowThreads(__tstate);
 
31798
    if (PyErr_Occurred()) SWIG_fail;
 
31799
  }
 
31800
  {
 
31801
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
31802
  }
 
31803
  return resultobj;
 
31804
fail:
 
31805
  return NULL;
 
31806
}
 
31807
 
 
31808
 
 
31809
SWIGINTERN PyObject *_wrap_ListCtrl_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31810
  PyObject *resultobj = 0;
 
31811
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31812
  long arg2 ;
 
31813
  wxString *arg3 = 0 ;
 
31814
  bool arg4 = (bool) false ;
 
31815
  long result;
 
31816
  void *argp1 = 0 ;
 
31817
  int res1 = 0 ;
 
31818
  long val2 ;
 
31819
  int ecode2 = 0 ;
 
31820
  bool temp3 = false ;
 
31821
  bool val4 ;
 
31822
  int ecode4 = 0 ;
 
31823
  PyObject * obj0 = 0 ;
 
31824
  PyObject * obj1 = 0 ;
 
31825
  PyObject * obj2 = 0 ;
 
31826
  PyObject * obj3 = 0 ;
 
31827
  char *  kwnames[] = {
 
31828
    (char *) "self",(char *) "start",(char *) "str",(char *) "partial", NULL 
 
31829
  };
 
31830
  
 
31831
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ListCtrl_FindItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
31832
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31833
  if (!SWIG_IsOK(res1)) {
 
31834
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_FindItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31835
  }
 
31836
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31837
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
31838
  if (!SWIG_IsOK(ecode2)) {
 
31839
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_FindItem" "', expected argument " "2"" of type '" "long""'");
 
31840
  } 
 
31841
  arg2 = static_cast< long >(val2);
 
31842
  {
 
31843
    arg3 = wxString_in_helper(obj2);
 
31844
    if (arg3 == NULL) SWIG_fail;
 
31845
    temp3 = true;
 
31846
  }
 
31847
  if (obj3) {
 
31848
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
 
31849
    if (!SWIG_IsOK(ecode4)) {
 
31850
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListCtrl_FindItem" "', expected argument " "4"" of type '" "bool""'");
 
31851
    } 
 
31852
    arg4 = static_cast< bool >(val4);
 
31853
  }
 
31854
  {
 
31855
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31856
    result = (long)(arg1)->FindItem(arg2,(wxString const &)*arg3,arg4);
 
31857
    wxPyEndAllowThreads(__tstate);
 
31858
    if (PyErr_Occurred()) SWIG_fail;
 
31859
  }
 
31860
  resultobj = SWIG_From_long(static_cast< long >(result));
 
31861
  {
 
31862
    if (temp3)
 
31863
    delete arg3;
 
31864
  }
 
31865
  return resultobj;
 
31866
fail:
 
31867
  {
 
31868
    if (temp3)
 
31869
    delete arg3;
 
31870
  }
 
31871
  return NULL;
 
31872
}
 
31873
 
 
31874
 
 
31875
SWIGINTERN PyObject *_wrap_ListCtrl_FindItemData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31876
  PyObject *resultobj = 0;
 
31877
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31878
  long arg2 ;
 
31879
  long arg3 ;
 
31880
  long result;
 
31881
  void *argp1 = 0 ;
 
31882
  int res1 = 0 ;
 
31883
  long val2 ;
 
31884
  int ecode2 = 0 ;
 
31885
  long val3 ;
 
31886
  int ecode3 = 0 ;
 
31887
  PyObject * obj0 = 0 ;
 
31888
  PyObject * obj1 = 0 ;
 
31889
  PyObject * obj2 = 0 ;
 
31890
  char *  kwnames[] = {
 
31891
    (char *) "self",(char *) "start",(char *) "data", NULL 
 
31892
  };
 
31893
  
 
31894
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_FindItemData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
31895
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31896
  if (!SWIG_IsOK(res1)) {
 
31897
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_FindItemData" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31898
  }
 
31899
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31900
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
31901
  if (!SWIG_IsOK(ecode2)) {
 
31902
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_FindItemData" "', expected argument " "2"" of type '" "long""'");
 
31903
  } 
 
31904
  arg2 = static_cast< long >(val2);
 
31905
  ecode3 = SWIG_AsVal_long(obj2, &val3);
 
31906
  if (!SWIG_IsOK(ecode3)) {
 
31907
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_FindItemData" "', expected argument " "3"" of type '" "long""'");
 
31908
  } 
 
31909
  arg3 = static_cast< long >(val3);
 
31910
  {
 
31911
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31912
    result = (long)(arg1)->FindItem(arg2,arg3);
 
31913
    wxPyEndAllowThreads(__tstate);
 
31914
    if (PyErr_Occurred()) SWIG_fail;
 
31915
  }
 
31916
  resultobj = SWIG_From_long(static_cast< long >(result));
 
31917
  return resultobj;
 
31918
fail:
 
31919
  return NULL;
 
31920
}
 
31921
 
 
31922
 
 
31923
SWIGINTERN PyObject *_wrap_ListCtrl_FindItemAtPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31924
  PyObject *resultobj = 0;
 
31925
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31926
  long arg2 ;
 
31927
  wxPoint *arg3 = 0 ;
 
31928
  int arg4 ;
 
31929
  long result;
 
31930
  void *argp1 = 0 ;
 
31931
  int res1 = 0 ;
 
31932
  long val2 ;
 
31933
  int ecode2 = 0 ;
 
31934
  wxPoint temp3 ;
 
31935
  int val4 ;
 
31936
  int ecode4 = 0 ;
 
31937
  PyObject * obj0 = 0 ;
 
31938
  PyObject * obj1 = 0 ;
 
31939
  PyObject * obj2 = 0 ;
 
31940
  PyObject * obj3 = 0 ;
 
31941
  char *  kwnames[] = {
 
31942
    (char *) "self",(char *) "start",(char *) "pt",(char *) "direction", NULL 
 
31943
  };
 
31944
  
 
31945
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ListCtrl_FindItemAtPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
31946
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31947
  if (!SWIG_IsOK(res1)) {
 
31948
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_FindItemAtPos" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
31949
  }
 
31950
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
31951
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
31952
  if (!SWIG_IsOK(ecode2)) {
 
31953
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_FindItemAtPos" "', expected argument " "2"" of type '" "long""'");
 
31954
  } 
 
31955
  arg2 = static_cast< long >(val2);
 
31956
  {
 
31957
    arg3 = &temp3;
 
31958
    if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
31959
  }
 
31960
  ecode4 = SWIG_AsVal_int(obj3, &val4);
 
31961
  if (!SWIG_IsOK(ecode4)) {
 
31962
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListCtrl_FindItemAtPos" "', expected argument " "4"" of type '" "int""'");
 
31963
  } 
 
31964
  arg4 = static_cast< int >(val4);
 
31965
  {
 
31966
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
31967
    result = (long)(arg1)->FindItem(arg2,(wxPoint const &)*arg3,arg4);
 
31968
    wxPyEndAllowThreads(__tstate);
 
31969
    if (PyErr_Occurred()) SWIG_fail;
 
31970
  }
 
31971
  resultobj = SWIG_From_long(static_cast< long >(result));
 
31972
  return resultobj;
 
31973
fail:
 
31974
  return NULL;
 
31975
}
 
31976
 
 
31977
 
 
31978
SWIGINTERN PyObject *_wrap_ListCtrl_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
31979
  PyObject *resultobj = 0;
 
31980
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
31981
  wxPoint *arg2 = 0 ;
 
31982
  int *arg3 = 0 ;
 
31983
  long result;
 
31984
  void *argp1 = 0 ;
 
31985
  int res1 = 0 ;
 
31986
  wxPoint temp2 ;
 
31987
  int temp3 ;
 
31988
  int res3 = SWIG_TMPOBJ ;
 
31989
  PyObject * obj0 = 0 ;
 
31990
  PyObject * obj1 = 0 ;
 
31991
  char *  kwnames[] = {
 
31992
    (char *) "self",(char *) "point", NULL 
 
31993
  };
 
31994
  
 
31995
  arg3 = &temp3;
 
31996
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
 
31997
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
31998
  if (!SWIG_IsOK(res1)) {
 
31999
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_HitTest" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32000
  }
 
32001
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32002
  {
 
32003
    arg2 = &temp2;
 
32004
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
32005
  }
 
32006
  {
 
32007
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32008
    result = (long)(arg1)->HitTest((wxPoint const &)*arg2,*arg3);
 
32009
    wxPyEndAllowThreads(__tstate);
 
32010
    if (PyErr_Occurred()) SWIG_fail;
 
32011
  }
 
32012
  resultobj = SWIG_From_long(static_cast< long >(result));
 
32013
  if (SWIG_IsTmpObj(res3)) {
 
32014
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
 
32015
  } else {
 
32016
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
32017
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
 
32018
  }
 
32019
  return resultobj;
 
32020
fail:
 
32021
  return NULL;
 
32022
}
 
32023
 
 
32024
 
 
32025
SWIGINTERN PyObject *_wrap_ListCtrl_HitTestSubItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32026
  PyObject *resultobj = 0;
 
32027
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32028
  wxPoint *arg2 = 0 ;
 
32029
  int *arg3 = 0 ;
 
32030
  long *arg4 = (long *) 0 ;
 
32031
  long result;
 
32032
  void *argp1 = 0 ;
 
32033
  int res1 = 0 ;
 
32034
  wxPoint temp2 ;
 
32035
  int temp3 ;
 
32036
  int res3 = SWIG_TMPOBJ ;
 
32037
  long temp4 ;
 
32038
  int res4 = SWIG_TMPOBJ ;
 
32039
  PyObject * obj0 = 0 ;
 
32040
  PyObject * obj1 = 0 ;
 
32041
  char *  kwnames[] = {
 
32042
    (char *) "self",(char *) "point", NULL 
 
32043
  };
 
32044
  
 
32045
  arg3 = &temp3;
 
32046
  arg4 = &temp4;
 
32047
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_HitTestSubItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
32048
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32049
  if (!SWIG_IsOK(res1)) {
 
32050
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_HitTestSubItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32051
  }
 
32052
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32053
  {
 
32054
    arg2 = &temp2;
 
32055
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
32056
  }
 
32057
  {
 
32058
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32059
    result = (long)(arg1)->HitTest((wxPoint const &)*arg2,*arg3,arg4);
 
32060
    wxPyEndAllowThreads(__tstate);
 
32061
    if (PyErr_Occurred()) SWIG_fail;
 
32062
  }
 
32063
  resultobj = SWIG_From_long(static_cast< long >(result));
 
32064
  if (SWIG_IsTmpObj(res3)) {
 
32065
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
 
32066
  } else {
 
32067
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
32068
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
 
32069
  }
 
32070
  if (SWIG_IsTmpObj(res4)) {
 
32071
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
 
32072
  } else {
 
32073
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
32074
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
 
32075
  }
 
32076
  return resultobj;
 
32077
fail:
 
32078
  return NULL;
 
32079
}
 
32080
 
 
32081
 
 
32082
SWIGINTERN PyObject *_wrap_ListCtrl_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32083
  PyObject *resultobj = 0;
 
32084
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32085
  wxListItem *arg2 = 0 ;
 
32086
  long result;
 
32087
  void *argp1 = 0 ;
 
32088
  int res1 = 0 ;
 
32089
  void *argp2 = 0 ;
 
32090
  int res2 = 0 ;
 
32091
  PyObject * obj0 = 0 ;
 
32092
  PyObject * obj1 = 0 ;
 
32093
  char *  kwnames[] = {
 
32094
    (char *) "self",(char *) "info", NULL 
 
32095
  };
 
32096
  
 
32097
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_InsertItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
32098
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32099
  if (!SWIG_IsOK(res1)) {
 
32100
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_InsertItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32101
  }
 
32102
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32103
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxListItem,  0 );
 
32104
  if (!SWIG_IsOK(res2)) {
 
32105
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListCtrl_InsertItem" "', expected argument " "2"" of type '" "wxListItem &""'"); 
 
32106
  }
 
32107
  if (!argp2) {
 
32108
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListCtrl_InsertItem" "', expected argument " "2"" of type '" "wxListItem &""'"); 
 
32109
  }
 
32110
  arg2 = reinterpret_cast< wxListItem * >(argp2);
 
32111
  {
 
32112
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32113
    result = (long)(arg1)->InsertItem(*arg2);
 
32114
    wxPyEndAllowThreads(__tstate);
 
32115
    if (PyErr_Occurred()) SWIG_fail;
 
32116
  }
 
32117
  resultobj = SWIG_From_long(static_cast< long >(result));
 
32118
  return resultobj;
 
32119
fail:
 
32120
  return NULL;
 
32121
}
 
32122
 
 
32123
 
 
32124
SWIGINTERN PyObject *_wrap_ListCtrl_InsertStringItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32125
  PyObject *resultobj = 0;
 
32126
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32127
  long arg2 ;
 
32128
  wxString *arg3 = 0 ;
 
32129
  int arg4 = (int) -1 ;
 
32130
  long result;
 
32131
  void *argp1 = 0 ;
 
32132
  int res1 = 0 ;
 
32133
  long val2 ;
 
32134
  int ecode2 = 0 ;
 
32135
  bool temp3 = false ;
 
32136
  int val4 ;
 
32137
  int ecode4 = 0 ;
 
32138
  PyObject * obj0 = 0 ;
 
32139
  PyObject * obj1 = 0 ;
 
32140
  PyObject * obj2 = 0 ;
 
32141
  PyObject * obj3 = 0 ;
 
32142
  char *  kwnames[] = {
 
32143
    (char *) "self",(char *) "index",(char *) "label",(char *) "imageIndex", NULL 
 
32144
  };
 
32145
  
 
32146
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ListCtrl_InsertStringItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
32147
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32148
  if (!SWIG_IsOK(res1)) {
 
32149
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_InsertStringItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32150
  }
 
32151
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32152
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32153
  if (!SWIG_IsOK(ecode2)) {
 
32154
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_InsertStringItem" "', expected argument " "2"" of type '" "long""'");
 
32155
  } 
 
32156
  arg2 = static_cast< long >(val2);
 
32157
  {
 
32158
    arg3 = wxString_in_helper(obj2);
 
32159
    if (arg3 == NULL) SWIG_fail;
 
32160
    temp3 = true;
 
32161
  }
 
32162
  if (obj3) {
 
32163
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
32164
    if (!SWIG_IsOK(ecode4)) {
 
32165
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListCtrl_InsertStringItem" "', expected argument " "4"" of type '" "int""'");
 
32166
    } 
 
32167
    arg4 = static_cast< int >(val4);
 
32168
  }
 
32169
  {
 
32170
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32171
    result = (long)(arg1)->InsertItem(arg2,(wxString const &)*arg3,arg4);
 
32172
    wxPyEndAllowThreads(__tstate);
 
32173
    if (PyErr_Occurred()) SWIG_fail;
 
32174
  }
 
32175
  resultobj = SWIG_From_long(static_cast< long >(result));
 
32176
  {
 
32177
    if (temp3)
 
32178
    delete arg3;
 
32179
  }
 
32180
  return resultobj;
 
32181
fail:
 
32182
  {
 
32183
    if (temp3)
 
32184
    delete arg3;
 
32185
  }
 
32186
  return NULL;
 
32187
}
 
32188
 
 
32189
 
 
32190
SWIGINTERN PyObject *_wrap_ListCtrl_InsertImageItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32191
  PyObject *resultobj = 0;
 
32192
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32193
  long arg2 ;
 
32194
  int arg3 ;
 
32195
  long result;
 
32196
  void *argp1 = 0 ;
 
32197
  int res1 = 0 ;
 
32198
  long val2 ;
 
32199
  int ecode2 = 0 ;
 
32200
  int val3 ;
 
32201
  int ecode3 = 0 ;
 
32202
  PyObject * obj0 = 0 ;
 
32203
  PyObject * obj1 = 0 ;
 
32204
  PyObject * obj2 = 0 ;
 
32205
  char *  kwnames[] = {
 
32206
    (char *) "self",(char *) "index",(char *) "imageIndex", NULL 
 
32207
  };
 
32208
  
 
32209
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_InsertImageItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
32210
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32211
  if (!SWIG_IsOK(res1)) {
 
32212
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_InsertImageItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32213
  }
 
32214
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32215
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32216
  if (!SWIG_IsOK(ecode2)) {
 
32217
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_InsertImageItem" "', expected argument " "2"" of type '" "long""'");
 
32218
  } 
 
32219
  arg2 = static_cast< long >(val2);
 
32220
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
32221
  if (!SWIG_IsOK(ecode3)) {
 
32222
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_InsertImageItem" "', expected argument " "3"" of type '" "int""'");
 
32223
  } 
 
32224
  arg3 = static_cast< int >(val3);
 
32225
  {
 
32226
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32227
    result = (long)(arg1)->InsertItem(arg2,arg3);
 
32228
    wxPyEndAllowThreads(__tstate);
 
32229
    if (PyErr_Occurred()) SWIG_fail;
 
32230
  }
 
32231
  resultobj = SWIG_From_long(static_cast< long >(result));
 
32232
  return resultobj;
 
32233
fail:
 
32234
  return NULL;
 
32235
}
 
32236
 
 
32237
 
 
32238
SWIGINTERN PyObject *_wrap_ListCtrl_InsertImageStringItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32239
  PyObject *resultobj = 0;
 
32240
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32241
  long arg2 ;
 
32242
  wxString *arg3 = 0 ;
 
32243
  int arg4 ;
 
32244
  long result;
 
32245
  void *argp1 = 0 ;
 
32246
  int res1 = 0 ;
 
32247
  long val2 ;
 
32248
  int ecode2 = 0 ;
 
32249
  bool temp3 = false ;
 
32250
  int val4 ;
 
32251
  int ecode4 = 0 ;
 
32252
  PyObject * obj0 = 0 ;
 
32253
  PyObject * obj1 = 0 ;
 
32254
  PyObject * obj2 = 0 ;
 
32255
  PyObject * obj3 = 0 ;
 
32256
  char *  kwnames[] = {
 
32257
    (char *) "self",(char *) "index",(char *) "label",(char *) "imageIndex", NULL 
 
32258
  };
 
32259
  
 
32260
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ListCtrl_InsertImageStringItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
32261
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32262
  if (!SWIG_IsOK(res1)) {
 
32263
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_InsertImageStringItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32264
  }
 
32265
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32266
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32267
  if (!SWIG_IsOK(ecode2)) {
 
32268
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_InsertImageStringItem" "', expected argument " "2"" of type '" "long""'");
 
32269
  } 
 
32270
  arg2 = static_cast< long >(val2);
 
32271
  {
 
32272
    arg3 = wxString_in_helper(obj2);
 
32273
    if (arg3 == NULL) SWIG_fail;
 
32274
    temp3 = true;
 
32275
  }
 
32276
  ecode4 = SWIG_AsVal_int(obj3, &val4);
 
32277
  if (!SWIG_IsOK(ecode4)) {
 
32278
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListCtrl_InsertImageStringItem" "', expected argument " "4"" of type '" "int""'");
 
32279
  } 
 
32280
  arg4 = static_cast< int >(val4);
 
32281
  {
 
32282
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32283
    result = (long)(arg1)->InsertItem(arg2,(wxString const &)*arg3,arg4);
 
32284
    wxPyEndAllowThreads(__tstate);
 
32285
    if (PyErr_Occurred()) SWIG_fail;
 
32286
  }
 
32287
  resultobj = SWIG_From_long(static_cast< long >(result));
 
32288
  {
 
32289
    if (temp3)
 
32290
    delete arg3;
 
32291
  }
 
32292
  return resultobj;
 
32293
fail:
 
32294
  {
 
32295
    if (temp3)
 
32296
    delete arg3;
 
32297
  }
 
32298
  return NULL;
 
32299
}
 
32300
 
 
32301
 
 
32302
SWIGINTERN PyObject *_wrap_ListCtrl_InsertColumnItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32303
  PyObject *resultobj = 0;
 
32304
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32305
  long arg2 ;
 
32306
  wxListItem *arg3 = 0 ;
 
32307
  long result;
 
32308
  void *argp1 = 0 ;
 
32309
  int res1 = 0 ;
 
32310
  long val2 ;
 
32311
  int ecode2 = 0 ;
 
32312
  void *argp3 = 0 ;
 
32313
  int res3 = 0 ;
 
32314
  PyObject * obj0 = 0 ;
 
32315
  PyObject * obj1 = 0 ;
 
32316
  PyObject * obj2 = 0 ;
 
32317
  char *  kwnames[] = {
 
32318
    (char *) "self",(char *) "col",(char *) "info", NULL 
 
32319
  };
 
32320
  
 
32321
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_InsertColumnItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
32322
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32323
  if (!SWIG_IsOK(res1)) {
 
32324
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_InsertColumnItem" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32325
  }
 
32326
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32327
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32328
  if (!SWIG_IsOK(ecode2)) {
 
32329
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_InsertColumnItem" "', expected argument " "2"" of type '" "long""'");
 
32330
  } 
 
32331
  arg2 = static_cast< long >(val2);
 
32332
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxListItem,  0 );
 
32333
  if (!SWIG_IsOK(res3)) {
 
32334
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ListCtrl_InsertColumnItem" "', expected argument " "3"" of type '" "wxListItem &""'"); 
 
32335
  }
 
32336
  if (!argp3) {
 
32337
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListCtrl_InsertColumnItem" "', expected argument " "3"" of type '" "wxListItem &""'"); 
 
32338
  }
 
32339
  arg3 = reinterpret_cast< wxListItem * >(argp3);
 
32340
  {
 
32341
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32342
    result = (long)(arg1)->InsertColumn(arg2,*arg3);
 
32343
    wxPyEndAllowThreads(__tstate);
 
32344
    if (PyErr_Occurred()) SWIG_fail;
 
32345
  }
 
32346
  resultobj = SWIG_From_long(static_cast< long >(result));
 
32347
  return resultobj;
 
32348
fail:
 
32349
  return NULL;
 
32350
}
 
32351
 
 
32352
 
 
32353
SWIGINTERN PyObject *_wrap_ListCtrl_InsertColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32354
  PyObject *resultobj = 0;
 
32355
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32356
  long arg2 ;
 
32357
  wxString *arg3 = 0 ;
 
32358
  int arg4 = (int) wxLIST_FORMAT_LEFT ;
 
32359
  int arg5 = (int) -1 ;
 
32360
  long result;
 
32361
  void *argp1 = 0 ;
 
32362
  int res1 = 0 ;
 
32363
  long val2 ;
 
32364
  int ecode2 = 0 ;
 
32365
  bool temp3 = false ;
 
32366
  int val4 ;
 
32367
  int ecode4 = 0 ;
 
32368
  int val5 ;
 
32369
  int ecode5 = 0 ;
 
32370
  PyObject * obj0 = 0 ;
 
32371
  PyObject * obj1 = 0 ;
 
32372
  PyObject * obj2 = 0 ;
 
32373
  PyObject * obj3 = 0 ;
 
32374
  PyObject * obj4 = 0 ;
 
32375
  char *  kwnames[] = {
 
32376
    (char *) "self",(char *) "col",(char *) "heading",(char *) "format",(char *) "width", NULL 
 
32377
  };
 
32378
  
 
32379
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:ListCtrl_InsertColumn",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
32380
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32381
  if (!SWIG_IsOK(res1)) {
 
32382
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_InsertColumn" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32383
  }
 
32384
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32385
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32386
  if (!SWIG_IsOK(ecode2)) {
 
32387
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_InsertColumn" "', expected argument " "2"" of type '" "long""'");
 
32388
  } 
 
32389
  arg2 = static_cast< long >(val2);
 
32390
  {
 
32391
    arg3 = wxString_in_helper(obj2);
 
32392
    if (arg3 == NULL) SWIG_fail;
 
32393
    temp3 = true;
 
32394
  }
 
32395
  if (obj3) {
 
32396
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
32397
    if (!SWIG_IsOK(ecode4)) {
 
32398
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListCtrl_InsertColumn" "', expected argument " "4"" of type '" "int""'");
 
32399
    } 
 
32400
    arg4 = static_cast< int >(val4);
 
32401
  }
 
32402
  if (obj4) {
 
32403
    ecode5 = SWIG_AsVal_int(obj4, &val5);
 
32404
    if (!SWIG_IsOK(ecode5)) {
 
32405
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ListCtrl_InsertColumn" "', expected argument " "5"" of type '" "int""'");
 
32406
    } 
 
32407
    arg5 = static_cast< int >(val5);
 
32408
  }
 
32409
  {
 
32410
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32411
    result = (long)(arg1)->InsertColumn(arg2,(wxString const &)*arg3,arg4,arg5);
 
32412
    wxPyEndAllowThreads(__tstate);
 
32413
    if (PyErr_Occurred()) SWIG_fail;
 
32414
  }
 
32415
  resultobj = SWIG_From_long(static_cast< long >(result));
 
32416
  {
 
32417
    if (temp3)
 
32418
    delete arg3;
 
32419
  }
 
32420
  return resultobj;
 
32421
fail:
 
32422
  {
 
32423
    if (temp3)
 
32424
    delete arg3;
 
32425
  }
 
32426
  return NULL;
 
32427
}
 
32428
 
 
32429
 
 
32430
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32431
  PyObject *resultobj = 0;
 
32432
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32433
  long arg2 ;
 
32434
  void *argp1 = 0 ;
 
32435
  int res1 = 0 ;
 
32436
  long val2 ;
 
32437
  int ecode2 = 0 ;
 
32438
  PyObject * obj0 = 0 ;
 
32439
  PyObject * obj1 = 0 ;
 
32440
  char *  kwnames[] = {
 
32441
    (char *) "self",(char *) "count", NULL 
 
32442
  };
 
32443
  
 
32444
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SetItemCount",kwnames,&obj0,&obj1)) SWIG_fail;
 
32445
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32446
  if (!SWIG_IsOK(res1)) {
 
32447
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemCount" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32448
  }
 
32449
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32450
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32451
  if (!SWIG_IsOK(ecode2)) {
 
32452
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemCount" "', expected argument " "2"" of type '" "long""'");
 
32453
  } 
 
32454
  arg2 = static_cast< long >(val2);
 
32455
  {
 
32456
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32457
    (arg1)->SetItemCount(arg2);
 
32458
    wxPyEndAllowThreads(__tstate);
 
32459
    if (PyErr_Occurred()) SWIG_fail;
 
32460
  }
 
32461
  resultobj = SWIG_Py_Void();
 
32462
  return resultobj;
 
32463
fail:
 
32464
  return NULL;
 
32465
}
 
32466
 
 
32467
 
 
32468
SWIGINTERN PyObject *_wrap_ListCtrl_ScrollList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32469
  PyObject *resultobj = 0;
 
32470
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32471
  int arg2 ;
 
32472
  int arg3 ;
 
32473
  bool result;
 
32474
  void *argp1 = 0 ;
 
32475
  int res1 = 0 ;
 
32476
  int val2 ;
 
32477
  int ecode2 = 0 ;
 
32478
  int val3 ;
 
32479
  int ecode3 = 0 ;
 
32480
  PyObject * obj0 = 0 ;
 
32481
  PyObject * obj1 = 0 ;
 
32482
  PyObject * obj2 = 0 ;
 
32483
  char *  kwnames[] = {
 
32484
    (char *) "self",(char *) "dx",(char *) "dy", NULL 
 
32485
  };
 
32486
  
 
32487
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_ScrollList",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
32488
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32489
  if (!SWIG_IsOK(res1)) {
 
32490
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_ScrollList" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32491
  }
 
32492
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32493
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
32494
  if (!SWIG_IsOK(ecode2)) {
 
32495
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_ScrollList" "', expected argument " "2"" of type '" "int""'");
 
32496
  } 
 
32497
  arg2 = static_cast< int >(val2);
 
32498
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
32499
  if (!SWIG_IsOK(ecode3)) {
 
32500
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListCtrl_ScrollList" "', expected argument " "3"" of type '" "int""'");
 
32501
  } 
 
32502
  arg3 = static_cast< int >(val3);
 
32503
  {
 
32504
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32505
    result = (bool)(arg1)->ScrollList(arg2,arg3);
 
32506
    wxPyEndAllowThreads(__tstate);
 
32507
    if (PyErr_Occurred()) SWIG_fail;
 
32508
  }
 
32509
  {
 
32510
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
32511
  }
 
32512
  return resultobj;
 
32513
fail:
 
32514
  return NULL;
 
32515
}
 
32516
 
 
32517
 
 
32518
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32519
  PyObject *resultobj = 0;
 
32520
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32521
  long arg2 ;
 
32522
  wxColour *arg3 = 0 ;
 
32523
  void *argp1 = 0 ;
 
32524
  int res1 = 0 ;
 
32525
  long val2 ;
 
32526
  int ecode2 = 0 ;
 
32527
  wxColour temp3 ;
 
32528
  PyObject * obj0 = 0 ;
 
32529
  PyObject * obj1 = 0 ;
 
32530
  PyObject * obj2 = 0 ;
 
32531
  char *  kwnames[] = {
 
32532
    (char *) "self",(char *) "item",(char *) "col", NULL 
 
32533
  };
 
32534
  
 
32535
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
32536
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32537
  if (!SWIG_IsOK(res1)) {
 
32538
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemTextColour" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32539
  }
 
32540
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32541
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32542
  if (!SWIG_IsOK(ecode2)) {
 
32543
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemTextColour" "', expected argument " "2"" of type '" "long""'");
 
32544
  } 
 
32545
  arg2 = static_cast< long >(val2);
 
32546
  {
 
32547
    arg3 = &temp3;
 
32548
    if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
 
32549
  }
 
32550
  {
 
32551
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32552
    (arg1)->SetItemTextColour(arg2,(wxColour const &)*arg3);
 
32553
    wxPyEndAllowThreads(__tstate);
 
32554
    if (PyErr_Occurred()) SWIG_fail;
 
32555
  }
 
32556
  resultobj = SWIG_Py_Void();
 
32557
  return resultobj;
 
32558
fail:
 
32559
  return NULL;
 
32560
}
 
32561
 
 
32562
 
 
32563
SWIGINTERN PyObject *_wrap_ListCtrl_GetItemTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32564
  PyObject *resultobj = 0;
 
32565
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32566
  long arg2 ;
 
32567
  wxColour result;
 
32568
  void *argp1 = 0 ;
 
32569
  int res1 = 0 ;
 
32570
  long val2 ;
 
32571
  int ecode2 = 0 ;
 
32572
  PyObject * obj0 = 0 ;
 
32573
  PyObject * obj1 = 0 ;
 
32574
  char *  kwnames[] = {
 
32575
    (char *) "self",(char *) "item", NULL 
 
32576
  };
 
32577
  
 
32578
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
32579
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32580
  if (!SWIG_IsOK(res1)) {
 
32581
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItemTextColour" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
32582
  }
 
32583
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32584
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32585
  if (!SWIG_IsOK(ecode2)) {
 
32586
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetItemTextColour" "', expected argument " "2"" of type '" "long""'");
 
32587
  } 
 
32588
  arg2 = static_cast< long >(val2);
 
32589
  {
 
32590
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32591
    result = ((wxPyListCtrl const *)arg1)->GetItemTextColour(arg2);
 
32592
    wxPyEndAllowThreads(__tstate);
 
32593
    if (PyErr_Occurred()) SWIG_fail;
 
32594
  }
 
32595
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
32596
  return resultobj;
 
32597
fail:
 
32598
  return NULL;
 
32599
}
 
32600
 
 
32601
 
 
32602
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32603
  PyObject *resultobj = 0;
 
32604
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32605
  long arg2 ;
 
32606
  wxColour *arg3 = 0 ;
 
32607
  void *argp1 = 0 ;
 
32608
  int res1 = 0 ;
 
32609
  long val2 ;
 
32610
  int ecode2 = 0 ;
 
32611
  wxColour temp3 ;
 
32612
  PyObject * obj0 = 0 ;
 
32613
  PyObject * obj1 = 0 ;
 
32614
  PyObject * obj2 = 0 ;
 
32615
  char *  kwnames[] = {
 
32616
    (char *) "self",(char *) "item",(char *) "col", NULL 
 
32617
  };
 
32618
  
 
32619
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
32620
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32621
  if (!SWIG_IsOK(res1)) {
 
32622
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemBackgroundColour" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32623
  }
 
32624
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32625
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32626
  if (!SWIG_IsOK(ecode2)) {
 
32627
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemBackgroundColour" "', expected argument " "2"" of type '" "long""'");
 
32628
  } 
 
32629
  arg2 = static_cast< long >(val2);
 
32630
  {
 
32631
    arg3 = &temp3;
 
32632
    if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
 
32633
  }
 
32634
  {
 
32635
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32636
    (arg1)->SetItemBackgroundColour(arg2,(wxColour const &)*arg3);
 
32637
    wxPyEndAllowThreads(__tstate);
 
32638
    if (PyErr_Occurred()) SWIG_fail;
 
32639
  }
 
32640
  resultobj = SWIG_Py_Void();
 
32641
  return resultobj;
 
32642
fail:
 
32643
  return NULL;
 
32644
}
 
32645
 
 
32646
 
 
32647
SWIGINTERN PyObject *_wrap_ListCtrl_GetItemBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32648
  PyObject *resultobj = 0;
 
32649
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32650
  long arg2 ;
 
32651
  wxColour result;
 
32652
  void *argp1 = 0 ;
 
32653
  int res1 = 0 ;
 
32654
  long val2 ;
 
32655
  int ecode2 = 0 ;
 
32656
  PyObject * obj0 = 0 ;
 
32657
  PyObject * obj1 = 0 ;
 
32658
  char *  kwnames[] = {
 
32659
    (char *) "self",(char *) "item", NULL 
 
32660
  };
 
32661
  
 
32662
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
32663
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32664
  if (!SWIG_IsOK(res1)) {
 
32665
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItemBackgroundColour" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
32666
  }
 
32667
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32668
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32669
  if (!SWIG_IsOK(ecode2)) {
 
32670
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetItemBackgroundColour" "', expected argument " "2"" of type '" "long""'");
 
32671
  } 
 
32672
  arg2 = static_cast< long >(val2);
 
32673
  {
 
32674
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32675
    result = ((wxPyListCtrl const *)arg1)->GetItemBackgroundColour(arg2);
 
32676
    wxPyEndAllowThreads(__tstate);
 
32677
    if (PyErr_Occurred()) SWIG_fail;
 
32678
  }
 
32679
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
32680
  return resultobj;
 
32681
fail:
 
32682
  return NULL;
 
32683
}
 
32684
 
 
32685
 
 
32686
SWIGINTERN PyObject *_wrap_ListCtrl_SetItemFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32687
  PyObject *resultobj = 0;
 
32688
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32689
  long arg2 ;
 
32690
  wxFont *arg3 = 0 ;
 
32691
  void *argp1 = 0 ;
 
32692
  int res1 = 0 ;
 
32693
  long val2 ;
 
32694
  int ecode2 = 0 ;
 
32695
  void *argp3 = 0 ;
 
32696
  int res3 = 0 ;
 
32697
  PyObject * obj0 = 0 ;
 
32698
  PyObject * obj1 = 0 ;
 
32699
  PyObject * obj2 = 0 ;
 
32700
  char *  kwnames[] = {
 
32701
    (char *) "self",(char *) "item",(char *) "f", NULL 
 
32702
  };
 
32703
  
 
32704
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListCtrl_SetItemFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
32705
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32706
  if (!SWIG_IsOK(res1)) {
 
32707
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SetItemFont" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32708
  }
 
32709
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32710
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32711
  if (!SWIG_IsOK(ecode2)) {
 
32712
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_SetItemFont" "', expected argument " "2"" of type '" "long""'");
 
32713
  } 
 
32714
  arg2 = static_cast< long >(val2);
 
32715
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxFont,  0  | 0);
 
32716
  if (!SWIG_IsOK(res3)) {
 
32717
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ListCtrl_SetItemFont" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
32718
  }
 
32719
  if (!argp3) {
 
32720
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListCtrl_SetItemFont" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
32721
  }
 
32722
  arg3 = reinterpret_cast< wxFont * >(argp3);
 
32723
  {
 
32724
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32725
    (arg1)->SetItemFont(arg2,(wxFont const &)*arg3);
 
32726
    wxPyEndAllowThreads(__tstate);
 
32727
    if (PyErr_Occurred()) SWIG_fail;
 
32728
  }
 
32729
  resultobj = SWIG_Py_Void();
 
32730
  return resultobj;
 
32731
fail:
 
32732
  return NULL;
 
32733
}
 
32734
 
 
32735
 
 
32736
SWIGINTERN PyObject *_wrap_ListCtrl_GetItemFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32737
  PyObject *resultobj = 0;
 
32738
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32739
  long arg2 ;
 
32740
  wxFont result;
 
32741
  void *argp1 = 0 ;
 
32742
  int res1 = 0 ;
 
32743
  long val2 ;
 
32744
  int ecode2 = 0 ;
 
32745
  PyObject * obj0 = 0 ;
 
32746
  PyObject * obj1 = 0 ;
 
32747
  char *  kwnames[] = {
 
32748
    (char *) "self",(char *) "item", NULL 
 
32749
  };
 
32750
  
 
32751
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_GetItemFont",kwnames,&obj0,&obj1)) SWIG_fail;
 
32752
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32753
  if (!SWIG_IsOK(res1)) {
 
32754
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetItemFont" "', expected argument " "1"" of type '" "wxPyListCtrl const *""'"); 
 
32755
  }
 
32756
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32757
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
32758
  if (!SWIG_IsOK(ecode2)) {
 
32759
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListCtrl_GetItemFont" "', expected argument " "2"" of type '" "long""'");
 
32760
  } 
 
32761
  arg2 = static_cast< long >(val2);
 
32762
  {
 
32763
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32764
    result = ((wxPyListCtrl const *)arg1)->GetItemFont(arg2);
 
32765
    wxPyEndAllowThreads(__tstate);
 
32766
    if (PyErr_Occurred()) SWIG_fail;
 
32767
  }
 
32768
  resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN |  0 );
 
32769
  return resultobj;
 
32770
fail:
 
32771
  return NULL;
 
32772
}
 
32773
 
 
32774
 
 
32775
SWIGINTERN PyObject *_wrap_ListCtrl_SortItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32776
  PyObject *resultobj = 0;
 
32777
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32778
  PyObject *arg2 = (PyObject *) 0 ;
 
32779
  bool result;
 
32780
  void *argp1 = 0 ;
 
32781
  int res1 = 0 ;
 
32782
  PyObject * obj0 = 0 ;
 
32783
  PyObject * obj1 = 0 ;
 
32784
  char *  kwnames[] = {
 
32785
    (char *) "self",(char *) "func", NULL 
 
32786
  };
 
32787
  
 
32788
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListCtrl_SortItems",kwnames,&obj0,&obj1)) SWIG_fail;
 
32789
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32790
  if (!SWIG_IsOK(res1)) {
 
32791
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_SortItems" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32792
  }
 
32793
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32794
  arg2 = obj1;
 
32795
  {
 
32796
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32797
    result = (bool)wxPyListCtrl_SortItems(arg1,arg2);
 
32798
    wxPyEndAllowThreads(__tstate);
 
32799
    if (PyErr_Occurred()) SWIG_fail;
 
32800
  }
 
32801
  {
 
32802
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
32803
  }
 
32804
  return resultobj;
 
32805
fail:
 
32806
  return NULL;
 
32807
}
 
32808
 
 
32809
 
 
32810
SWIGINTERN PyObject *_wrap_ListCtrl_GetMainWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
32811
  PyObject *resultobj = 0;
 
32812
  wxPyListCtrl *arg1 = (wxPyListCtrl *) 0 ;
 
32813
  wxWindow *result = 0 ;
 
32814
  void *argp1 = 0 ;
 
32815
  int res1 = 0 ;
 
32816
  PyObject *swig_obj[1] ;
 
32817
  
 
32818
  if (!args) SWIG_fail;
 
32819
  swig_obj[0] = args;
 
32820
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyListCtrl, 0 |  0 );
 
32821
  if (!SWIG_IsOK(res1)) {
 
32822
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListCtrl_GetMainWindow" "', expected argument " "1"" of type '" "wxPyListCtrl *""'"); 
 
32823
  }
 
32824
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
32825
  {
 
32826
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32827
    result = (wxWindow *)wxPyListCtrl_GetMainWindow(arg1);
 
32828
    wxPyEndAllowThreads(__tstate);
 
32829
    if (PyErr_Occurred()) SWIG_fail;
 
32830
  }
 
32831
  {
 
32832
    resultobj = wxPyMake_wxObject(result, 0); 
 
32833
  }
 
32834
  return resultobj;
 
32835
fail:
 
32836
  return NULL;
 
32837
}
 
32838
 
 
32839
 
 
32840
SWIGINTERN PyObject *_wrap_ListCtrl_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32841
  PyObject *resultobj = 0;
 
32842
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
32843
  SwigValueWrapper<wxVisualAttributes > result;
 
32844
  int val1 ;
 
32845
  int ecode1 = 0 ;
 
32846
  PyObject * obj0 = 0 ;
 
32847
  char *  kwnames[] = {
 
32848
    (char *) "variant", NULL 
 
32849
  };
 
32850
  
 
32851
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ListCtrl_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
32852
  if (obj0) {
 
32853
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
32854
    if (!SWIG_IsOK(ecode1)) {
 
32855
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ListCtrl_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
32856
    } 
 
32857
    arg1 = static_cast< wxWindowVariant >(val1);
 
32858
  }
 
32859
  {
 
32860
    if (!wxPyCheckForApp()) SWIG_fail;
 
32861
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32862
    result = wxPyListCtrl::GetClassDefaultAttributes(arg1);
 
32863
    wxPyEndAllowThreads(__tstate);
 
32864
    if (PyErr_Occurred()) SWIG_fail;
 
32865
  }
 
32866
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
32867
  return resultobj;
 
32868
fail:
 
32869
  return NULL;
 
32870
}
 
32871
 
 
32872
 
 
32873
SWIGINTERN PyObject *ListCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
32874
  PyObject *obj;
 
32875
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
32876
  SWIG_TypeNewClientData(SWIGTYPE_p_wxPyListCtrl, SWIG_NewClientData(obj));
 
32877
  return SWIG_Py_Void();
 
32878
}
 
32879
 
 
32880
SWIGINTERN PyObject *ListCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
32881
  return SWIG_Python_InitShadowInstance(args);
 
32882
}
 
32883
 
 
32884
SWIGINTERN PyObject *_wrap_new_ListView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
32885
  PyObject *resultobj = 0;
 
32886
  wxWindow *arg1 = (wxWindow *) 0 ;
 
32887
  int arg2 = (int) -1 ;
 
32888
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
32889
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
32890
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
32891
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
32892
  long arg5 = (long) wxLC_REPORT ;
 
32893
  wxValidator const &arg6_defvalue = wxDefaultValidator ;
 
32894
  wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
 
32895
  wxString const &arg7_defvalue = wxPyListCtrlNameStr ;
 
32896
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
32897
  wxListView *result = 0 ;
 
32898
  void *argp1 = 0 ;
 
32899
  int res1 = 0 ;
 
32900
  int val2 ;
 
32901
  int ecode2 = 0 ;
 
32902
  wxPoint temp3 ;
 
32903
  wxSize temp4 ;
 
32904
  long val5 ;
 
32905
  int ecode5 = 0 ;
 
32906
  void *argp6 = 0 ;
 
32907
  int res6 = 0 ;
 
32908
  bool temp7 = false ;
 
32909
  PyObject * obj0 = 0 ;
 
32910
  PyObject * obj1 = 0 ;
 
32911
  PyObject * obj2 = 0 ;
 
32912
  PyObject * obj3 = 0 ;
 
32913
  PyObject * obj4 = 0 ;
 
32914
  PyObject * obj5 = 0 ;
 
32915
  PyObject * obj6 = 0 ;
 
32916
  char *  kwnames[] = {
 
32917
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
32918
  };
 
32919
  
 
32920
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_ListView",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
32921
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
32922
  if (!SWIG_IsOK(res1)) {
 
32923
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListView" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
32924
  }
 
32925
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
32926
  if (obj1) {
 
32927
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
32928
    if (!SWIG_IsOK(ecode2)) {
 
32929
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListView" "', expected argument " "2"" of type '" "int""'");
 
32930
    } 
 
32931
    arg2 = static_cast< int >(val2);
 
32932
  }
 
32933
  if (obj2) {
 
32934
    {
 
32935
      arg3 = &temp3;
 
32936
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
32937
    }
 
32938
  }
 
32939
  if (obj3) {
 
32940
    {
 
32941
      arg4 = &temp4;
 
32942
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
32943
    }
 
32944
  }
 
32945
  if (obj4) {
 
32946
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
32947
    if (!SWIG_IsOK(ecode5)) {
 
32948
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ListView" "', expected argument " "5"" of type '" "long""'");
 
32949
    } 
 
32950
    arg5 = static_cast< long >(val5);
 
32951
  }
 
32952
  if (obj5) {
 
32953
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator,  0  | 0);
 
32954
    if (!SWIG_IsOK(res6)) {
 
32955
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ListView" "', expected argument " "6"" of type '" "wxValidator const &""'"); 
 
32956
    }
 
32957
    if (!argp6) {
 
32958
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListView" "', expected argument " "6"" of type '" "wxValidator const &""'"); 
 
32959
    }
 
32960
    arg6 = reinterpret_cast< wxValidator * >(argp6);
 
32961
  }
 
32962
  if (obj6) {
 
32963
    {
 
32964
      arg7 = wxString_in_helper(obj6);
 
32965
      if (arg7 == NULL) SWIG_fail;
 
32966
      temp7 = true;
 
32967
    }
 
32968
  }
 
32969
  {
 
32970
    if (!wxPyCheckForApp()) SWIG_fail;
 
32971
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32972
    result = (wxListView *)new wxListView(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
 
32973
    wxPyEndAllowThreads(__tstate);
 
32974
    if (PyErr_Occurred()) SWIG_fail;
 
32975
  }
 
32976
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListView, SWIG_POINTER_NEW |  0 );
 
32977
  {
 
32978
    if (temp7)
 
32979
    delete arg7;
 
32980
  }
 
32981
  return resultobj;
 
32982
fail:
 
32983
  {
 
32984
    if (temp7)
 
32985
    delete arg7;
 
32986
  }
 
32987
  return NULL;
 
32988
}
 
32989
 
 
32990
 
 
32991
SWIGINTERN PyObject *_wrap_new_PreListView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
32992
  PyObject *resultobj = 0;
 
32993
  wxListView *result = 0 ;
 
32994
  
 
32995
  if (!SWIG_Python_UnpackTuple(args,"new_PreListView",0,0,0)) SWIG_fail;
 
32996
  {
 
32997
    if (!wxPyCheckForApp()) SWIG_fail;
 
32998
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
32999
    result = (wxListView *)new wxListView();
 
33000
    wxPyEndAllowThreads(__tstate);
 
33001
    if (PyErr_Occurred()) SWIG_fail;
 
33002
  }
 
33003
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxListView, SWIG_POINTER_OWN |  0 );
 
33004
  return resultobj;
 
33005
fail:
 
33006
  return NULL;
 
33007
}
 
33008
 
 
33009
 
 
33010
SWIGINTERN PyObject *_wrap_ListView_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33011
  PyObject *resultobj = 0;
 
33012
  wxListView *arg1 = (wxListView *) 0 ;
 
33013
  wxWindow *arg2 = (wxWindow *) 0 ;
 
33014
  int arg3 = (int) -1 ;
 
33015
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
33016
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
33017
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
33018
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
33019
  long arg6 = (long) wxLC_REPORT ;
 
33020
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
33021
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
33022
  wxString const &arg8_defvalue = wxPyListCtrlNameStr ;
 
33023
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
33024
  bool result;
 
33025
  void *argp1 = 0 ;
 
33026
  int res1 = 0 ;
 
33027
  void *argp2 = 0 ;
 
33028
  int res2 = 0 ;
 
33029
  int val3 ;
 
33030
  int ecode3 = 0 ;
 
33031
  wxPoint temp4 ;
 
33032
  wxSize temp5 ;
 
33033
  long val6 ;
 
33034
  int ecode6 = 0 ;
 
33035
  void *argp7 = 0 ;
 
33036
  int res7 = 0 ;
 
33037
  bool temp8 = false ;
 
33038
  PyObject * obj0 = 0 ;
 
33039
  PyObject * obj1 = 0 ;
 
33040
  PyObject * obj2 = 0 ;
 
33041
  PyObject * obj3 = 0 ;
 
33042
  PyObject * obj4 = 0 ;
 
33043
  PyObject * obj5 = 0 ;
 
33044
  PyObject * obj6 = 0 ;
 
33045
  PyObject * obj7 = 0 ;
 
33046
  char *  kwnames[] = {
 
33047
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
33048
  };
 
33049
  
 
33050
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:ListView_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
33051
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListView, 0 |  0 );
 
33052
  if (!SWIG_IsOK(res1)) {
 
33053
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListView_Create" "', expected argument " "1"" of type '" "wxListView *""'"); 
 
33054
  }
 
33055
  arg1 = reinterpret_cast< wxListView * >(argp1);
 
33056
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
33057
  if (!SWIG_IsOK(res2)) {
 
33058
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListView_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
33059
  }
 
33060
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
33061
  if (obj2) {
 
33062
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
33063
    if (!SWIG_IsOK(ecode3)) {
 
33064
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListView_Create" "', expected argument " "3"" of type '" "int""'");
 
33065
    } 
 
33066
    arg3 = static_cast< int >(val3);
 
33067
  }
 
33068
  if (obj3) {
 
33069
    {
 
33070
      arg4 = &temp4;
 
33071
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
33072
    }
 
33073
  }
 
33074
  if (obj4) {
 
33075
    {
 
33076
      arg5 = &temp5;
 
33077
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
33078
    }
 
33079
  }
 
33080
  if (obj5) {
 
33081
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
33082
    if (!SWIG_IsOK(ecode6)) {
 
33083
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ListView_Create" "', expected argument " "6"" of type '" "long""'");
 
33084
    } 
 
33085
    arg6 = static_cast< long >(val6);
 
33086
  }
 
33087
  if (obj6) {
 
33088
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
33089
    if (!SWIG_IsOK(res7)) {
 
33090
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ListView_Create" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
33091
    }
 
33092
    if (!argp7) {
 
33093
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListView_Create" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
33094
    }
 
33095
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
33096
  }
 
33097
  if (obj7) {
 
33098
    {
 
33099
      arg8 = wxString_in_helper(obj7);
 
33100
      if (arg8 == NULL) SWIG_fail;
 
33101
      temp8 = true;
 
33102
    }
 
33103
  }
 
33104
  {
 
33105
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33106
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
33107
    wxPyEndAllowThreads(__tstate);
 
33108
    if (PyErr_Occurred()) SWIG_fail;
 
33109
  }
 
33110
  {
 
33111
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
33112
  }
 
33113
  {
 
33114
    if (temp8)
 
33115
    delete arg8;
 
33116
  }
 
33117
  return resultobj;
 
33118
fail:
 
33119
  {
 
33120
    if (temp8)
 
33121
    delete arg8;
 
33122
  }
 
33123
  return NULL;
 
33124
}
 
33125
 
 
33126
 
 
33127
SWIGINTERN PyObject *_wrap_ListView_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33128
  PyObject *resultobj = 0;
 
33129
  wxListView *arg1 = (wxListView *) 0 ;
 
33130
  long arg2 ;
 
33131
  bool arg3 = (bool) true ;
 
33132
  void *argp1 = 0 ;
 
33133
  int res1 = 0 ;
 
33134
  long val2 ;
 
33135
  int ecode2 = 0 ;
 
33136
  bool val3 ;
 
33137
  int ecode3 = 0 ;
 
33138
  PyObject * obj0 = 0 ;
 
33139
  PyObject * obj1 = 0 ;
 
33140
  PyObject * obj2 = 0 ;
 
33141
  char *  kwnames[] = {
 
33142
    (char *) "self",(char *) "n",(char *) "on", NULL 
 
33143
  };
 
33144
  
 
33145
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ListView_Select",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
33146
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListView, 0 |  0 );
 
33147
  if (!SWIG_IsOK(res1)) {
 
33148
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListView_Select" "', expected argument " "1"" of type '" "wxListView *""'"); 
 
33149
  }
 
33150
  arg1 = reinterpret_cast< wxListView * >(argp1);
 
33151
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
33152
  if (!SWIG_IsOK(ecode2)) {
 
33153
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListView_Select" "', expected argument " "2"" of type '" "long""'");
 
33154
  } 
 
33155
  arg2 = static_cast< long >(val2);
 
33156
  if (obj2) {
 
33157
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
33158
    if (!SWIG_IsOK(ecode3)) {
 
33159
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListView_Select" "', expected argument " "3"" of type '" "bool""'");
 
33160
    } 
 
33161
    arg3 = static_cast< bool >(val3);
 
33162
  }
 
33163
  {
 
33164
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33165
    (arg1)->Select(arg2,arg3);
 
33166
    wxPyEndAllowThreads(__tstate);
 
33167
    if (PyErr_Occurred()) SWIG_fail;
 
33168
  }
 
33169
  resultobj = SWIG_Py_Void();
 
33170
  return resultobj;
 
33171
fail:
 
33172
  return NULL;
 
33173
}
 
33174
 
 
33175
 
 
33176
SWIGINTERN PyObject *_wrap_ListView_Focus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33177
  PyObject *resultobj = 0;
 
33178
  wxListView *arg1 = (wxListView *) 0 ;
 
33179
  long arg2 ;
 
33180
  void *argp1 = 0 ;
 
33181
  int res1 = 0 ;
 
33182
  long val2 ;
 
33183
  int ecode2 = 0 ;
 
33184
  PyObject * obj0 = 0 ;
 
33185
  PyObject * obj1 = 0 ;
 
33186
  char *  kwnames[] = {
 
33187
    (char *) "self",(char *) "index", NULL 
 
33188
  };
 
33189
  
 
33190
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_Focus",kwnames,&obj0,&obj1)) SWIG_fail;
 
33191
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListView, 0 |  0 );
 
33192
  if (!SWIG_IsOK(res1)) {
 
33193
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListView_Focus" "', expected argument " "1"" of type '" "wxListView *""'"); 
 
33194
  }
 
33195
  arg1 = reinterpret_cast< wxListView * >(argp1);
 
33196
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
33197
  if (!SWIG_IsOK(ecode2)) {
 
33198
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListView_Focus" "', expected argument " "2"" of type '" "long""'");
 
33199
  } 
 
33200
  arg2 = static_cast< long >(val2);
 
33201
  {
 
33202
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33203
    (arg1)->Focus(arg2);
 
33204
    wxPyEndAllowThreads(__tstate);
 
33205
    if (PyErr_Occurred()) SWIG_fail;
 
33206
  }
 
33207
  resultobj = SWIG_Py_Void();
 
33208
  return resultobj;
 
33209
fail:
 
33210
  return NULL;
 
33211
}
 
33212
 
 
33213
 
 
33214
SWIGINTERN PyObject *_wrap_ListView_GetFocusedItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33215
  PyObject *resultobj = 0;
 
33216
  wxListView *arg1 = (wxListView *) 0 ;
 
33217
  long result;
 
33218
  void *argp1 = 0 ;
 
33219
  int res1 = 0 ;
 
33220
  PyObject *swig_obj[1] ;
 
33221
  
 
33222
  if (!args) SWIG_fail;
 
33223
  swig_obj[0] = args;
 
33224
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListView, 0 |  0 );
 
33225
  if (!SWIG_IsOK(res1)) {
 
33226
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListView_GetFocusedItem" "', expected argument " "1"" of type '" "wxListView const *""'"); 
 
33227
  }
 
33228
  arg1 = reinterpret_cast< wxListView * >(argp1);
 
33229
  {
 
33230
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33231
    result = (long)((wxListView const *)arg1)->GetFocusedItem();
 
33232
    wxPyEndAllowThreads(__tstate);
 
33233
    if (PyErr_Occurred()) SWIG_fail;
 
33234
  }
 
33235
  resultobj = SWIG_From_long(static_cast< long >(result));
 
33236
  return resultobj;
 
33237
fail:
 
33238
  return NULL;
 
33239
}
 
33240
 
 
33241
 
 
33242
SWIGINTERN PyObject *_wrap_ListView_GetNextSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33243
  PyObject *resultobj = 0;
 
33244
  wxListView *arg1 = (wxListView *) 0 ;
 
33245
  long arg2 ;
 
33246
  long result;
 
33247
  void *argp1 = 0 ;
 
33248
  int res1 = 0 ;
 
33249
  long val2 ;
 
33250
  int ecode2 = 0 ;
 
33251
  PyObject * obj0 = 0 ;
 
33252
  PyObject * obj1 = 0 ;
 
33253
  char *  kwnames[] = {
 
33254
    (char *) "self",(char *) "item", NULL 
 
33255
  };
 
33256
  
 
33257
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_GetNextSelected",kwnames,&obj0,&obj1)) SWIG_fail;
 
33258
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListView, 0 |  0 );
 
33259
  if (!SWIG_IsOK(res1)) {
 
33260
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListView_GetNextSelected" "', expected argument " "1"" of type '" "wxListView const *""'"); 
 
33261
  }
 
33262
  arg1 = reinterpret_cast< wxListView * >(argp1);
 
33263
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
33264
  if (!SWIG_IsOK(ecode2)) {
 
33265
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListView_GetNextSelected" "', expected argument " "2"" of type '" "long""'");
 
33266
  } 
 
33267
  arg2 = static_cast< long >(val2);
 
33268
  {
 
33269
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33270
    result = (long)((wxListView const *)arg1)->GetNextSelected(arg2);
 
33271
    wxPyEndAllowThreads(__tstate);
 
33272
    if (PyErr_Occurred()) SWIG_fail;
 
33273
  }
 
33274
  resultobj = SWIG_From_long(static_cast< long >(result));
 
33275
  return resultobj;
 
33276
fail:
 
33277
  return NULL;
 
33278
}
 
33279
 
 
33280
 
 
33281
SWIGINTERN PyObject *_wrap_ListView_GetFirstSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33282
  PyObject *resultobj = 0;
 
33283
  wxListView *arg1 = (wxListView *) 0 ;
 
33284
  long result;
 
33285
  void *argp1 = 0 ;
 
33286
  int res1 = 0 ;
 
33287
  PyObject *swig_obj[1] ;
 
33288
  
 
33289
  if (!args) SWIG_fail;
 
33290
  swig_obj[0] = args;
 
33291
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxListView, 0 |  0 );
 
33292
  if (!SWIG_IsOK(res1)) {
 
33293
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListView_GetFirstSelected" "', expected argument " "1"" of type '" "wxListView const *""'"); 
 
33294
  }
 
33295
  arg1 = reinterpret_cast< wxListView * >(argp1);
 
33296
  {
 
33297
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33298
    result = (long)((wxListView const *)arg1)->GetFirstSelected();
 
33299
    wxPyEndAllowThreads(__tstate);
 
33300
    if (PyErr_Occurred()) SWIG_fail;
 
33301
  }
 
33302
  resultobj = SWIG_From_long(static_cast< long >(result));
 
33303
  return resultobj;
 
33304
fail:
 
33305
  return NULL;
 
33306
}
 
33307
 
 
33308
 
 
33309
SWIGINTERN PyObject *_wrap_ListView_IsSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33310
  PyObject *resultobj = 0;
 
33311
  wxListView *arg1 = (wxListView *) 0 ;
 
33312
  long arg2 ;
 
33313
  bool result;
 
33314
  void *argp1 = 0 ;
 
33315
  int res1 = 0 ;
 
33316
  long val2 ;
 
33317
  int ecode2 = 0 ;
 
33318
  PyObject * obj0 = 0 ;
 
33319
  PyObject * obj1 = 0 ;
 
33320
  char *  kwnames[] = {
 
33321
    (char *) "self",(char *) "index", NULL 
 
33322
  };
 
33323
  
 
33324
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_IsSelected",kwnames,&obj0,&obj1)) SWIG_fail;
 
33325
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListView, 0 |  0 );
 
33326
  if (!SWIG_IsOK(res1)) {
 
33327
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListView_IsSelected" "', expected argument " "1"" of type '" "wxListView *""'"); 
 
33328
  }
 
33329
  arg1 = reinterpret_cast< wxListView * >(argp1);
 
33330
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
33331
  if (!SWIG_IsOK(ecode2)) {
 
33332
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListView_IsSelected" "', expected argument " "2"" of type '" "long""'");
 
33333
  } 
 
33334
  arg2 = static_cast< long >(val2);
 
33335
  {
 
33336
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33337
    result = (bool)(arg1)->IsSelected(arg2);
 
33338
    wxPyEndAllowThreads(__tstate);
 
33339
    if (PyErr_Occurred()) SWIG_fail;
 
33340
  }
 
33341
  {
 
33342
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
33343
  }
 
33344
  return resultobj;
 
33345
fail:
 
33346
  return NULL;
 
33347
}
 
33348
 
 
33349
 
 
33350
SWIGINTERN PyObject *_wrap_ListView_SetColumnImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33351
  PyObject *resultobj = 0;
 
33352
  wxListView *arg1 = (wxListView *) 0 ;
 
33353
  int arg2 ;
 
33354
  int arg3 ;
 
33355
  void *argp1 = 0 ;
 
33356
  int res1 = 0 ;
 
33357
  int val2 ;
 
33358
  int ecode2 = 0 ;
 
33359
  int val3 ;
 
33360
  int ecode3 = 0 ;
 
33361
  PyObject * obj0 = 0 ;
 
33362
  PyObject * obj1 = 0 ;
 
33363
  PyObject * obj2 = 0 ;
 
33364
  char *  kwnames[] = {
 
33365
    (char *) "self",(char *) "col",(char *) "image", NULL 
 
33366
  };
 
33367
  
 
33368
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ListView_SetColumnImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
33369
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListView, 0 |  0 );
 
33370
  if (!SWIG_IsOK(res1)) {
 
33371
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListView_SetColumnImage" "', expected argument " "1"" of type '" "wxListView *""'"); 
 
33372
  }
 
33373
  arg1 = reinterpret_cast< wxListView * >(argp1);
 
33374
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
33375
  if (!SWIG_IsOK(ecode2)) {
 
33376
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListView_SetColumnImage" "', expected argument " "2"" of type '" "int""'");
 
33377
  } 
 
33378
  arg2 = static_cast< int >(val2);
 
33379
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
33380
  if (!SWIG_IsOK(ecode3)) {
 
33381
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListView_SetColumnImage" "', expected argument " "3"" of type '" "int""'");
 
33382
  } 
 
33383
  arg3 = static_cast< int >(val3);
 
33384
  {
 
33385
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33386
    (arg1)->SetColumnImage(arg2,arg3);
 
33387
    wxPyEndAllowThreads(__tstate);
 
33388
    if (PyErr_Occurred()) SWIG_fail;
 
33389
  }
 
33390
  resultobj = SWIG_Py_Void();
 
33391
  return resultobj;
 
33392
fail:
 
33393
  return NULL;
 
33394
}
 
33395
 
 
33396
 
 
33397
SWIGINTERN PyObject *_wrap_ListView_ClearColumnImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33398
  PyObject *resultobj = 0;
 
33399
  wxListView *arg1 = (wxListView *) 0 ;
 
33400
  int arg2 ;
 
33401
  void *argp1 = 0 ;
 
33402
  int res1 = 0 ;
 
33403
  int val2 ;
 
33404
  int ecode2 = 0 ;
 
33405
  PyObject * obj0 = 0 ;
 
33406
  PyObject * obj1 = 0 ;
 
33407
  char *  kwnames[] = {
 
33408
    (char *) "self",(char *) "col", NULL 
 
33409
  };
 
33410
  
 
33411
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListView_ClearColumnImage",kwnames,&obj0,&obj1)) SWIG_fail;
 
33412
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxListView, 0 |  0 );
 
33413
  if (!SWIG_IsOK(res1)) {
 
33414
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListView_ClearColumnImage" "', expected argument " "1"" of type '" "wxListView *""'"); 
 
33415
  }
 
33416
  arg1 = reinterpret_cast< wxListView * >(argp1);
 
33417
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
33418
  if (!SWIG_IsOK(ecode2)) {
 
33419
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListView_ClearColumnImage" "', expected argument " "2"" of type '" "int""'");
 
33420
  } 
 
33421
  arg2 = static_cast< int >(val2);
 
33422
  {
 
33423
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33424
    (arg1)->ClearColumnImage(arg2);
 
33425
    wxPyEndAllowThreads(__tstate);
 
33426
    if (PyErr_Occurred()) SWIG_fail;
 
33427
  }
 
33428
  resultobj = SWIG_Py_Void();
 
33429
  return resultobj;
 
33430
fail:
 
33431
  return NULL;
 
33432
}
 
33433
 
 
33434
 
 
33435
SWIGINTERN PyObject *ListView_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33436
  PyObject *obj;
 
33437
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
33438
  SWIG_TypeNewClientData(SWIGTYPE_p_wxListView, SWIG_NewClientData(obj));
 
33439
  return SWIG_Py_Void();
 
33440
}
 
33441
 
 
33442
SWIGINTERN PyObject *ListView_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33443
  return SWIG_Python_InitShadowInstance(args);
 
33444
}
 
33445
 
 
33446
SWIGINTERN int TreeCtrlNameStr_set(PyObject *) {
 
33447
  SWIG_Error(SWIG_AttributeError,"Variable TreeCtrlNameStr is read-only.");
 
33448
  return 1;
 
33449
}
 
33450
 
 
33451
 
 
33452
SWIGINTERN PyObject *TreeCtrlNameStr_get(void) {
 
33453
  PyObject *pyobj = 0;
 
33454
  
 
33455
  {
 
33456
#if wxUSE_UNICODE
 
33457
    pyobj = PyUnicode_FromWideChar((&wxPyTreeCtrlNameStr)->c_str(), (&wxPyTreeCtrlNameStr)->Len());
 
33458
#else
 
33459
    pyobj = PyString_FromStringAndSize((&wxPyTreeCtrlNameStr)->c_str(), (&wxPyTreeCtrlNameStr)->Len());
 
33460
#endif
 
33461
  }
 
33462
  return pyobj;
 
33463
}
 
33464
 
 
33465
 
 
33466
SWIGINTERN PyObject *_wrap_new_TreeItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33467
  PyObject *resultobj = 0;
 
33468
  wxTreeItemId *result = 0 ;
 
33469
  
 
33470
  if (!SWIG_Python_UnpackTuple(args,"new_TreeItemId",0,0,0)) SWIG_fail;
 
33471
  {
 
33472
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33473
    result = (wxTreeItemId *)new wxTreeItemId();
 
33474
    wxPyEndAllowThreads(__tstate);
 
33475
    if (PyErr_Occurred()) SWIG_fail;
 
33476
  }
 
33477
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_NEW |  0 );
 
33478
  return resultobj;
 
33479
fail:
 
33480
  return NULL;
 
33481
}
 
33482
 
 
33483
 
 
33484
SWIGINTERN PyObject *_wrap_delete_TreeItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33485
  PyObject *resultobj = 0;
 
33486
  wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
 
33487
  void *argp1 = 0 ;
 
33488
  int res1 = 0 ;
 
33489
  PyObject *swig_obj[1] ;
 
33490
  
 
33491
  if (!args) SWIG_fail;
 
33492
  swig_obj[0] = args;
 
33493
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_DISOWN |  0 );
 
33494
  if (!SWIG_IsOK(res1)) {
 
33495
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TreeItemId" "', expected argument " "1"" of type '" "wxTreeItemId *""'"); 
 
33496
  }
 
33497
  arg1 = reinterpret_cast< wxTreeItemId * >(argp1);
 
33498
  {
 
33499
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33500
    delete arg1;
 
33501
    
 
33502
    wxPyEndAllowThreads(__tstate);
 
33503
    if (PyErr_Occurred()) SWIG_fail;
 
33504
  }
 
33505
  resultobj = SWIG_Py_Void();
 
33506
  return resultobj;
 
33507
fail:
 
33508
  return NULL;
 
33509
}
 
33510
 
 
33511
 
 
33512
SWIGINTERN PyObject *_wrap_TreeItemId_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33513
  PyObject *resultobj = 0;
 
33514
  wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
 
33515
  bool result;
 
33516
  void *argp1 = 0 ;
 
33517
  int res1 = 0 ;
 
33518
  PyObject *swig_obj[1] ;
 
33519
  
 
33520
  if (!args) SWIG_fail;
 
33521
  swig_obj[0] = args;
 
33522
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeItemId, 0 |  0 );
 
33523
  if (!SWIG_IsOK(res1)) {
 
33524
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeItemId_IsOk" "', expected argument " "1"" of type '" "wxTreeItemId const *""'"); 
 
33525
  }
 
33526
  arg1 = reinterpret_cast< wxTreeItemId * >(argp1);
 
33527
  {
 
33528
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33529
    result = (bool)((wxTreeItemId const *)arg1)->IsOk();
 
33530
    wxPyEndAllowThreads(__tstate);
 
33531
    if (PyErr_Occurred()) SWIG_fail;
 
33532
  }
 
33533
  {
 
33534
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
33535
  }
 
33536
  return resultobj;
 
33537
fail:
 
33538
  return NULL;
 
33539
}
 
33540
 
 
33541
 
 
33542
SWIGINTERN PyObject *_wrap_TreeItemId___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33543
  PyObject *resultobj = 0;
 
33544
  wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
 
33545
  wxTreeItemId *arg2 = (wxTreeItemId *) 0 ;
 
33546
  bool result;
 
33547
  void *argp1 = 0 ;
 
33548
  int res1 = 0 ;
 
33549
  void *argp2 = 0 ;
 
33550
  int res2 = 0 ;
 
33551
  PyObject * obj0 = 0 ;
 
33552
  PyObject * obj1 = 0 ;
 
33553
  char *  kwnames[] = {
 
33554
    (char *) "self",(char *) "other", NULL 
 
33555
  };
 
33556
  
 
33557
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemId___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
 
33558
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreeItemId, 0 |  0 );
 
33559
  if (!SWIG_IsOK(res1)) {
 
33560
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeItemId___eq__" "', expected argument " "1"" of type '" "wxTreeItemId *""'"); 
 
33561
  }
 
33562
  arg1 = reinterpret_cast< wxTreeItemId * >(argp1);
 
33563
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTreeItemId, 0 |  0 );
 
33564
  if (!SWIG_IsOK(res2)) {
 
33565
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeItemId___eq__" "', expected argument " "2"" of type '" "wxTreeItemId const *""'"); 
 
33566
  }
 
33567
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
33568
  {
 
33569
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33570
    result = (bool)wxTreeItemId___eq__(arg1,(wxTreeItemId const *)arg2);
 
33571
    wxPyEndAllowThreads(__tstate);
 
33572
    if (PyErr_Occurred()) SWIG_fail;
 
33573
  }
 
33574
  {
 
33575
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
33576
  }
 
33577
  return resultobj;
 
33578
fail:
 
33579
  return NULL;
 
33580
}
 
33581
 
 
33582
 
 
33583
SWIGINTERN PyObject *_wrap_TreeItemId___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33584
  PyObject *resultobj = 0;
 
33585
  wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
 
33586
  wxTreeItemId *arg2 = (wxTreeItemId *) 0 ;
 
33587
  bool result;
 
33588
  void *argp1 = 0 ;
 
33589
  int res1 = 0 ;
 
33590
  void *argp2 = 0 ;
 
33591
  int res2 = 0 ;
 
33592
  PyObject * obj0 = 0 ;
 
33593
  PyObject * obj1 = 0 ;
 
33594
  char *  kwnames[] = {
 
33595
    (char *) "self",(char *) "other", NULL 
 
33596
  };
 
33597
  
 
33598
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemId___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
 
33599
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreeItemId, 0 |  0 );
 
33600
  if (!SWIG_IsOK(res1)) {
 
33601
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeItemId___ne__" "', expected argument " "1"" of type '" "wxTreeItemId *""'"); 
 
33602
  }
 
33603
  arg1 = reinterpret_cast< wxTreeItemId * >(argp1);
 
33604
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTreeItemId, 0 |  0 );
 
33605
  if (!SWIG_IsOK(res2)) {
 
33606
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeItemId___ne__" "', expected argument " "2"" of type '" "wxTreeItemId const *""'"); 
 
33607
  }
 
33608
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
33609
  {
 
33610
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33611
    result = (bool)wxTreeItemId___ne__(arg1,(wxTreeItemId const *)arg2);
 
33612
    wxPyEndAllowThreads(__tstate);
 
33613
    if (PyErr_Occurred()) SWIG_fail;
 
33614
  }
 
33615
  {
 
33616
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
33617
  }
 
33618
  return resultobj;
 
33619
fail:
 
33620
  return NULL;
 
33621
}
 
33622
 
 
33623
 
 
33624
SWIGINTERN PyObject *_wrap_TreeItemId_m_pItem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33625
  PyObject *resultobj = 0;
 
33626
  wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
 
33627
  void *arg2 = (void *) 0 ;
 
33628
  void *argp1 = 0 ;
 
33629
  int res1 = 0 ;
 
33630
  int res2 ;
 
33631
  PyObject *swig_obj[2] ;
 
33632
  
 
33633
  if (!SWIG_Python_UnpackTuple(args,"TreeItemId_m_pItem_set",2,2,swig_obj)) SWIG_fail;
 
33634
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeItemId, 0 |  0 );
 
33635
  if (!SWIG_IsOK(res1)) {
 
33636
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeItemId_m_pItem_set" "', expected argument " "1"" of type '" "wxTreeItemId *""'"); 
 
33637
  }
 
33638
  arg1 = reinterpret_cast< wxTreeItemId * >(argp1);
 
33639
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
 
33640
  if (!SWIG_IsOK(res2)) {
 
33641
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeItemId_m_pItem_set" "', expected argument " "2"" of type '" "void *""'"); 
 
33642
  }
 
33643
  if (arg1) (arg1)->m_pItem = arg2;
 
33644
  
 
33645
  resultobj = SWIG_Py_Void();
 
33646
  return resultobj;
 
33647
fail:
 
33648
  return NULL;
 
33649
}
 
33650
 
 
33651
 
 
33652
SWIGINTERN PyObject *_wrap_TreeItemId_m_pItem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33653
  PyObject *resultobj = 0;
 
33654
  wxTreeItemId *arg1 = (wxTreeItemId *) 0 ;
 
33655
  void *result = 0 ;
 
33656
  void *argp1 = 0 ;
 
33657
  int res1 = 0 ;
 
33658
  PyObject *swig_obj[1] ;
 
33659
  
 
33660
  if (!args) SWIG_fail;
 
33661
  swig_obj[0] = args;
 
33662
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeItemId, 0 |  0 );
 
33663
  if (!SWIG_IsOK(res1)) {
 
33664
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeItemId_m_pItem_get" "', expected argument " "1"" of type '" "wxTreeItemId *""'"); 
 
33665
  }
 
33666
  arg1 = reinterpret_cast< wxTreeItemId * >(argp1);
 
33667
  result = (void *) ((arg1)->m_pItem);
 
33668
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
 
33669
  return resultobj;
 
33670
fail:
 
33671
  return NULL;
 
33672
}
 
33673
 
 
33674
 
 
33675
SWIGINTERN PyObject *TreeItemId_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33676
  PyObject *obj;
 
33677
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
33678
  SWIG_TypeNewClientData(SWIGTYPE_p_wxTreeItemId, SWIG_NewClientData(obj));
 
33679
  return SWIG_Py_Void();
 
33680
}
 
33681
 
 
33682
SWIGINTERN PyObject *TreeItemId_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33683
  return SWIG_Python_InitShadowInstance(args);
 
33684
}
 
33685
 
 
33686
SWIGINTERN PyObject *_wrap_new_TreeItemData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33687
  PyObject *resultobj = 0;
 
33688
  PyObject *arg1 = (PyObject *) NULL ;
 
33689
  wxPyTreeItemData *result = 0 ;
 
33690
  PyObject * obj0 = 0 ;
 
33691
  char *  kwnames[] = {
 
33692
    (char *) "obj", NULL 
 
33693
  };
 
33694
  
 
33695
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TreeItemData",kwnames,&obj0)) SWIG_fail;
 
33696
  if (obj0) {
 
33697
    arg1 = obj0;
 
33698
  }
 
33699
  {
 
33700
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33701
    result = (wxPyTreeItemData *)new wxPyTreeItemData(arg1);
 
33702
    wxPyEndAllowThreads(__tstate);
 
33703
    if (PyErr_Occurred()) SWIG_fail;
 
33704
  }
 
33705
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_NEW |  0 );
 
33706
  return resultobj;
 
33707
fail:
 
33708
  return NULL;
 
33709
}
 
33710
 
 
33711
 
 
33712
SWIGINTERN PyObject *_wrap_delete_TreeItemData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33713
  PyObject *resultobj = 0;
 
33714
  wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
 
33715
  void *argp1 = 0 ;
 
33716
  int res1 = 0 ;
 
33717
  PyObject *swig_obj[1] ;
 
33718
  
 
33719
  if (!args) SWIG_fail;
 
33720
  swig_obj[0] = args;
 
33721
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_DISOWN |  0 );
 
33722
  if (!SWIG_IsOK(res1)) {
 
33723
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TreeItemData" "', expected argument " "1"" of type '" "wxPyTreeItemData *""'"); 
 
33724
  }
 
33725
  arg1 = reinterpret_cast< wxPyTreeItemData * >(argp1);
 
33726
  {
 
33727
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33728
    delete arg1;
 
33729
    
 
33730
    wxPyEndAllowThreads(__tstate);
 
33731
    if (PyErr_Occurred()) SWIG_fail;
 
33732
  }
 
33733
  resultobj = SWIG_Py_Void();
 
33734
  return resultobj;
 
33735
fail:
 
33736
  return NULL;
 
33737
}
 
33738
 
 
33739
 
 
33740
SWIGINTERN PyObject *_wrap_TreeItemData_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33741
  PyObject *resultobj = 0;
 
33742
  wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
 
33743
  PyObject *result = 0 ;
 
33744
  void *argp1 = 0 ;
 
33745
  int res1 = 0 ;
 
33746
  PyObject *swig_obj[1] ;
 
33747
  
 
33748
  if (!args) SWIG_fail;
 
33749
  swig_obj[0] = args;
 
33750
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeItemData, 0 |  0 );
 
33751
  if (!SWIG_IsOK(res1)) {
 
33752
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeItemData_GetData" "', expected argument " "1"" of type '" "wxPyTreeItemData *""'"); 
 
33753
  }
 
33754
  arg1 = reinterpret_cast< wxPyTreeItemData * >(argp1);
 
33755
  {
 
33756
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33757
    result = (PyObject *)(arg1)->GetData();
 
33758
    wxPyEndAllowThreads(__tstate);
 
33759
    if (PyErr_Occurred()) SWIG_fail;
 
33760
  }
 
33761
  resultobj = result;
 
33762
  return resultobj;
 
33763
fail:
 
33764
  return NULL;
 
33765
}
 
33766
 
 
33767
 
 
33768
SWIGINTERN PyObject *_wrap_TreeItemData_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33769
  PyObject *resultobj = 0;
 
33770
  wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
 
33771
  PyObject *arg2 = (PyObject *) 0 ;
 
33772
  void *argp1 = 0 ;
 
33773
  int res1 = 0 ;
 
33774
  PyObject * obj0 = 0 ;
 
33775
  PyObject * obj1 = 0 ;
 
33776
  char *  kwnames[] = {
 
33777
    (char *) "self",(char *) "obj", NULL 
 
33778
  };
 
33779
  
 
33780
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemData_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
 
33781
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeItemData, 0 |  0 );
 
33782
  if (!SWIG_IsOK(res1)) {
 
33783
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeItemData_SetData" "', expected argument " "1"" of type '" "wxPyTreeItemData *""'"); 
 
33784
  }
 
33785
  arg1 = reinterpret_cast< wxPyTreeItemData * >(argp1);
 
33786
  arg2 = obj1;
 
33787
  {
 
33788
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33789
    (arg1)->SetData(arg2);
 
33790
    wxPyEndAllowThreads(__tstate);
 
33791
    if (PyErr_Occurred()) SWIG_fail;
 
33792
  }
 
33793
  resultobj = SWIG_Py_Void();
 
33794
  return resultobj;
 
33795
fail:
 
33796
  return NULL;
 
33797
}
 
33798
 
 
33799
 
 
33800
SWIGINTERN PyObject *_wrap_TreeItemData_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33801
  PyObject *resultobj = 0;
 
33802
  wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
 
33803
  wxTreeItemId *result = 0 ;
 
33804
  void *argp1 = 0 ;
 
33805
  int res1 = 0 ;
 
33806
  PyObject *swig_obj[1] ;
 
33807
  
 
33808
  if (!args) SWIG_fail;
 
33809
  swig_obj[0] = args;
 
33810
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeItemData, 0 |  0 );
 
33811
  if (!SWIG_IsOK(res1)) {
 
33812
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeItemData_GetId" "', expected argument " "1"" of type '" "wxPyTreeItemData *""'"); 
 
33813
  }
 
33814
  arg1 = reinterpret_cast< wxPyTreeItemData * >(argp1);
 
33815
  {
 
33816
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33817
    {
 
33818
      wxTreeItemId const &_result_ref = (arg1)->GetId();
 
33819
      result = (wxTreeItemId *) &_result_ref;
 
33820
    }
 
33821
    wxPyEndAllowThreads(__tstate);
 
33822
    if (PyErr_Occurred()) SWIG_fail;
 
33823
  }
 
33824
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTreeItemId, 0 |  0 );
 
33825
  return resultobj;
 
33826
fail:
 
33827
  return NULL;
 
33828
}
 
33829
 
 
33830
 
 
33831
SWIGINTERN PyObject *_wrap_TreeItemData_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
33832
  PyObject *resultobj = 0;
 
33833
  wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
 
33834
  wxTreeItemId *arg2 = 0 ;
 
33835
  void *argp1 = 0 ;
 
33836
  int res1 = 0 ;
 
33837
  void *argp2 = 0 ;
 
33838
  int res2 = 0 ;
 
33839
  PyObject * obj0 = 0 ;
 
33840
  PyObject * obj1 = 0 ;
 
33841
  char *  kwnames[] = {
 
33842
    (char *) "self",(char *) "id", NULL 
 
33843
  };
 
33844
  
 
33845
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeItemData_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
 
33846
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeItemData, 0 |  0 );
 
33847
  if (!SWIG_IsOK(res1)) {
 
33848
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeItemData_SetId" "', expected argument " "1"" of type '" "wxPyTreeItemData *""'"); 
 
33849
  }
 
33850
  arg1 = reinterpret_cast< wxPyTreeItemData * >(argp1);
 
33851
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
33852
  if (!SWIG_IsOK(res2)) {
 
33853
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeItemData_SetId" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
33854
  }
 
33855
  if (!argp2) {
 
33856
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeItemData_SetId" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
33857
  }
 
33858
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
33859
  {
 
33860
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33861
    (arg1)->SetId((wxTreeItemId const &)*arg2);
 
33862
    wxPyEndAllowThreads(__tstate);
 
33863
    if (PyErr_Occurred()) SWIG_fail;
 
33864
  }
 
33865
  resultobj = SWIG_Py_Void();
 
33866
  return resultobj;
 
33867
fail:
 
33868
  return NULL;
 
33869
}
 
33870
 
 
33871
 
 
33872
SWIGINTERN PyObject *_wrap_TreeItemData_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33873
  PyObject *resultobj = 0;
 
33874
  wxPyTreeItemData *arg1 = (wxPyTreeItemData *) 0 ;
 
33875
  void *argp1 = 0 ;
 
33876
  int res1 = 0 ;
 
33877
  PyObject *swig_obj[1] ;
 
33878
  
 
33879
  if (!args) SWIG_fail;
 
33880
  swig_obj[0] = args;
 
33881
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeItemData, 0 |  0 );
 
33882
  if (!SWIG_IsOK(res1)) {
 
33883
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeItemData_Destroy" "', expected argument " "1"" of type '" "wxPyTreeItemData *""'"); 
 
33884
  }
 
33885
  arg1 = reinterpret_cast< wxPyTreeItemData * >(argp1);
 
33886
  {
 
33887
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33888
    wxPyTreeItemData_Destroy(arg1);
 
33889
    wxPyEndAllowThreads(__tstate);
 
33890
    if (PyErr_Occurred()) SWIG_fail;
 
33891
  }
 
33892
  resultobj = SWIG_Py_Void();
 
33893
  return resultobj;
 
33894
fail:
 
33895
  return NULL;
 
33896
}
 
33897
 
 
33898
 
 
33899
SWIGINTERN PyObject *TreeItemData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33900
  PyObject *obj;
 
33901
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
33902
  SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTreeItemData, SWIG_NewClientData(obj));
 
33903
  return SWIG_Py_Void();
 
33904
}
 
33905
 
 
33906
SWIGINTERN PyObject *TreeItemData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
33907
  return SWIG_Python_InitShadowInstance(args);
 
33908
}
 
33909
 
 
33910
SWIGINTERN int NullTreeItemId_set(PyObject *_val) {
 
33911
  {
 
33912
    void *argp = 0;
 
33913
    int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
33914
    if (!SWIG_IsOK(res)) {
 
33915
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""wxNullTreeItemId""' of type '""wxTreeItemId""'");
 
33916
    }
 
33917
    if (!argp) {
 
33918
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""wxNullTreeItemId""' of type '""wxTreeItemId""'");
 
33919
    } else {
 
33920
      wxTreeItemId * temp;
 
33921
      temp  = reinterpret_cast< wxTreeItemId * >(argp);
 
33922
      wxNullTreeItemId = *temp;
 
33923
      if (SWIG_IsNewObj(res)) delete temp;
 
33924
    }
 
33925
  }
 
33926
  return 0;
 
33927
fail:
 
33928
  return 1;
 
33929
}
 
33930
 
 
33931
 
 
33932
SWIGINTERN PyObject *NullTreeItemId_get(void) {
 
33933
  PyObject *pyobj = 0;
 
33934
  
 
33935
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullTreeItemId), SWIGTYPE_p_wxTreeItemId,  0 );
 
33936
  return pyobj;
 
33937
}
 
33938
 
 
33939
 
 
33940
SWIGINTERN PyObject *_wrap_new_TreeEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
 
33941
  PyObject *resultobj = 0;
 
33942
  wxEventType arg1 = (wxEventType) wxEVT_NULL ;
 
33943
  int arg2 = (int) 0 ;
 
33944
  wxTreeEvent *result = 0 ;
 
33945
  int val1 ;
 
33946
  int ecode1 = 0 ;
 
33947
  int val2 ;
 
33948
  int ecode2 = 0 ;
 
33949
  
 
33950
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
 
33951
  if (swig_obj[0]) {
 
33952
    ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
 
33953
    if (!SWIG_IsOK(ecode1)) {
 
33954
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TreeEvent" "', expected argument " "1"" of type '" "wxEventType""'");
 
33955
    } 
 
33956
    arg1 = static_cast< wxEventType >(val1);
 
33957
  }
 
33958
  if (swig_obj[1]) {
 
33959
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
 
33960
    if (!SWIG_IsOK(ecode2)) {
 
33961
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeEvent" "', expected argument " "2"" of type '" "int""'");
 
33962
    } 
 
33963
    arg2 = static_cast< int >(val2);
 
33964
  }
 
33965
  {
 
33966
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
33967
    result = (wxTreeEvent *)new wxTreeEvent(arg1,arg2);
 
33968
    wxPyEndAllowThreads(__tstate);
 
33969
    if (PyErr_Occurred()) SWIG_fail;
 
33970
  }
 
33971
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_NEW |  0 );
 
33972
  return resultobj;
 
33973
fail:
 
33974
  return NULL;
 
33975
}
 
33976
 
 
33977
 
 
33978
SWIGINTERN PyObject *_wrap_new_TreeEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
 
33979
  PyObject *resultobj = 0;
 
33980
  wxEventType arg1 ;
 
33981
  wxPyTreeCtrl *arg2 = (wxPyTreeCtrl *) 0 ;
 
33982
  wxTreeItemId &arg3_defvalue = wxNullTreeItemId ;
 
33983
  wxTreeItemId *arg3 = (wxTreeItemId *) &arg3_defvalue ;
 
33984
  wxTreeEvent *result = 0 ;
 
33985
  int val1 ;
 
33986
  int ecode1 = 0 ;
 
33987
  void *argp2 = 0 ;
 
33988
  int res2 = 0 ;
 
33989
  void *argp3 = 0 ;
 
33990
  int res3 = 0 ;
 
33991
  
 
33992
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
 
33993
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
 
33994
  if (!SWIG_IsOK(ecode1)) {
 
33995
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TreeEvent" "', expected argument " "1"" of type '" "wxEventType""'");
 
33996
  } 
 
33997
  arg1 = static_cast< wxEventType >(val1);
 
33998
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
33999
  if (!SWIG_IsOK(res2)) {
 
34000
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TreeEvent" "', expected argument " "2"" of type '" "wxPyTreeCtrl *""'"); 
 
34001
  }
 
34002
  arg2 = reinterpret_cast< wxPyTreeCtrl * >(argp2);
 
34003
  if (swig_obj[2]) {
 
34004
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxTreeItemId,  0 );
 
34005
    if (!SWIG_IsOK(res3)) {
 
34006
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TreeEvent" "', expected argument " "3"" of type '" "wxTreeItemId &""'"); 
 
34007
    }
 
34008
    if (!argp3) {
 
34009
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeEvent" "', expected argument " "3"" of type '" "wxTreeItemId &""'"); 
 
34010
    }
 
34011
    arg3 = reinterpret_cast< wxTreeItemId * >(argp3);
 
34012
  }
 
34013
  {
 
34014
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34015
    result = (wxTreeEvent *)new wxTreeEvent(arg1,arg2,*arg3);
 
34016
    wxPyEndAllowThreads(__tstate);
 
34017
    if (PyErr_Occurred()) SWIG_fail;
 
34018
  }
 
34019
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTreeEvent, SWIG_POINTER_NEW |  0 );
 
34020
  return resultobj;
 
34021
fail:
 
34022
  return NULL;
 
34023
}
 
34024
 
 
34025
 
 
34026
SWIGINTERN PyObject *_wrap_new_TreeEvent(PyObject *self, PyObject *args) {
 
34027
  int argc;
 
34028
  PyObject *argv[4];
 
34029
  
 
34030
  if (!(argc = SWIG_Python_UnpackTuple(args,"new_TreeEvent",0,3,argv))) SWIG_fail;
 
34031
  --argc;
 
34032
  if ((argc >= 0) && (argc <= 2)) {
 
34033
    int _v = 0;
 
34034
    if (argc > 1) {
 
34035
      {
 
34036
        {
 
34037
          int res = SWIG_AsVal_int(argv[1], NULL);
 
34038
          _v = SWIG_CheckState(res);
 
34039
        }
 
34040
      }
 
34041
      if (!_v) goto check_1;
 
34042
    }
 
34043
    return _wrap_new_TreeEvent__SWIG_0(self, argc, argv);
 
34044
  }
 
34045
check_1:
 
34046
  
 
34047
  if ((argc >= 2) && (argc <= 3)) {
 
34048
    return _wrap_new_TreeEvent__SWIG_1(self, argc, argv);
 
34049
  }
 
34050
  
 
34051
fail:
 
34052
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TreeEvent'");
 
34053
  return NULL;
 
34054
}
 
34055
 
 
34056
 
 
34057
SWIGINTERN PyObject *_wrap_TreeEvent_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34058
  PyObject *resultobj = 0;
 
34059
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34060
  wxTreeItemId result;
 
34061
  void *argp1 = 0 ;
 
34062
  int res1 = 0 ;
 
34063
  PyObject *swig_obj[1] ;
 
34064
  
 
34065
  if (!args) SWIG_fail;
 
34066
  swig_obj[0] = args;
 
34067
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34068
  if (!SWIG_IsOK(res1)) {
 
34069
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_GetItem" "', expected argument " "1"" of type '" "wxTreeEvent const *""'"); 
 
34070
  }
 
34071
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34072
  {
 
34073
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34074
    result = ((wxTreeEvent const *)arg1)->GetItem();
 
34075
    wxPyEndAllowThreads(__tstate);
 
34076
    if (PyErr_Occurred()) SWIG_fail;
 
34077
  }
 
34078
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
34079
  return resultobj;
 
34080
fail:
 
34081
  return NULL;
 
34082
}
 
34083
 
 
34084
 
 
34085
SWIGINTERN PyObject *_wrap_TreeEvent_SetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34086
  PyObject *resultobj = 0;
 
34087
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34088
  wxTreeItemId *arg2 = 0 ;
 
34089
  void *argp1 = 0 ;
 
34090
  int res1 = 0 ;
 
34091
  void *argp2 = 0 ;
 
34092
  int res2 = 0 ;
 
34093
  PyObject * obj0 = 0 ;
 
34094
  PyObject * obj1 = 0 ;
 
34095
  char *  kwnames[] = {
 
34096
    (char *) "self",(char *) "item", NULL 
 
34097
  };
 
34098
  
 
34099
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
34100
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34101
  if (!SWIG_IsOK(res1)) {
 
34102
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_SetItem" "', expected argument " "1"" of type '" "wxTreeEvent *""'"); 
 
34103
  }
 
34104
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34105
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
34106
  if (!SWIG_IsOK(res2)) {
 
34107
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeEvent_SetItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
34108
  }
 
34109
  if (!argp2) {
 
34110
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeEvent_SetItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
34111
  }
 
34112
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
34113
  {
 
34114
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34115
    (arg1)->SetItem((wxTreeItemId const &)*arg2);
 
34116
    wxPyEndAllowThreads(__tstate);
 
34117
    if (PyErr_Occurred()) SWIG_fail;
 
34118
  }
 
34119
  resultobj = SWIG_Py_Void();
 
34120
  return resultobj;
 
34121
fail:
 
34122
  return NULL;
 
34123
}
 
34124
 
 
34125
 
 
34126
SWIGINTERN PyObject *_wrap_TreeEvent_GetOldItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34127
  PyObject *resultobj = 0;
 
34128
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34129
  wxTreeItemId result;
 
34130
  void *argp1 = 0 ;
 
34131
  int res1 = 0 ;
 
34132
  PyObject *swig_obj[1] ;
 
34133
  
 
34134
  if (!args) SWIG_fail;
 
34135
  swig_obj[0] = args;
 
34136
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34137
  if (!SWIG_IsOK(res1)) {
 
34138
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_GetOldItem" "', expected argument " "1"" of type '" "wxTreeEvent const *""'"); 
 
34139
  }
 
34140
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34141
  {
 
34142
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34143
    result = ((wxTreeEvent const *)arg1)->GetOldItem();
 
34144
    wxPyEndAllowThreads(__tstate);
 
34145
    if (PyErr_Occurred()) SWIG_fail;
 
34146
  }
 
34147
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
34148
  return resultobj;
 
34149
fail:
 
34150
  return NULL;
 
34151
}
 
34152
 
 
34153
 
 
34154
SWIGINTERN PyObject *_wrap_TreeEvent_SetOldItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34155
  PyObject *resultobj = 0;
 
34156
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34157
  wxTreeItemId *arg2 = 0 ;
 
34158
  void *argp1 = 0 ;
 
34159
  int res1 = 0 ;
 
34160
  void *argp2 = 0 ;
 
34161
  int res2 = 0 ;
 
34162
  PyObject * obj0 = 0 ;
 
34163
  PyObject * obj1 = 0 ;
 
34164
  char *  kwnames[] = {
 
34165
    (char *) "self",(char *) "item", NULL 
 
34166
  };
 
34167
  
 
34168
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetOldItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
34169
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34170
  if (!SWIG_IsOK(res1)) {
 
34171
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_SetOldItem" "', expected argument " "1"" of type '" "wxTreeEvent *""'"); 
 
34172
  }
 
34173
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34174
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
34175
  if (!SWIG_IsOK(res2)) {
 
34176
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeEvent_SetOldItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
34177
  }
 
34178
  if (!argp2) {
 
34179
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeEvent_SetOldItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
34180
  }
 
34181
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
34182
  {
 
34183
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34184
    (arg1)->SetOldItem((wxTreeItemId const &)*arg2);
 
34185
    wxPyEndAllowThreads(__tstate);
 
34186
    if (PyErr_Occurred()) SWIG_fail;
 
34187
  }
 
34188
  resultobj = SWIG_Py_Void();
 
34189
  return resultobj;
 
34190
fail:
 
34191
  return NULL;
 
34192
}
 
34193
 
 
34194
 
 
34195
SWIGINTERN PyObject *_wrap_TreeEvent_GetPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34196
  PyObject *resultobj = 0;
 
34197
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34198
  wxPoint result;
 
34199
  void *argp1 = 0 ;
 
34200
  int res1 = 0 ;
 
34201
  PyObject *swig_obj[1] ;
 
34202
  
 
34203
  if (!args) SWIG_fail;
 
34204
  swig_obj[0] = args;
 
34205
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34206
  if (!SWIG_IsOK(res1)) {
 
34207
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_GetPoint" "', expected argument " "1"" of type '" "wxTreeEvent const *""'"); 
 
34208
  }
 
34209
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34210
  {
 
34211
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34212
    result = ((wxTreeEvent const *)arg1)->GetPoint();
 
34213
    wxPyEndAllowThreads(__tstate);
 
34214
    if (PyErr_Occurred()) SWIG_fail;
 
34215
  }
 
34216
  resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN |  0 );
 
34217
  return resultobj;
 
34218
fail:
 
34219
  return NULL;
 
34220
}
 
34221
 
 
34222
 
 
34223
SWIGINTERN PyObject *_wrap_TreeEvent_SetPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34224
  PyObject *resultobj = 0;
 
34225
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34226
  wxPoint *arg2 = 0 ;
 
34227
  void *argp1 = 0 ;
 
34228
  int res1 = 0 ;
 
34229
  wxPoint temp2 ;
 
34230
  PyObject * obj0 = 0 ;
 
34231
  PyObject * obj1 = 0 ;
 
34232
  char *  kwnames[] = {
 
34233
    (char *) "self",(char *) "pt", NULL 
 
34234
  };
 
34235
  
 
34236
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetPoint",kwnames,&obj0,&obj1)) SWIG_fail;
 
34237
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34238
  if (!SWIG_IsOK(res1)) {
 
34239
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_SetPoint" "', expected argument " "1"" of type '" "wxTreeEvent *""'"); 
 
34240
  }
 
34241
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34242
  {
 
34243
    arg2 = &temp2;
 
34244
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
34245
  }
 
34246
  {
 
34247
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34248
    (arg1)->SetPoint((wxPoint const &)*arg2);
 
34249
    wxPyEndAllowThreads(__tstate);
 
34250
    if (PyErr_Occurred()) SWIG_fail;
 
34251
  }
 
34252
  resultobj = SWIG_Py_Void();
 
34253
  return resultobj;
 
34254
fail:
 
34255
  return NULL;
 
34256
}
 
34257
 
 
34258
 
 
34259
SWIGINTERN PyObject *_wrap_TreeEvent_GetKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34260
  PyObject *resultobj = 0;
 
34261
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34262
  wxKeyEvent *result = 0 ;
 
34263
  void *argp1 = 0 ;
 
34264
  int res1 = 0 ;
 
34265
  PyObject *swig_obj[1] ;
 
34266
  
 
34267
  if (!args) SWIG_fail;
 
34268
  swig_obj[0] = args;
 
34269
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34270
  if (!SWIG_IsOK(res1)) {
 
34271
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_GetKeyEvent" "', expected argument " "1"" of type '" "wxTreeEvent const *""'"); 
 
34272
  }
 
34273
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34274
  {
 
34275
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34276
    {
 
34277
      wxKeyEvent const &_result_ref = ((wxTreeEvent const *)arg1)->GetKeyEvent();
 
34278
      result = (wxKeyEvent *) &_result_ref;
 
34279
    }
 
34280
    wxPyEndAllowThreads(__tstate);
 
34281
    if (PyErr_Occurred()) SWIG_fail;
 
34282
  }
 
34283
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, 0 |  0 );
 
34284
  return resultobj;
 
34285
fail:
 
34286
  return NULL;
 
34287
}
 
34288
 
 
34289
 
 
34290
SWIGINTERN PyObject *_wrap_TreeEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34291
  PyObject *resultobj = 0;
 
34292
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34293
  int result;
 
34294
  void *argp1 = 0 ;
 
34295
  int res1 = 0 ;
 
34296
  PyObject *swig_obj[1] ;
 
34297
  
 
34298
  if (!args) SWIG_fail;
 
34299
  swig_obj[0] = args;
 
34300
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34301
  if (!SWIG_IsOK(res1)) {
 
34302
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxTreeEvent const *""'"); 
 
34303
  }
 
34304
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34305
  {
 
34306
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34307
    result = (int)((wxTreeEvent const *)arg1)->GetKeyCode();
 
34308
    wxPyEndAllowThreads(__tstate);
 
34309
    if (PyErr_Occurred()) SWIG_fail;
 
34310
  }
 
34311
  resultobj = SWIG_From_int(static_cast< int >(result));
 
34312
  return resultobj;
 
34313
fail:
 
34314
  return NULL;
 
34315
}
 
34316
 
 
34317
 
 
34318
SWIGINTERN PyObject *_wrap_TreeEvent_SetKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34319
  PyObject *resultobj = 0;
 
34320
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34321
  wxKeyEvent *arg2 = 0 ;
 
34322
  void *argp1 = 0 ;
 
34323
  int res1 = 0 ;
 
34324
  void *argp2 = 0 ;
 
34325
  int res2 = 0 ;
 
34326
  PyObject * obj0 = 0 ;
 
34327
  PyObject * obj1 = 0 ;
 
34328
  char *  kwnames[] = {
 
34329
    (char *) "self",(char *) "evt", NULL 
 
34330
  };
 
34331
  
 
34332
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetKeyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
 
34333
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34334
  if (!SWIG_IsOK(res1)) {
 
34335
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_SetKeyEvent" "', expected argument " "1"" of type '" "wxTreeEvent *""'"); 
 
34336
  }
 
34337
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34338
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent,  0  | 0);
 
34339
  if (!SWIG_IsOK(res2)) {
 
34340
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeEvent_SetKeyEvent" "', expected argument " "2"" of type '" "wxKeyEvent const &""'"); 
 
34341
  }
 
34342
  if (!argp2) {
 
34343
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeEvent_SetKeyEvent" "', expected argument " "2"" of type '" "wxKeyEvent const &""'"); 
 
34344
  }
 
34345
  arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
 
34346
  {
 
34347
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34348
    (arg1)->SetKeyEvent((wxKeyEvent const &)*arg2);
 
34349
    wxPyEndAllowThreads(__tstate);
 
34350
    if (PyErr_Occurred()) SWIG_fail;
 
34351
  }
 
34352
  resultobj = SWIG_Py_Void();
 
34353
  return resultobj;
 
34354
fail:
 
34355
  return NULL;
 
34356
}
 
34357
 
 
34358
 
 
34359
SWIGINTERN PyObject *_wrap_TreeEvent_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34360
  PyObject *resultobj = 0;
 
34361
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34362
  wxString *result = 0 ;
 
34363
  void *argp1 = 0 ;
 
34364
  int res1 = 0 ;
 
34365
  PyObject *swig_obj[1] ;
 
34366
  
 
34367
  if (!args) SWIG_fail;
 
34368
  swig_obj[0] = args;
 
34369
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34370
  if (!SWIG_IsOK(res1)) {
 
34371
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_GetLabel" "', expected argument " "1"" of type '" "wxTreeEvent const *""'"); 
 
34372
  }
 
34373
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34374
  {
 
34375
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34376
    {
 
34377
      wxString const &_result_ref = ((wxTreeEvent const *)arg1)->GetLabel();
 
34378
      result = (wxString *) &_result_ref;
 
34379
    }
 
34380
    wxPyEndAllowThreads(__tstate);
 
34381
    if (PyErr_Occurred()) SWIG_fail;
 
34382
  }
 
34383
  {
 
34384
#if wxUSE_UNICODE
 
34385
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
34386
#else
 
34387
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
34388
#endif
 
34389
  }
 
34390
  return resultobj;
 
34391
fail:
 
34392
  return NULL;
 
34393
}
 
34394
 
 
34395
 
 
34396
SWIGINTERN PyObject *_wrap_TreeEvent_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34397
  PyObject *resultobj = 0;
 
34398
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34399
  wxString *arg2 = 0 ;
 
34400
  void *argp1 = 0 ;
 
34401
  int res1 = 0 ;
 
34402
  bool temp2 = false ;
 
34403
  PyObject * obj0 = 0 ;
 
34404
  PyObject * obj1 = 0 ;
 
34405
  char *  kwnames[] = {
 
34406
    (char *) "self",(char *) "label", NULL 
 
34407
  };
 
34408
  
 
34409
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
 
34410
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34411
  if (!SWIG_IsOK(res1)) {
 
34412
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_SetLabel" "', expected argument " "1"" of type '" "wxTreeEvent *""'"); 
 
34413
  }
 
34414
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34415
  {
 
34416
    arg2 = wxString_in_helper(obj1);
 
34417
    if (arg2 == NULL) SWIG_fail;
 
34418
    temp2 = true;
 
34419
  }
 
34420
  {
 
34421
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34422
    (arg1)->SetLabel((wxString const &)*arg2);
 
34423
    wxPyEndAllowThreads(__tstate);
 
34424
    if (PyErr_Occurred()) SWIG_fail;
 
34425
  }
 
34426
  resultobj = SWIG_Py_Void();
 
34427
  {
 
34428
    if (temp2)
 
34429
    delete arg2;
 
34430
  }
 
34431
  return resultobj;
 
34432
fail:
 
34433
  {
 
34434
    if (temp2)
 
34435
    delete arg2;
 
34436
  }
 
34437
  return NULL;
 
34438
}
 
34439
 
 
34440
 
 
34441
SWIGINTERN PyObject *_wrap_TreeEvent_IsEditCancelled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34442
  PyObject *resultobj = 0;
 
34443
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34444
  bool result;
 
34445
  void *argp1 = 0 ;
 
34446
  int res1 = 0 ;
 
34447
  PyObject *swig_obj[1] ;
 
34448
  
 
34449
  if (!args) SWIG_fail;
 
34450
  swig_obj[0] = args;
 
34451
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34452
  if (!SWIG_IsOK(res1)) {
 
34453
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_IsEditCancelled" "', expected argument " "1"" of type '" "wxTreeEvent const *""'"); 
 
34454
  }
 
34455
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34456
  {
 
34457
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34458
    result = (bool)((wxTreeEvent const *)arg1)->IsEditCancelled();
 
34459
    wxPyEndAllowThreads(__tstate);
 
34460
    if (PyErr_Occurred()) SWIG_fail;
 
34461
  }
 
34462
  {
 
34463
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
34464
  }
 
34465
  return resultobj;
 
34466
fail:
 
34467
  return NULL;
 
34468
}
 
34469
 
 
34470
 
 
34471
SWIGINTERN PyObject *_wrap_TreeEvent_SetEditCanceled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34472
  PyObject *resultobj = 0;
 
34473
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34474
  bool arg2 ;
 
34475
  void *argp1 = 0 ;
 
34476
  int res1 = 0 ;
 
34477
  bool val2 ;
 
34478
  int ecode2 = 0 ;
 
34479
  PyObject * obj0 = 0 ;
 
34480
  PyObject * obj1 = 0 ;
 
34481
  char *  kwnames[] = {
 
34482
    (char *) "self",(char *) "editCancelled", NULL 
 
34483
  };
 
34484
  
 
34485
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetEditCanceled",kwnames,&obj0,&obj1)) SWIG_fail;
 
34486
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34487
  if (!SWIG_IsOK(res1)) {
 
34488
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_SetEditCanceled" "', expected argument " "1"" of type '" "wxTreeEvent *""'"); 
 
34489
  }
 
34490
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34491
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
34492
  if (!SWIG_IsOK(ecode2)) {
 
34493
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeEvent_SetEditCanceled" "', expected argument " "2"" of type '" "bool""'");
 
34494
  } 
 
34495
  arg2 = static_cast< bool >(val2);
 
34496
  {
 
34497
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34498
    (arg1)->SetEditCanceled(arg2);
 
34499
    wxPyEndAllowThreads(__tstate);
 
34500
    if (PyErr_Occurred()) SWIG_fail;
 
34501
  }
 
34502
  resultobj = SWIG_Py_Void();
 
34503
  return resultobj;
 
34504
fail:
 
34505
  return NULL;
 
34506
}
 
34507
 
 
34508
 
 
34509
SWIGINTERN PyObject *_wrap_TreeEvent_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34510
  PyObject *resultobj = 0;
 
34511
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34512
  wxString *arg2 = 0 ;
 
34513
  void *argp1 = 0 ;
 
34514
  int res1 = 0 ;
 
34515
  bool temp2 = false ;
 
34516
  PyObject * obj0 = 0 ;
 
34517
  PyObject * obj1 = 0 ;
 
34518
  char *  kwnames[] = {
 
34519
    (char *) "self",(char *) "toolTip", NULL 
 
34520
  };
 
34521
  
 
34522
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeEvent_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
 
34523
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34524
  if (!SWIG_IsOK(res1)) {
 
34525
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_SetToolTip" "', expected argument " "1"" of type '" "wxTreeEvent *""'"); 
 
34526
  }
 
34527
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34528
  {
 
34529
    arg2 = wxString_in_helper(obj1);
 
34530
    if (arg2 == NULL) SWIG_fail;
 
34531
    temp2 = true;
 
34532
  }
 
34533
  {
 
34534
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34535
    (arg1)->SetToolTip((wxString const &)*arg2);
 
34536
    wxPyEndAllowThreads(__tstate);
 
34537
    if (PyErr_Occurred()) SWIG_fail;
 
34538
  }
 
34539
  resultobj = SWIG_Py_Void();
 
34540
  {
 
34541
    if (temp2)
 
34542
    delete arg2;
 
34543
  }
 
34544
  return resultobj;
 
34545
fail:
 
34546
  {
 
34547
    if (temp2)
 
34548
    delete arg2;
 
34549
  }
 
34550
  return NULL;
 
34551
}
 
34552
 
 
34553
 
 
34554
SWIGINTERN PyObject *_wrap_TreeEvent_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34555
  PyObject *resultobj = 0;
 
34556
  wxTreeEvent *arg1 = (wxTreeEvent *) 0 ;
 
34557
  wxString result;
 
34558
  void *argp1 = 0 ;
 
34559
  int res1 = 0 ;
 
34560
  PyObject *swig_obj[1] ;
 
34561
  
 
34562
  if (!args) SWIG_fail;
 
34563
  swig_obj[0] = args;
 
34564
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTreeEvent, 0 |  0 );
 
34565
  if (!SWIG_IsOK(res1)) {
 
34566
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeEvent_GetToolTip" "', expected argument " "1"" of type '" "wxTreeEvent *""'"); 
 
34567
  }
 
34568
  arg1 = reinterpret_cast< wxTreeEvent * >(argp1);
 
34569
  {
 
34570
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34571
    result = (arg1)->GetToolTip();
 
34572
    wxPyEndAllowThreads(__tstate);
 
34573
    if (PyErr_Occurred()) SWIG_fail;
 
34574
  }
 
34575
  {
 
34576
#if wxUSE_UNICODE
 
34577
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
34578
#else
 
34579
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
34580
#endif
 
34581
  }
 
34582
  return resultobj;
 
34583
fail:
 
34584
  return NULL;
 
34585
}
 
34586
 
 
34587
 
 
34588
SWIGINTERN PyObject *TreeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34589
  PyObject *obj;
 
34590
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
34591
  SWIG_TypeNewClientData(SWIGTYPE_p_wxTreeEvent, SWIG_NewClientData(obj));
 
34592
  return SWIG_Py_Void();
 
34593
}
 
34594
 
 
34595
SWIGINTERN PyObject *TreeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34596
  return SWIG_Python_InitShadowInstance(args);
 
34597
}
 
34598
 
 
34599
SWIGINTERN PyObject *_wrap_new_TreeCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34600
  PyObject *resultobj = 0;
 
34601
  wxWindow *arg1 = (wxWindow *) 0 ;
 
34602
  int arg2 = (int) -1 ;
 
34603
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
34604
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
34605
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
34606
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
34607
  long arg5 = (long) wxTR_DEFAULT_STYLE ;
 
34608
  wxValidator const &arg6_defvalue = wxDefaultValidator ;
 
34609
  wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
 
34610
  wxString const &arg7_defvalue = wxPyTreeCtrlNameStr ;
 
34611
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
34612
  wxPyTreeCtrl *result = 0 ;
 
34613
  void *argp1 = 0 ;
 
34614
  int res1 = 0 ;
 
34615
  int val2 ;
 
34616
  int ecode2 = 0 ;
 
34617
  wxPoint temp3 ;
 
34618
  wxSize temp4 ;
 
34619
  long val5 ;
 
34620
  int ecode5 = 0 ;
 
34621
  void *argp6 = 0 ;
 
34622
  int res6 = 0 ;
 
34623
  bool temp7 = false ;
 
34624
  PyObject * obj0 = 0 ;
 
34625
  PyObject * obj1 = 0 ;
 
34626
  PyObject * obj2 = 0 ;
 
34627
  PyObject * obj3 = 0 ;
 
34628
  PyObject * obj4 = 0 ;
 
34629
  PyObject * obj5 = 0 ;
 
34630
  PyObject * obj6 = 0 ;
 
34631
  char *  kwnames[] = {
 
34632
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
34633
  };
 
34634
  
 
34635
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_TreeCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
34636
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
34637
  if (!SWIG_IsOK(res1)) {
 
34638
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
34639
  }
 
34640
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
34641
  if (obj1) {
 
34642
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
34643
    if (!SWIG_IsOK(ecode2)) {
 
34644
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeCtrl" "', expected argument " "2"" of type '" "int""'");
 
34645
    } 
 
34646
    arg2 = static_cast< int >(val2);
 
34647
  }
 
34648
  if (obj2) {
 
34649
    {
 
34650
      arg3 = &temp3;
 
34651
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
34652
    }
 
34653
  }
 
34654
  if (obj3) {
 
34655
    {
 
34656
      arg4 = &temp4;
 
34657
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
34658
    }
 
34659
  }
 
34660
  if (obj4) {
 
34661
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
34662
    if (!SWIG_IsOK(ecode5)) {
 
34663
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TreeCtrl" "', expected argument " "5"" of type '" "long""'");
 
34664
    } 
 
34665
    arg5 = static_cast< long >(val5);
 
34666
  }
 
34667
  if (obj5) {
 
34668
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator,  0  | 0);
 
34669
    if (!SWIG_IsOK(res6)) {
 
34670
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_TreeCtrl" "', expected argument " "6"" of type '" "wxValidator const &""'"); 
 
34671
    }
 
34672
    if (!argp6) {
 
34673
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeCtrl" "', expected argument " "6"" of type '" "wxValidator const &""'"); 
 
34674
    }
 
34675
    arg6 = reinterpret_cast< wxValidator * >(argp6);
 
34676
  }
 
34677
  if (obj6) {
 
34678
    {
 
34679
      arg7 = wxString_in_helper(obj6);
 
34680
      if (arg7 == NULL) SWIG_fail;
 
34681
      temp7 = true;
 
34682
    }
 
34683
  }
 
34684
  {
 
34685
    if (!wxPyCheckForApp()) SWIG_fail;
 
34686
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34687
    result = (wxPyTreeCtrl *)new wxPyTreeCtrl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
 
34688
    wxPyEndAllowThreads(__tstate);
 
34689
    if (PyErr_Occurred()) SWIG_fail;
 
34690
  }
 
34691
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_NEW |  0 );
 
34692
  {
 
34693
    if (temp7)
 
34694
    delete arg7;
 
34695
  }
 
34696
  return resultobj;
 
34697
fail:
 
34698
  {
 
34699
    if (temp7)
 
34700
    delete arg7;
 
34701
  }
 
34702
  return NULL;
 
34703
}
 
34704
 
 
34705
 
 
34706
SWIGINTERN PyObject *_wrap_new_PreTreeCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34707
  PyObject *resultobj = 0;
 
34708
  wxPyTreeCtrl *result = 0 ;
 
34709
  
 
34710
  if (!SWIG_Python_UnpackTuple(args,"new_PreTreeCtrl",0,0,0)) SWIG_fail;
 
34711
  {
 
34712
    if (!wxPyCheckForApp()) SWIG_fail;
 
34713
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34714
    result = (wxPyTreeCtrl *)new wxPyTreeCtrl();
 
34715
    wxPyEndAllowThreads(__tstate);
 
34716
    if (PyErr_Occurred()) SWIG_fail;
 
34717
  }
 
34718
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTreeCtrl, SWIG_POINTER_OWN |  0 );
 
34719
  return resultobj;
 
34720
fail:
 
34721
  return NULL;
 
34722
}
 
34723
 
 
34724
 
 
34725
SWIGINTERN PyObject *_wrap_TreeCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34726
  PyObject *resultobj = 0;
 
34727
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
34728
  wxWindow *arg2 = (wxWindow *) 0 ;
 
34729
  int arg3 = (int) -1 ;
 
34730
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
34731
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
34732
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
34733
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
34734
  long arg6 = (long) wxTR_DEFAULT_STYLE ;
 
34735
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
34736
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
34737
  wxString const &arg8_defvalue = wxPyTreeCtrlNameStr ;
 
34738
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
34739
  bool result;
 
34740
  void *argp1 = 0 ;
 
34741
  int res1 = 0 ;
 
34742
  void *argp2 = 0 ;
 
34743
  int res2 = 0 ;
 
34744
  int val3 ;
 
34745
  int ecode3 = 0 ;
 
34746
  wxPoint temp4 ;
 
34747
  wxSize temp5 ;
 
34748
  long val6 ;
 
34749
  int ecode6 = 0 ;
 
34750
  void *argp7 = 0 ;
 
34751
  int res7 = 0 ;
 
34752
  bool temp8 = false ;
 
34753
  PyObject * obj0 = 0 ;
 
34754
  PyObject * obj1 = 0 ;
 
34755
  PyObject * obj2 = 0 ;
 
34756
  PyObject * obj3 = 0 ;
 
34757
  PyObject * obj4 = 0 ;
 
34758
  PyObject * obj5 = 0 ;
 
34759
  PyObject * obj6 = 0 ;
 
34760
  PyObject * obj7 = 0 ;
 
34761
  char *  kwnames[] = {
 
34762
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
34763
  };
 
34764
  
 
34765
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:TreeCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
34766
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
34767
  if (!SWIG_IsOK(res1)) {
 
34768
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_Create" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
34769
  }
 
34770
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
34771
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
34772
  if (!SWIG_IsOK(res2)) {
 
34773
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
34774
  }
 
34775
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
34776
  if (obj2) {
 
34777
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
34778
    if (!SWIG_IsOK(ecode3)) {
 
34779
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
34780
    } 
 
34781
    arg3 = static_cast< int >(val3);
 
34782
  }
 
34783
  if (obj3) {
 
34784
    {
 
34785
      arg4 = &temp4;
 
34786
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
34787
    }
 
34788
  }
 
34789
  if (obj4) {
 
34790
    {
 
34791
      arg5 = &temp5;
 
34792
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
34793
    }
 
34794
  }
 
34795
  if (obj5) {
 
34796
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
34797
    if (!SWIG_IsOK(ecode6)) {
 
34798
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TreeCtrl_Create" "', expected argument " "6"" of type '" "long""'");
 
34799
    } 
 
34800
    arg6 = static_cast< long >(val6);
 
34801
  }
 
34802
  if (obj6) {
 
34803
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
34804
    if (!SWIG_IsOK(res7)) {
 
34805
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TreeCtrl_Create" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
34806
    }
 
34807
    if (!argp7) {
 
34808
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_Create" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
34809
    }
 
34810
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
34811
  }
 
34812
  if (obj7) {
 
34813
    {
 
34814
      arg8 = wxString_in_helper(obj7);
 
34815
      if (arg8 == NULL) SWIG_fail;
 
34816
      temp8 = true;
 
34817
    }
 
34818
  }
 
34819
  {
 
34820
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34821
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
34822
    wxPyEndAllowThreads(__tstate);
 
34823
    if (PyErr_Occurred()) SWIG_fail;
 
34824
  }
 
34825
  {
 
34826
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
34827
  }
 
34828
  {
 
34829
    if (temp8)
 
34830
    delete arg8;
 
34831
  }
 
34832
  return resultobj;
 
34833
fail:
 
34834
  {
 
34835
    if (temp8)
 
34836
    delete arg8;
 
34837
  }
 
34838
  return NULL;
 
34839
}
 
34840
 
 
34841
 
 
34842
SWIGINTERN PyObject *_wrap_TreeCtrl__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34843
  PyObject *resultobj = 0;
 
34844
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
34845
  PyObject *arg2 = (PyObject *) 0 ;
 
34846
  PyObject *arg3 = (PyObject *) 0 ;
 
34847
  void *argp1 = 0 ;
 
34848
  int res1 = 0 ;
 
34849
  PyObject * obj0 = 0 ;
 
34850
  PyObject * obj1 = 0 ;
 
34851
  PyObject * obj2 = 0 ;
 
34852
  char *  kwnames[] = {
 
34853
    (char *) "self",(char *) "self",(char *) "_class", NULL 
 
34854
  };
 
34855
  
 
34856
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
34857
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
34858
  if (!SWIG_IsOK(res1)) {
 
34859
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
34860
  }
 
34861
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
34862
  arg2 = obj1;
 
34863
  arg3 = obj2;
 
34864
  {
 
34865
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34866
    (arg1)->_setCallbackInfo(arg2,arg3);
 
34867
    wxPyEndAllowThreads(__tstate);
 
34868
    if (PyErr_Occurred()) SWIG_fail;
 
34869
  }
 
34870
  resultobj = SWIG_Py_Void();
 
34871
  return resultobj;
 
34872
fail:
 
34873
  return NULL;
 
34874
}
 
34875
 
 
34876
 
 
34877
SWIGINTERN PyObject *_wrap_TreeCtrl_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34878
  PyObject *resultobj = 0;
 
34879
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
34880
  unsigned int result;
 
34881
  void *argp1 = 0 ;
 
34882
  int res1 = 0 ;
 
34883
  PyObject *swig_obj[1] ;
 
34884
  
 
34885
  if (!args) SWIG_fail;
 
34886
  swig_obj[0] = args;
 
34887
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
34888
  if (!SWIG_IsOK(res1)) {
 
34889
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetCount" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
34890
  }
 
34891
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
34892
  {
 
34893
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34894
    result = (unsigned int)((wxPyTreeCtrl const *)arg1)->GetCount();
 
34895
    wxPyEndAllowThreads(__tstate);
 
34896
    if (PyErr_Occurred()) SWIG_fail;
 
34897
  }
 
34898
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
 
34899
  return resultobj;
 
34900
fail:
 
34901
  return NULL;
 
34902
}
 
34903
 
 
34904
 
 
34905
SWIGINTERN PyObject *_wrap_TreeCtrl_GetIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34906
  PyObject *resultobj = 0;
 
34907
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
34908
  unsigned int result;
 
34909
  void *argp1 = 0 ;
 
34910
  int res1 = 0 ;
 
34911
  PyObject *swig_obj[1] ;
 
34912
  
 
34913
  if (!args) SWIG_fail;
 
34914
  swig_obj[0] = args;
 
34915
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
34916
  if (!SWIG_IsOK(res1)) {
 
34917
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetIndent" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
34918
  }
 
34919
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
34920
  {
 
34921
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34922
    result = (unsigned int)((wxPyTreeCtrl const *)arg1)->GetIndent();
 
34923
    wxPyEndAllowThreads(__tstate);
 
34924
    if (PyErr_Occurred()) SWIG_fail;
 
34925
  }
 
34926
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
 
34927
  return resultobj;
 
34928
fail:
 
34929
  return NULL;
 
34930
}
 
34931
 
 
34932
 
 
34933
SWIGINTERN PyObject *_wrap_TreeCtrl_SetIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
34934
  PyObject *resultobj = 0;
 
34935
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
34936
  unsigned int arg2 ;
 
34937
  void *argp1 = 0 ;
 
34938
  int res1 = 0 ;
 
34939
  unsigned int val2 ;
 
34940
  int ecode2 = 0 ;
 
34941
  PyObject * obj0 = 0 ;
 
34942
  PyObject * obj1 = 0 ;
 
34943
  char *  kwnames[] = {
 
34944
    (char *) "self",(char *) "indent", NULL 
 
34945
  };
 
34946
  
 
34947
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetIndent",kwnames,&obj0,&obj1)) SWIG_fail;
 
34948
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
34949
  if (!SWIG_IsOK(res1)) {
 
34950
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetIndent" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
34951
  }
 
34952
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
34953
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
34954
  if (!SWIG_IsOK(ecode2)) {
 
34955
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeCtrl_SetIndent" "', expected argument " "2"" of type '" "unsigned int""'");
 
34956
  } 
 
34957
  arg2 = static_cast< unsigned int >(val2);
 
34958
  {
 
34959
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34960
    (arg1)->SetIndent(arg2);
 
34961
    wxPyEndAllowThreads(__tstate);
 
34962
    if (PyErr_Occurred()) SWIG_fail;
 
34963
  }
 
34964
  resultobj = SWIG_Py_Void();
 
34965
  return resultobj;
 
34966
fail:
 
34967
  return NULL;
 
34968
}
 
34969
 
 
34970
 
 
34971
SWIGINTERN PyObject *_wrap_TreeCtrl_GetSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
34972
  PyObject *resultobj = 0;
 
34973
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
34974
  unsigned int result;
 
34975
  void *argp1 = 0 ;
 
34976
  int res1 = 0 ;
 
34977
  PyObject *swig_obj[1] ;
 
34978
  
 
34979
  if (!args) SWIG_fail;
 
34980
  swig_obj[0] = args;
 
34981
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
34982
  if (!SWIG_IsOK(res1)) {
 
34983
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetSpacing" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
34984
  }
 
34985
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
34986
  {
 
34987
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
34988
    result = (unsigned int)((wxPyTreeCtrl const *)arg1)->GetSpacing();
 
34989
    wxPyEndAllowThreads(__tstate);
 
34990
    if (PyErr_Occurred()) SWIG_fail;
 
34991
  }
 
34992
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
 
34993
  return resultobj;
 
34994
fail:
 
34995
  return NULL;
 
34996
}
 
34997
 
 
34998
 
 
34999
SWIGINTERN PyObject *_wrap_TreeCtrl_SetSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35000
  PyObject *resultobj = 0;
 
35001
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35002
  unsigned int arg2 ;
 
35003
  void *argp1 = 0 ;
 
35004
  int res1 = 0 ;
 
35005
  unsigned int val2 ;
 
35006
  int ecode2 = 0 ;
 
35007
  PyObject * obj0 = 0 ;
 
35008
  PyObject * obj1 = 0 ;
 
35009
  char *  kwnames[] = {
 
35010
    (char *) "self",(char *) "spacing", NULL 
 
35011
  };
 
35012
  
 
35013
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetSpacing",kwnames,&obj0,&obj1)) SWIG_fail;
 
35014
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35015
  if (!SWIG_IsOK(res1)) {
 
35016
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetSpacing" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35017
  }
 
35018
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35019
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
35020
  if (!SWIG_IsOK(ecode2)) {
 
35021
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeCtrl_SetSpacing" "', expected argument " "2"" of type '" "unsigned int""'");
 
35022
  } 
 
35023
  arg2 = static_cast< unsigned int >(val2);
 
35024
  {
 
35025
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35026
    (arg1)->SetSpacing(arg2);
 
35027
    wxPyEndAllowThreads(__tstate);
 
35028
    if (PyErr_Occurred()) SWIG_fail;
 
35029
  }
 
35030
  resultobj = SWIG_Py_Void();
 
35031
  return resultobj;
 
35032
fail:
 
35033
  return NULL;
 
35034
}
 
35035
 
 
35036
 
 
35037
SWIGINTERN PyObject *_wrap_TreeCtrl_GetImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
35038
  PyObject *resultobj = 0;
 
35039
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35040
  wxImageList *result = 0 ;
 
35041
  void *argp1 = 0 ;
 
35042
  int res1 = 0 ;
 
35043
  PyObject *swig_obj[1] ;
 
35044
  
 
35045
  if (!args) SWIG_fail;
 
35046
  swig_obj[0] = args;
 
35047
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35048
  if (!SWIG_IsOK(res1)) {
 
35049
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetImageList" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
35050
  }
 
35051
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35052
  {
 
35053
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35054
    result = (wxImageList *)((wxPyTreeCtrl const *)arg1)->GetImageList();
 
35055
    wxPyEndAllowThreads(__tstate);
 
35056
    if (PyErr_Occurred()) SWIG_fail;
 
35057
  }
 
35058
  {
 
35059
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
35060
  }
 
35061
  return resultobj;
 
35062
fail:
 
35063
  return NULL;
 
35064
}
 
35065
 
 
35066
 
 
35067
SWIGINTERN PyObject *_wrap_TreeCtrl_GetStateImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
35068
  PyObject *resultobj = 0;
 
35069
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35070
  wxImageList *result = 0 ;
 
35071
  void *argp1 = 0 ;
 
35072
  int res1 = 0 ;
 
35073
  PyObject *swig_obj[1] ;
 
35074
  
 
35075
  if (!args) SWIG_fail;
 
35076
  swig_obj[0] = args;
 
35077
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35078
  if (!SWIG_IsOK(res1)) {
 
35079
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetStateImageList" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
35080
  }
 
35081
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35082
  {
 
35083
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35084
    result = (wxImageList *)((wxPyTreeCtrl const *)arg1)->GetStateImageList();
 
35085
    wxPyEndAllowThreads(__tstate);
 
35086
    if (PyErr_Occurred()) SWIG_fail;
 
35087
  }
 
35088
  {
 
35089
    resultobj = wxPyMake_wxObject(result, (bool)0); 
 
35090
  }
 
35091
  return resultobj;
 
35092
fail:
 
35093
  return NULL;
 
35094
}
 
35095
 
 
35096
 
 
35097
SWIGINTERN PyObject *_wrap_TreeCtrl_SetImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35098
  PyObject *resultobj = 0;
 
35099
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35100
  wxImageList *arg2 = (wxImageList *) 0 ;
 
35101
  void *argp1 = 0 ;
 
35102
  int res1 = 0 ;
 
35103
  void *argp2 = 0 ;
 
35104
  int res2 = 0 ;
 
35105
  PyObject * obj0 = 0 ;
 
35106
  PyObject * obj1 = 0 ;
 
35107
  char *  kwnames[] = {
 
35108
    (char *) "self",(char *) "imageList", NULL 
 
35109
  };
 
35110
  
 
35111
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetImageList",kwnames,&obj0,&obj1)) SWIG_fail;
 
35112
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35113
  if (!SWIG_IsOK(res1)) {
 
35114
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetImageList" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35115
  }
 
35116
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35117
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxImageList, 0 |  0 );
 
35118
  if (!SWIG_IsOK(res2)) {
 
35119
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetImageList" "', expected argument " "2"" of type '" "wxImageList *""'"); 
 
35120
  }
 
35121
  arg2 = reinterpret_cast< wxImageList * >(argp2);
 
35122
  {
 
35123
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35124
    (arg1)->SetImageList(arg2);
 
35125
    wxPyEndAllowThreads(__tstate);
 
35126
    if (PyErr_Occurred()) SWIG_fail;
 
35127
  }
 
35128
  resultobj = SWIG_Py_Void();
 
35129
  return resultobj;
 
35130
fail:
 
35131
  return NULL;
 
35132
}
 
35133
 
 
35134
 
 
35135
SWIGINTERN PyObject *_wrap_TreeCtrl_SetStateImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35136
  PyObject *resultobj = 0;
 
35137
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35138
  wxImageList *arg2 = (wxImageList *) 0 ;
 
35139
  void *argp1 = 0 ;
 
35140
  int res1 = 0 ;
 
35141
  void *argp2 = 0 ;
 
35142
  int res2 = 0 ;
 
35143
  PyObject * obj0 = 0 ;
 
35144
  PyObject * obj1 = 0 ;
 
35145
  char *  kwnames[] = {
 
35146
    (char *) "self",(char *) "imageList", NULL 
 
35147
  };
 
35148
  
 
35149
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetStateImageList",kwnames,&obj0,&obj1)) SWIG_fail;
 
35150
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35151
  if (!SWIG_IsOK(res1)) {
 
35152
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetStateImageList" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35153
  }
 
35154
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35155
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxImageList, 0 |  0 );
 
35156
  if (!SWIG_IsOK(res2)) {
 
35157
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetStateImageList" "', expected argument " "2"" of type '" "wxImageList *""'"); 
 
35158
  }
 
35159
  arg2 = reinterpret_cast< wxImageList * >(argp2);
 
35160
  {
 
35161
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35162
    (arg1)->SetStateImageList(arg2);
 
35163
    wxPyEndAllowThreads(__tstate);
 
35164
    if (PyErr_Occurred()) SWIG_fail;
 
35165
  }
 
35166
  resultobj = SWIG_Py_Void();
 
35167
  return resultobj;
 
35168
fail:
 
35169
  return NULL;
 
35170
}
 
35171
 
 
35172
 
 
35173
SWIGINTERN PyObject *_wrap_TreeCtrl_AssignImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35174
  PyObject *resultobj = 0;
 
35175
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35176
  wxImageList *arg2 = (wxImageList *) 0 ;
 
35177
  void *argp1 = 0 ;
 
35178
  int res1 = 0 ;
 
35179
  int res2 = 0 ;
 
35180
  PyObject * obj0 = 0 ;
 
35181
  PyObject * obj1 = 0 ;
 
35182
  char *  kwnames[] = {
 
35183
    (char *) "self",(char *) "imageList", NULL 
 
35184
  };
 
35185
  
 
35186
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_AssignImageList",kwnames,&obj0,&obj1)) SWIG_fail;
 
35187
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35188
  if (!SWIG_IsOK(res1)) {
 
35189
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_AssignImageList" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35190
  }
 
35191
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35192
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxImageList, SWIG_POINTER_DISOWN |  0 );
 
35193
  if (!SWIG_IsOK(res2)) {
 
35194
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_AssignImageList" "', expected argument " "2"" of type '" "wxImageList *""'");
 
35195
  }
 
35196
  {
 
35197
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35198
    (arg1)->AssignImageList(arg2);
 
35199
    wxPyEndAllowThreads(__tstate);
 
35200
    if (PyErr_Occurred()) SWIG_fail;
 
35201
  }
 
35202
  resultobj = SWIG_Py_Void();
 
35203
  return resultobj;
 
35204
fail:
 
35205
  return NULL;
 
35206
}
 
35207
 
 
35208
 
 
35209
SWIGINTERN PyObject *_wrap_TreeCtrl_AssignStateImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35210
  PyObject *resultobj = 0;
 
35211
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35212
  wxImageList *arg2 = (wxImageList *) 0 ;
 
35213
  void *argp1 = 0 ;
 
35214
  int res1 = 0 ;
 
35215
  int res2 = 0 ;
 
35216
  PyObject * obj0 = 0 ;
 
35217
  PyObject * obj1 = 0 ;
 
35218
  char *  kwnames[] = {
 
35219
    (char *) "self",(char *) "imageList", NULL 
 
35220
  };
 
35221
  
 
35222
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_AssignStateImageList",kwnames,&obj0,&obj1)) SWIG_fail;
 
35223
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35224
  if (!SWIG_IsOK(res1)) {
 
35225
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_AssignStateImageList" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35226
  }
 
35227
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35228
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxImageList, SWIG_POINTER_DISOWN |  0 );
 
35229
  if (!SWIG_IsOK(res2)) {
 
35230
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_AssignStateImageList" "', expected argument " "2"" of type '" "wxImageList *""'");
 
35231
  }
 
35232
  {
 
35233
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35234
    (arg1)->AssignStateImageList(arg2);
 
35235
    wxPyEndAllowThreads(__tstate);
 
35236
    if (PyErr_Occurred()) SWIG_fail;
 
35237
  }
 
35238
  resultobj = SWIG_Py_Void();
 
35239
  return resultobj;
 
35240
fail:
 
35241
  return NULL;
 
35242
}
 
35243
 
 
35244
 
 
35245
SWIGINTERN PyObject *_wrap_TreeCtrl_GetItemText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35246
  PyObject *resultobj = 0;
 
35247
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35248
  wxTreeItemId *arg2 = 0 ;
 
35249
  wxString result;
 
35250
  void *argp1 = 0 ;
 
35251
  int res1 = 0 ;
 
35252
  void *argp2 = 0 ;
 
35253
  int res2 = 0 ;
 
35254
  PyObject * obj0 = 0 ;
 
35255
  PyObject * obj1 = 0 ;
 
35256
  char *  kwnames[] = {
 
35257
    (char *) "self",(char *) "item", NULL 
 
35258
  };
 
35259
  
 
35260
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemText",kwnames,&obj0,&obj1)) SWIG_fail;
 
35261
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35262
  if (!SWIG_IsOK(res1)) {
 
35263
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetItemText" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
35264
  }
 
35265
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35266
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35267
  if (!SWIG_IsOK(res2)) {
 
35268
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetItemText" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35269
  }
 
35270
  if (!argp2) {
 
35271
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetItemText" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35272
  }
 
35273
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35274
  {
 
35275
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35276
    result = ((wxPyTreeCtrl const *)arg1)->GetItemText((wxTreeItemId const &)*arg2);
 
35277
    wxPyEndAllowThreads(__tstate);
 
35278
    if (PyErr_Occurred()) SWIG_fail;
 
35279
  }
 
35280
  {
 
35281
#if wxUSE_UNICODE
 
35282
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
35283
#else
 
35284
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
35285
#endif
 
35286
  }
 
35287
  return resultobj;
 
35288
fail:
 
35289
  return NULL;
 
35290
}
 
35291
 
 
35292
 
 
35293
SWIGINTERN PyObject *_wrap_TreeCtrl_GetItemImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35294
  PyObject *resultobj = 0;
 
35295
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35296
  wxTreeItemId *arg2 = 0 ;
 
35297
  wxTreeItemIcon arg3 = (wxTreeItemIcon) wxTreeItemIcon_Normal ;
 
35298
  int result;
 
35299
  void *argp1 = 0 ;
 
35300
  int res1 = 0 ;
 
35301
  void *argp2 = 0 ;
 
35302
  int res2 = 0 ;
 
35303
  int val3 ;
 
35304
  int ecode3 = 0 ;
 
35305
  PyObject * obj0 = 0 ;
 
35306
  PyObject * obj1 = 0 ;
 
35307
  PyObject * obj2 = 0 ;
 
35308
  char *  kwnames[] = {
 
35309
    (char *) "self",(char *) "item",(char *) "which", NULL 
 
35310
  };
 
35311
  
 
35312
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_GetItemImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
35313
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35314
  if (!SWIG_IsOK(res1)) {
 
35315
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetItemImage" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
35316
  }
 
35317
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35318
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35319
  if (!SWIG_IsOK(res2)) {
 
35320
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetItemImage" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35321
  }
 
35322
  if (!argp2) {
 
35323
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetItemImage" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35324
  }
 
35325
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35326
  if (obj2) {
 
35327
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
35328
    if (!SWIG_IsOK(ecode3)) {
 
35329
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_GetItemImage" "', expected argument " "3"" of type '" "wxTreeItemIcon""'");
 
35330
    } 
 
35331
    arg3 = static_cast< wxTreeItemIcon >(val3);
 
35332
  }
 
35333
  {
 
35334
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35335
    result = (int)((wxPyTreeCtrl const *)arg1)->GetItemImage((wxTreeItemId const &)*arg2,arg3);
 
35336
    wxPyEndAllowThreads(__tstate);
 
35337
    if (PyErr_Occurred()) SWIG_fail;
 
35338
  }
 
35339
  resultobj = SWIG_From_int(static_cast< int >(result));
 
35340
  return resultobj;
 
35341
fail:
 
35342
  return NULL;
 
35343
}
 
35344
 
 
35345
 
 
35346
SWIGINTERN PyObject *_wrap_TreeCtrl_GetItemData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35347
  PyObject *resultobj = 0;
 
35348
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35349
  wxTreeItemId *arg2 = 0 ;
 
35350
  wxPyTreeItemData *result = 0 ;
 
35351
  void *argp1 = 0 ;
 
35352
  int res1 = 0 ;
 
35353
  void *argp2 = 0 ;
 
35354
  int res2 = 0 ;
 
35355
  PyObject * obj0 = 0 ;
 
35356
  PyObject * obj1 = 0 ;
 
35357
  char *  kwnames[] = {
 
35358
    (char *) "self",(char *) "item", NULL 
 
35359
  };
 
35360
  
 
35361
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemData",kwnames,&obj0,&obj1)) SWIG_fail;
 
35362
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35363
  if (!SWIG_IsOK(res1)) {
 
35364
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetItemData" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35365
  }
 
35366
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35367
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35368
  if (!SWIG_IsOK(res2)) {
 
35369
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetItemData" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35370
  }
 
35371
  if (!argp2) {
 
35372
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetItemData" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35373
  }
 
35374
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35375
  {
 
35376
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35377
    result = (wxPyTreeItemData *)wxPyTreeCtrl_GetItemData(arg1,(wxTreeItemId const &)*arg2);
 
35378
    wxPyEndAllowThreads(__tstate);
 
35379
    if (PyErr_Occurred()) SWIG_fail;
 
35380
  }
 
35381
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTreeItemData, 0 |  0 );
 
35382
  return resultobj;
 
35383
fail:
 
35384
  return NULL;
 
35385
}
 
35386
 
 
35387
 
 
35388
SWIGINTERN PyObject *_wrap_TreeCtrl_GetItemPyData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35389
  PyObject *resultobj = 0;
 
35390
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35391
  wxTreeItemId *arg2 = 0 ;
 
35392
  PyObject *result = 0 ;
 
35393
  void *argp1 = 0 ;
 
35394
  int res1 = 0 ;
 
35395
  void *argp2 = 0 ;
 
35396
  int res2 = 0 ;
 
35397
  PyObject * obj0 = 0 ;
 
35398
  PyObject * obj1 = 0 ;
 
35399
  char *  kwnames[] = {
 
35400
    (char *) "self",(char *) "item", NULL 
 
35401
  };
 
35402
  
 
35403
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemPyData",kwnames,&obj0,&obj1)) SWIG_fail;
 
35404
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35405
  if (!SWIG_IsOK(res1)) {
 
35406
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetItemPyData" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35407
  }
 
35408
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35409
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35410
  if (!SWIG_IsOK(res2)) {
 
35411
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetItemPyData" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35412
  }
 
35413
  if (!argp2) {
 
35414
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetItemPyData" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35415
  }
 
35416
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35417
  {
 
35418
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35419
    result = (PyObject *)wxPyTreeCtrl_GetItemPyData(arg1,(wxTreeItemId const &)*arg2);
 
35420
    wxPyEndAllowThreads(__tstate);
 
35421
    if (PyErr_Occurred()) SWIG_fail;
 
35422
  }
 
35423
  resultobj = result;
 
35424
  return resultobj;
 
35425
fail:
 
35426
  return NULL;
 
35427
}
 
35428
 
 
35429
 
 
35430
SWIGINTERN PyObject *_wrap_TreeCtrl_GetItemTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35431
  PyObject *resultobj = 0;
 
35432
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35433
  wxTreeItemId *arg2 = 0 ;
 
35434
  wxColour result;
 
35435
  void *argp1 = 0 ;
 
35436
  int res1 = 0 ;
 
35437
  void *argp2 = 0 ;
 
35438
  int res2 = 0 ;
 
35439
  PyObject * obj0 = 0 ;
 
35440
  PyObject * obj1 = 0 ;
 
35441
  char *  kwnames[] = {
 
35442
    (char *) "self",(char *) "item", NULL 
 
35443
  };
 
35444
  
 
35445
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
35446
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35447
  if (!SWIG_IsOK(res1)) {
 
35448
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetItemTextColour" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
35449
  }
 
35450
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35451
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35452
  if (!SWIG_IsOK(res2)) {
 
35453
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetItemTextColour" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35454
  }
 
35455
  if (!argp2) {
 
35456
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetItemTextColour" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35457
  }
 
35458
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35459
  {
 
35460
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35461
    result = ((wxPyTreeCtrl const *)arg1)->GetItemTextColour((wxTreeItemId const &)*arg2);
 
35462
    wxPyEndAllowThreads(__tstate);
 
35463
    if (PyErr_Occurred()) SWIG_fail;
 
35464
  }
 
35465
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
35466
  return resultobj;
 
35467
fail:
 
35468
  return NULL;
 
35469
}
 
35470
 
 
35471
 
 
35472
SWIGINTERN PyObject *_wrap_TreeCtrl_GetItemBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35473
  PyObject *resultobj = 0;
 
35474
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35475
  wxTreeItemId *arg2 = 0 ;
 
35476
  wxColour result;
 
35477
  void *argp1 = 0 ;
 
35478
  int res1 = 0 ;
 
35479
  void *argp2 = 0 ;
 
35480
  int res2 = 0 ;
 
35481
  PyObject * obj0 = 0 ;
 
35482
  PyObject * obj1 = 0 ;
 
35483
  char *  kwnames[] = {
 
35484
    (char *) "self",(char *) "item", NULL 
 
35485
  };
 
35486
  
 
35487
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
35488
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35489
  if (!SWIG_IsOK(res1)) {
 
35490
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetItemBackgroundColour" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
35491
  }
 
35492
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35493
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35494
  if (!SWIG_IsOK(res2)) {
 
35495
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetItemBackgroundColour" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35496
  }
 
35497
  if (!argp2) {
 
35498
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetItemBackgroundColour" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35499
  }
 
35500
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35501
  {
 
35502
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35503
    result = ((wxPyTreeCtrl const *)arg1)->GetItemBackgroundColour((wxTreeItemId const &)*arg2);
 
35504
    wxPyEndAllowThreads(__tstate);
 
35505
    if (PyErr_Occurred()) SWIG_fail;
 
35506
  }
 
35507
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
35508
  return resultobj;
 
35509
fail:
 
35510
  return NULL;
 
35511
}
 
35512
 
 
35513
 
 
35514
SWIGINTERN PyObject *_wrap_TreeCtrl_GetItemFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35515
  PyObject *resultobj = 0;
 
35516
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35517
  wxTreeItemId *arg2 = 0 ;
 
35518
  wxFont result;
 
35519
  void *argp1 = 0 ;
 
35520
  int res1 = 0 ;
 
35521
  void *argp2 = 0 ;
 
35522
  int res2 = 0 ;
 
35523
  PyObject * obj0 = 0 ;
 
35524
  PyObject * obj1 = 0 ;
 
35525
  char *  kwnames[] = {
 
35526
    (char *) "self",(char *) "item", NULL 
 
35527
  };
 
35528
  
 
35529
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemFont",kwnames,&obj0,&obj1)) SWIG_fail;
 
35530
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35531
  if (!SWIG_IsOK(res1)) {
 
35532
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetItemFont" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
35533
  }
 
35534
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35535
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35536
  if (!SWIG_IsOK(res2)) {
 
35537
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetItemFont" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35538
  }
 
35539
  if (!argp2) {
 
35540
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetItemFont" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35541
  }
 
35542
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35543
  {
 
35544
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35545
    result = ((wxPyTreeCtrl const *)arg1)->GetItemFont((wxTreeItemId const &)*arg2);
 
35546
    wxPyEndAllowThreads(__tstate);
 
35547
    if (PyErr_Occurred()) SWIG_fail;
 
35548
  }
 
35549
  resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN |  0 );
 
35550
  return resultobj;
 
35551
fail:
 
35552
  return NULL;
 
35553
}
 
35554
 
 
35555
 
 
35556
SWIGINTERN PyObject *_wrap_TreeCtrl_GetItemState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35557
  PyObject *resultobj = 0;
 
35558
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35559
  wxTreeItemId *arg2 = 0 ;
 
35560
  int result;
 
35561
  void *argp1 = 0 ;
 
35562
  int res1 = 0 ;
 
35563
  void *argp2 = 0 ;
 
35564
  int res2 = 0 ;
 
35565
  PyObject * obj0 = 0 ;
 
35566
  PyObject * obj1 = 0 ;
 
35567
  char *  kwnames[] = {
 
35568
    (char *) "self",(char *) "item", NULL 
 
35569
  };
 
35570
  
 
35571
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemState",kwnames,&obj0,&obj1)) SWIG_fail;
 
35572
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35573
  if (!SWIG_IsOK(res1)) {
 
35574
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetItemState" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
35575
  }
 
35576
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35577
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35578
  if (!SWIG_IsOK(res2)) {
 
35579
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetItemState" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35580
  }
 
35581
  if (!argp2) {
 
35582
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetItemState" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35583
  }
 
35584
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35585
  {
 
35586
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35587
    result = (int)((wxPyTreeCtrl const *)arg1)->GetItemState((wxTreeItemId const &)*arg2);
 
35588
    wxPyEndAllowThreads(__tstate);
 
35589
    if (PyErr_Occurred()) SWIG_fail;
 
35590
  }
 
35591
  resultobj = SWIG_From_int(static_cast< int >(result));
 
35592
  return resultobj;
 
35593
fail:
 
35594
  return NULL;
 
35595
}
 
35596
 
 
35597
 
 
35598
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35599
  PyObject *resultobj = 0;
 
35600
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35601
  wxTreeItemId *arg2 = 0 ;
 
35602
  wxString *arg3 = 0 ;
 
35603
  void *argp1 = 0 ;
 
35604
  int res1 = 0 ;
 
35605
  void *argp2 = 0 ;
 
35606
  int res2 = 0 ;
 
35607
  bool temp3 = false ;
 
35608
  PyObject * obj0 = 0 ;
 
35609
  PyObject * obj1 = 0 ;
 
35610
  PyObject * obj2 = 0 ;
 
35611
  char *  kwnames[] = {
 
35612
    (char *) "self",(char *) "item",(char *) "text", NULL 
 
35613
  };
 
35614
  
 
35615
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
35616
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35617
  if (!SWIG_IsOK(res1)) {
 
35618
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemText" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35619
  }
 
35620
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35621
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35622
  if (!SWIG_IsOK(res2)) {
 
35623
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemText" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35624
  }
 
35625
  if (!argp2) {
 
35626
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemText" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35627
  }
 
35628
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35629
  {
 
35630
    arg3 = wxString_in_helper(obj2);
 
35631
    if (arg3 == NULL) SWIG_fail;
 
35632
    temp3 = true;
 
35633
  }
 
35634
  {
 
35635
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35636
    (arg1)->SetItemText((wxTreeItemId const &)*arg2,(wxString const &)*arg3);
 
35637
    wxPyEndAllowThreads(__tstate);
 
35638
    if (PyErr_Occurred()) SWIG_fail;
 
35639
  }
 
35640
  resultobj = SWIG_Py_Void();
 
35641
  {
 
35642
    if (temp3)
 
35643
    delete arg3;
 
35644
  }
 
35645
  return resultobj;
 
35646
fail:
 
35647
  {
 
35648
    if (temp3)
 
35649
    delete arg3;
 
35650
  }
 
35651
  return NULL;
 
35652
}
 
35653
 
 
35654
 
 
35655
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35656
  PyObject *resultobj = 0;
 
35657
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35658
  wxTreeItemId *arg2 = 0 ;
 
35659
  int arg3 ;
 
35660
  wxTreeItemIcon arg4 = (wxTreeItemIcon) wxTreeItemIcon_Normal ;
 
35661
  void *argp1 = 0 ;
 
35662
  int res1 = 0 ;
 
35663
  void *argp2 = 0 ;
 
35664
  int res2 = 0 ;
 
35665
  int val3 ;
 
35666
  int ecode3 = 0 ;
 
35667
  int val4 ;
 
35668
  int ecode4 = 0 ;
 
35669
  PyObject * obj0 = 0 ;
 
35670
  PyObject * obj1 = 0 ;
 
35671
  PyObject * obj2 = 0 ;
 
35672
  PyObject * obj3 = 0 ;
 
35673
  char *  kwnames[] = {
 
35674
    (char *) "self",(char *) "item",(char *) "image",(char *) "which", NULL 
 
35675
  };
 
35676
  
 
35677
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:TreeCtrl_SetItemImage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
35678
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35679
  if (!SWIG_IsOK(res1)) {
 
35680
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemImage" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35681
  }
 
35682
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35683
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35684
  if (!SWIG_IsOK(res2)) {
 
35685
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemImage" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35686
  }
 
35687
  if (!argp2) {
 
35688
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemImage" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35689
  }
 
35690
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35691
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
35692
  if (!SWIG_IsOK(ecode3)) {
 
35693
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_SetItemImage" "', expected argument " "3"" of type '" "int""'");
 
35694
  } 
 
35695
  arg3 = static_cast< int >(val3);
 
35696
  if (obj3) {
 
35697
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
35698
    if (!SWIG_IsOK(ecode4)) {
 
35699
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TreeCtrl_SetItemImage" "', expected argument " "4"" of type '" "wxTreeItemIcon""'");
 
35700
    } 
 
35701
    arg4 = static_cast< wxTreeItemIcon >(val4);
 
35702
  }
 
35703
  {
 
35704
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35705
    (arg1)->SetItemImage((wxTreeItemId const &)*arg2,arg3,arg4);
 
35706
    wxPyEndAllowThreads(__tstate);
 
35707
    if (PyErr_Occurred()) SWIG_fail;
 
35708
  }
 
35709
  resultobj = SWIG_Py_Void();
 
35710
  return resultobj;
 
35711
fail:
 
35712
  return NULL;
 
35713
}
 
35714
 
 
35715
 
 
35716
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35717
  PyObject *resultobj = 0;
 
35718
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35719
  wxTreeItemId *arg2 = 0 ;
 
35720
  wxPyTreeItemData *arg3 = (wxPyTreeItemData *) 0 ;
 
35721
  void *argp1 = 0 ;
 
35722
  int res1 = 0 ;
 
35723
  void *argp2 = 0 ;
 
35724
  int res2 = 0 ;
 
35725
  int res3 = 0 ;
 
35726
  PyObject * obj0 = 0 ;
 
35727
  PyObject * obj1 = 0 ;
 
35728
  PyObject * obj2 = 0 ;
 
35729
  char *  kwnames[] = {
 
35730
    (char *) "self",(char *) "item",(char *) "data", NULL 
 
35731
  };
 
35732
  
 
35733
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
35734
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35735
  if (!SWIG_IsOK(res1)) {
 
35736
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemData" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35737
  }
 
35738
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35739
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35740
  if (!SWIG_IsOK(res2)) {
 
35741
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemData" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35742
  }
 
35743
  if (!argp2) {
 
35744
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemData" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35745
  }
 
35746
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35747
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_DISOWN |  0 );
 
35748
  if (!SWIG_IsOK(res3)) {
 
35749
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TreeCtrl_SetItemData" "', expected argument " "3"" of type '" "wxPyTreeItemData *""'");
 
35750
  }
 
35751
  {
 
35752
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35753
    wxPyTreeCtrl_SetItemData(arg1,(wxTreeItemId const &)*arg2,arg3);
 
35754
    wxPyEndAllowThreads(__tstate);
 
35755
    if (PyErr_Occurred()) SWIG_fail;
 
35756
  }
 
35757
  resultobj = SWIG_Py_Void();
 
35758
  return resultobj;
 
35759
fail:
 
35760
  return NULL;
 
35761
}
 
35762
 
 
35763
 
 
35764
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemPyData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35765
  PyObject *resultobj = 0;
 
35766
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35767
  wxTreeItemId *arg2 = 0 ;
 
35768
  PyObject *arg3 = (PyObject *) 0 ;
 
35769
  void *argp1 = 0 ;
 
35770
  int res1 = 0 ;
 
35771
  void *argp2 = 0 ;
 
35772
  int res2 = 0 ;
 
35773
  PyObject * obj0 = 0 ;
 
35774
  PyObject * obj1 = 0 ;
 
35775
  PyObject * obj2 = 0 ;
 
35776
  char *  kwnames[] = {
 
35777
    (char *) "self",(char *) "item",(char *) "obj", NULL 
 
35778
  };
 
35779
  
 
35780
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemPyData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
35781
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35782
  if (!SWIG_IsOK(res1)) {
 
35783
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemPyData" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35784
  }
 
35785
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35786
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35787
  if (!SWIG_IsOK(res2)) {
 
35788
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemPyData" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35789
  }
 
35790
  if (!argp2) {
 
35791
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemPyData" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35792
  }
 
35793
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35794
  arg3 = obj2;
 
35795
  {
 
35796
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35797
    wxPyTreeCtrl_SetItemPyData(arg1,(wxTreeItemId const &)*arg2,arg3);
 
35798
    wxPyEndAllowThreads(__tstate);
 
35799
    if (PyErr_Occurred()) SWIG_fail;
 
35800
  }
 
35801
  resultobj = SWIG_Py_Void();
 
35802
  return resultobj;
 
35803
fail:
 
35804
  return NULL;
 
35805
}
 
35806
 
 
35807
 
 
35808
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemHasChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35809
  PyObject *resultobj = 0;
 
35810
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35811
  wxTreeItemId *arg2 = 0 ;
 
35812
  bool arg3 = (bool) true ;
 
35813
  void *argp1 = 0 ;
 
35814
  int res1 = 0 ;
 
35815
  void *argp2 = 0 ;
 
35816
  int res2 = 0 ;
 
35817
  bool val3 ;
 
35818
  int ecode3 = 0 ;
 
35819
  PyObject * obj0 = 0 ;
 
35820
  PyObject * obj1 = 0 ;
 
35821
  PyObject * obj2 = 0 ;
 
35822
  char *  kwnames[] = {
 
35823
    (char *) "self",(char *) "item",(char *) "has", NULL 
 
35824
  };
 
35825
  
 
35826
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SetItemHasChildren",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
35827
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35828
  if (!SWIG_IsOK(res1)) {
 
35829
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemHasChildren" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35830
  }
 
35831
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35832
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35833
  if (!SWIG_IsOK(res2)) {
 
35834
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemHasChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35835
  }
 
35836
  if (!argp2) {
 
35837
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemHasChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35838
  }
 
35839
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35840
  if (obj2) {
 
35841
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
35842
    if (!SWIG_IsOK(ecode3)) {
 
35843
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_SetItemHasChildren" "', expected argument " "3"" of type '" "bool""'");
 
35844
    } 
 
35845
    arg3 = static_cast< bool >(val3);
 
35846
  }
 
35847
  {
 
35848
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35849
    (arg1)->SetItemHasChildren((wxTreeItemId const &)*arg2,arg3);
 
35850
    wxPyEndAllowThreads(__tstate);
 
35851
    if (PyErr_Occurred()) SWIG_fail;
 
35852
  }
 
35853
  resultobj = SWIG_Py_Void();
 
35854
  return resultobj;
 
35855
fail:
 
35856
  return NULL;
 
35857
}
 
35858
 
 
35859
 
 
35860
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemBold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35861
  PyObject *resultobj = 0;
 
35862
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35863
  wxTreeItemId *arg2 = 0 ;
 
35864
  bool arg3 = (bool) true ;
 
35865
  void *argp1 = 0 ;
 
35866
  int res1 = 0 ;
 
35867
  void *argp2 = 0 ;
 
35868
  int res2 = 0 ;
 
35869
  bool val3 ;
 
35870
  int ecode3 = 0 ;
 
35871
  PyObject * obj0 = 0 ;
 
35872
  PyObject * obj1 = 0 ;
 
35873
  PyObject * obj2 = 0 ;
 
35874
  char *  kwnames[] = {
 
35875
    (char *) "self",(char *) "item",(char *) "bold", NULL 
 
35876
  };
 
35877
  
 
35878
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SetItemBold",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
35879
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35880
  if (!SWIG_IsOK(res1)) {
 
35881
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemBold" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35882
  }
 
35883
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35884
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35885
  if (!SWIG_IsOK(res2)) {
 
35886
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemBold" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35887
  }
 
35888
  if (!argp2) {
 
35889
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemBold" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35890
  }
 
35891
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35892
  if (obj2) {
 
35893
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
35894
    if (!SWIG_IsOK(ecode3)) {
 
35895
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_SetItemBold" "', expected argument " "3"" of type '" "bool""'");
 
35896
    } 
 
35897
    arg3 = static_cast< bool >(val3);
 
35898
  }
 
35899
  {
 
35900
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35901
    (arg1)->SetItemBold((wxTreeItemId const &)*arg2,arg3);
 
35902
    wxPyEndAllowThreads(__tstate);
 
35903
    if (PyErr_Occurred()) SWIG_fail;
 
35904
  }
 
35905
  resultobj = SWIG_Py_Void();
 
35906
  return resultobj;
 
35907
fail:
 
35908
  return NULL;
 
35909
}
 
35910
 
 
35911
 
 
35912
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemDropHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35913
  PyObject *resultobj = 0;
 
35914
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35915
  wxTreeItemId *arg2 = 0 ;
 
35916
  bool arg3 = (bool) true ;
 
35917
  void *argp1 = 0 ;
 
35918
  int res1 = 0 ;
 
35919
  void *argp2 = 0 ;
 
35920
  int res2 = 0 ;
 
35921
  bool val3 ;
 
35922
  int ecode3 = 0 ;
 
35923
  PyObject * obj0 = 0 ;
 
35924
  PyObject * obj1 = 0 ;
 
35925
  PyObject * obj2 = 0 ;
 
35926
  char *  kwnames[] = {
 
35927
    (char *) "self",(char *) "item",(char *) "highlight", NULL 
 
35928
  };
 
35929
  
 
35930
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SetItemDropHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
35931
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35932
  if (!SWIG_IsOK(res1)) {
 
35933
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemDropHighlight" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35934
  }
 
35935
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35936
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35937
  if (!SWIG_IsOK(res2)) {
 
35938
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemDropHighlight" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35939
  }
 
35940
  if (!argp2) {
 
35941
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemDropHighlight" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35942
  }
 
35943
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35944
  if (obj2) {
 
35945
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
35946
    if (!SWIG_IsOK(ecode3)) {
 
35947
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_SetItemDropHighlight" "', expected argument " "3"" of type '" "bool""'");
 
35948
    } 
 
35949
    arg3 = static_cast< bool >(val3);
 
35950
  }
 
35951
  {
 
35952
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
35953
    (arg1)->SetItemDropHighlight((wxTreeItemId const &)*arg2,arg3);
 
35954
    wxPyEndAllowThreads(__tstate);
 
35955
    if (PyErr_Occurred()) SWIG_fail;
 
35956
  }
 
35957
  resultobj = SWIG_Py_Void();
 
35958
  return resultobj;
 
35959
fail:
 
35960
  return NULL;
 
35961
}
 
35962
 
 
35963
 
 
35964
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
35965
  PyObject *resultobj = 0;
 
35966
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
35967
  wxTreeItemId *arg2 = 0 ;
 
35968
  wxColour *arg3 = 0 ;
 
35969
  void *argp1 = 0 ;
 
35970
  int res1 = 0 ;
 
35971
  void *argp2 = 0 ;
 
35972
  int res2 = 0 ;
 
35973
  wxColour temp3 ;
 
35974
  PyObject * obj0 = 0 ;
 
35975
  PyObject * obj1 = 0 ;
 
35976
  PyObject * obj2 = 0 ;
 
35977
  char *  kwnames[] = {
 
35978
    (char *) "self",(char *) "item",(char *) "col", NULL 
 
35979
  };
 
35980
  
 
35981
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
35982
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
35983
  if (!SWIG_IsOK(res1)) {
 
35984
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemTextColour" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
35985
  }
 
35986
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
35987
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
35988
  if (!SWIG_IsOK(res2)) {
 
35989
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemTextColour" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35990
  }
 
35991
  if (!argp2) {
 
35992
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemTextColour" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
35993
  }
 
35994
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
35995
  {
 
35996
    arg3 = &temp3;
 
35997
    if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
 
35998
  }
 
35999
  {
 
36000
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36001
    (arg1)->SetItemTextColour((wxTreeItemId const &)*arg2,(wxColour const &)*arg3);
 
36002
    wxPyEndAllowThreads(__tstate);
 
36003
    if (PyErr_Occurred()) SWIG_fail;
 
36004
  }
 
36005
  resultobj = SWIG_Py_Void();
 
36006
  return resultobj;
 
36007
fail:
 
36008
  return NULL;
 
36009
}
 
36010
 
 
36011
 
 
36012
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36013
  PyObject *resultobj = 0;
 
36014
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36015
  wxTreeItemId *arg2 = 0 ;
 
36016
  wxColour *arg3 = 0 ;
 
36017
  void *argp1 = 0 ;
 
36018
  int res1 = 0 ;
 
36019
  void *argp2 = 0 ;
 
36020
  int res2 = 0 ;
 
36021
  wxColour temp3 ;
 
36022
  PyObject * obj0 = 0 ;
 
36023
  PyObject * obj1 = 0 ;
 
36024
  PyObject * obj2 = 0 ;
 
36025
  char *  kwnames[] = {
 
36026
    (char *) "self",(char *) "item",(char *) "col", NULL 
 
36027
  };
 
36028
  
 
36029
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
36030
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36031
  if (!SWIG_IsOK(res1)) {
 
36032
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemBackgroundColour" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
36033
  }
 
36034
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36035
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36036
  if (!SWIG_IsOK(res2)) {
 
36037
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemBackgroundColour" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36038
  }
 
36039
  if (!argp2) {
 
36040
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemBackgroundColour" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36041
  }
 
36042
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36043
  {
 
36044
    arg3 = &temp3;
 
36045
    if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
 
36046
  }
 
36047
  {
 
36048
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36049
    (arg1)->SetItemBackgroundColour((wxTreeItemId const &)*arg2,(wxColour const &)*arg3);
 
36050
    wxPyEndAllowThreads(__tstate);
 
36051
    if (PyErr_Occurred()) SWIG_fail;
 
36052
  }
 
36053
  resultobj = SWIG_Py_Void();
 
36054
  return resultobj;
 
36055
fail:
 
36056
  return NULL;
 
36057
}
 
36058
 
 
36059
 
 
36060
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36061
  PyObject *resultobj = 0;
 
36062
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36063
  wxTreeItemId *arg2 = 0 ;
 
36064
  wxFont *arg3 = 0 ;
 
36065
  void *argp1 = 0 ;
 
36066
  int res1 = 0 ;
 
36067
  void *argp2 = 0 ;
 
36068
  int res2 = 0 ;
 
36069
  void *argp3 = 0 ;
 
36070
  int res3 = 0 ;
 
36071
  PyObject * obj0 = 0 ;
 
36072
  PyObject * obj1 = 0 ;
 
36073
  PyObject * obj2 = 0 ;
 
36074
  char *  kwnames[] = {
 
36075
    (char *) "self",(char *) "item",(char *) "font", NULL 
 
36076
  };
 
36077
  
 
36078
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
36079
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36080
  if (!SWIG_IsOK(res1)) {
 
36081
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemFont" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
36082
  }
 
36083
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36084
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36085
  if (!SWIG_IsOK(res2)) {
 
36086
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemFont" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36087
  }
 
36088
  if (!argp2) {
 
36089
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemFont" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36090
  }
 
36091
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36092
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxFont,  0  | 0);
 
36093
  if (!SWIG_IsOK(res3)) {
 
36094
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TreeCtrl_SetItemFont" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
36095
  }
 
36096
  if (!argp3) {
 
36097
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemFont" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
36098
  }
 
36099
  arg3 = reinterpret_cast< wxFont * >(argp3);
 
36100
  {
 
36101
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36102
    (arg1)->SetItemFont((wxTreeItemId const &)*arg2,(wxFont const &)*arg3);
 
36103
    wxPyEndAllowThreads(__tstate);
 
36104
    if (PyErr_Occurred()) SWIG_fail;
 
36105
  }
 
36106
  resultobj = SWIG_Py_Void();
 
36107
  return resultobj;
 
36108
fail:
 
36109
  return NULL;
 
36110
}
 
36111
 
 
36112
 
 
36113
SWIGINTERN PyObject *_wrap_TreeCtrl_SetItemState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36114
  PyObject *resultobj = 0;
 
36115
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36116
  wxTreeItemId *arg2 = 0 ;
 
36117
  int arg3 ;
 
36118
  void *argp1 = 0 ;
 
36119
  int res1 = 0 ;
 
36120
  void *argp2 = 0 ;
 
36121
  int res2 = 0 ;
 
36122
  int val3 ;
 
36123
  int ecode3 = 0 ;
 
36124
  PyObject * obj0 = 0 ;
 
36125
  PyObject * obj1 = 0 ;
 
36126
  PyObject * obj2 = 0 ;
 
36127
  char *  kwnames[] = {
 
36128
    (char *) "self",(char *) "item",(char *) "state", NULL 
 
36129
  };
 
36130
  
 
36131
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_SetItemState",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
36132
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36133
  if (!SWIG_IsOK(res1)) {
 
36134
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetItemState" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
36135
  }
 
36136
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36137
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36138
  if (!SWIG_IsOK(res2)) {
 
36139
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetItemState" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36140
  }
 
36141
  if (!argp2) {
 
36142
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetItemState" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36143
  }
 
36144
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36145
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
36146
  if (!SWIG_IsOK(ecode3)) {
 
36147
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_SetItemState" "', expected argument " "3"" of type '" "int""'");
 
36148
  } 
 
36149
  arg3 = static_cast< int >(val3);
 
36150
  {
 
36151
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36152
    (arg1)->SetItemState((wxTreeItemId const &)*arg2,arg3);
 
36153
    wxPyEndAllowThreads(__tstate);
 
36154
    if (PyErr_Occurred()) SWIG_fail;
 
36155
  }
 
36156
  resultobj = SWIG_Py_Void();
 
36157
  return resultobj;
 
36158
fail:
 
36159
  return NULL;
 
36160
}
 
36161
 
 
36162
 
 
36163
SWIGINTERN PyObject *_wrap_TreeCtrl_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36164
  PyObject *resultobj = 0;
 
36165
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36166
  wxTreeItemId *arg2 = 0 ;
 
36167
  bool result;
 
36168
  void *argp1 = 0 ;
 
36169
  int res1 = 0 ;
 
36170
  void *argp2 = 0 ;
 
36171
  int res2 = 0 ;
 
36172
  PyObject * obj0 = 0 ;
 
36173
  PyObject * obj1 = 0 ;
 
36174
  char *  kwnames[] = {
 
36175
    (char *) "self",(char *) "item", NULL 
 
36176
  };
 
36177
  
 
36178
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsVisible",kwnames,&obj0,&obj1)) SWIG_fail;
 
36179
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36180
  if (!SWIG_IsOK(res1)) {
 
36181
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_IsVisible" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36182
  }
 
36183
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36184
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36185
  if (!SWIG_IsOK(res2)) {
 
36186
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_IsVisible" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36187
  }
 
36188
  if (!argp2) {
 
36189
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_IsVisible" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36190
  }
 
36191
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36192
  {
 
36193
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36194
    result = (bool)((wxPyTreeCtrl const *)arg1)->IsVisible((wxTreeItemId const &)*arg2);
 
36195
    wxPyEndAllowThreads(__tstate);
 
36196
    if (PyErr_Occurred()) SWIG_fail;
 
36197
  }
 
36198
  {
 
36199
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
36200
  }
 
36201
  return resultobj;
 
36202
fail:
 
36203
  return NULL;
 
36204
}
 
36205
 
 
36206
 
 
36207
SWIGINTERN PyObject *_wrap_TreeCtrl_ItemHasChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36208
  PyObject *resultobj = 0;
 
36209
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36210
  wxTreeItemId *arg2 = 0 ;
 
36211
  bool result;
 
36212
  void *argp1 = 0 ;
 
36213
  int res1 = 0 ;
 
36214
  void *argp2 = 0 ;
 
36215
  int res2 = 0 ;
 
36216
  PyObject * obj0 = 0 ;
 
36217
  PyObject * obj1 = 0 ;
 
36218
  char *  kwnames[] = {
 
36219
    (char *) "self",(char *) "item", NULL 
 
36220
  };
 
36221
  
 
36222
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_ItemHasChildren",kwnames,&obj0,&obj1)) SWIG_fail;
 
36223
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36224
  if (!SWIG_IsOK(res1)) {
 
36225
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_ItemHasChildren" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36226
  }
 
36227
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36228
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36229
  if (!SWIG_IsOK(res2)) {
 
36230
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_ItemHasChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36231
  }
 
36232
  if (!argp2) {
 
36233
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_ItemHasChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36234
  }
 
36235
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36236
  {
 
36237
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36238
    result = (bool)((wxPyTreeCtrl const *)arg1)->ItemHasChildren((wxTreeItemId const &)*arg2);
 
36239
    wxPyEndAllowThreads(__tstate);
 
36240
    if (PyErr_Occurred()) SWIG_fail;
 
36241
  }
 
36242
  {
 
36243
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
36244
  }
 
36245
  return resultobj;
 
36246
fail:
 
36247
  return NULL;
 
36248
}
 
36249
 
 
36250
 
 
36251
SWIGINTERN PyObject *_wrap_TreeCtrl_IsExpanded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36252
  PyObject *resultobj = 0;
 
36253
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36254
  wxTreeItemId *arg2 = 0 ;
 
36255
  bool result;
 
36256
  void *argp1 = 0 ;
 
36257
  int res1 = 0 ;
 
36258
  void *argp2 = 0 ;
 
36259
  int res2 = 0 ;
 
36260
  PyObject * obj0 = 0 ;
 
36261
  PyObject * obj1 = 0 ;
 
36262
  char *  kwnames[] = {
 
36263
    (char *) "self",(char *) "item", NULL 
 
36264
  };
 
36265
  
 
36266
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsExpanded",kwnames,&obj0,&obj1)) SWIG_fail;
 
36267
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36268
  if (!SWIG_IsOK(res1)) {
 
36269
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_IsExpanded" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36270
  }
 
36271
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36272
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36273
  if (!SWIG_IsOK(res2)) {
 
36274
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_IsExpanded" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36275
  }
 
36276
  if (!argp2) {
 
36277
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_IsExpanded" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36278
  }
 
36279
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36280
  {
 
36281
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36282
    result = (bool)((wxPyTreeCtrl const *)arg1)->IsExpanded((wxTreeItemId const &)*arg2);
 
36283
    wxPyEndAllowThreads(__tstate);
 
36284
    if (PyErr_Occurred()) SWIG_fail;
 
36285
  }
 
36286
  {
 
36287
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
36288
  }
 
36289
  return resultobj;
 
36290
fail:
 
36291
  return NULL;
 
36292
}
 
36293
 
 
36294
 
 
36295
SWIGINTERN PyObject *_wrap_TreeCtrl_IsSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36296
  PyObject *resultobj = 0;
 
36297
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36298
  wxTreeItemId *arg2 = 0 ;
 
36299
  bool result;
 
36300
  void *argp1 = 0 ;
 
36301
  int res1 = 0 ;
 
36302
  void *argp2 = 0 ;
 
36303
  int res2 = 0 ;
 
36304
  PyObject * obj0 = 0 ;
 
36305
  PyObject * obj1 = 0 ;
 
36306
  char *  kwnames[] = {
 
36307
    (char *) "self",(char *) "item", NULL 
 
36308
  };
 
36309
  
 
36310
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsSelected",kwnames,&obj0,&obj1)) SWIG_fail;
 
36311
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36312
  if (!SWIG_IsOK(res1)) {
 
36313
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_IsSelected" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36314
  }
 
36315
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36316
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36317
  if (!SWIG_IsOK(res2)) {
 
36318
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_IsSelected" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36319
  }
 
36320
  if (!argp2) {
 
36321
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_IsSelected" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36322
  }
 
36323
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36324
  {
 
36325
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36326
    result = (bool)((wxPyTreeCtrl const *)arg1)->IsSelected((wxTreeItemId const &)*arg2);
 
36327
    wxPyEndAllowThreads(__tstate);
 
36328
    if (PyErr_Occurred()) SWIG_fail;
 
36329
  }
 
36330
  {
 
36331
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
36332
  }
 
36333
  return resultobj;
 
36334
fail:
 
36335
  return NULL;
 
36336
}
 
36337
 
 
36338
 
 
36339
SWIGINTERN PyObject *_wrap_TreeCtrl_IsBold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36340
  PyObject *resultobj = 0;
 
36341
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36342
  wxTreeItemId *arg2 = 0 ;
 
36343
  bool result;
 
36344
  void *argp1 = 0 ;
 
36345
  int res1 = 0 ;
 
36346
  void *argp2 = 0 ;
 
36347
  int res2 = 0 ;
 
36348
  PyObject * obj0 = 0 ;
 
36349
  PyObject * obj1 = 0 ;
 
36350
  char *  kwnames[] = {
 
36351
    (char *) "self",(char *) "item", NULL 
 
36352
  };
 
36353
  
 
36354
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_IsBold",kwnames,&obj0,&obj1)) SWIG_fail;
 
36355
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36356
  if (!SWIG_IsOK(res1)) {
 
36357
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_IsBold" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36358
  }
 
36359
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36360
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36361
  if (!SWIG_IsOK(res2)) {
 
36362
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_IsBold" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36363
  }
 
36364
  if (!argp2) {
 
36365
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_IsBold" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36366
  }
 
36367
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36368
  {
 
36369
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36370
    result = (bool)((wxPyTreeCtrl const *)arg1)->IsBold((wxTreeItemId const &)*arg2);
 
36371
    wxPyEndAllowThreads(__tstate);
 
36372
    if (PyErr_Occurred()) SWIG_fail;
 
36373
  }
 
36374
  {
 
36375
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
36376
  }
 
36377
  return resultobj;
 
36378
fail:
 
36379
  return NULL;
 
36380
}
 
36381
 
 
36382
 
 
36383
SWIGINTERN PyObject *_wrap_TreeCtrl_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
36384
  PyObject *resultobj = 0;
 
36385
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36386
  bool result;
 
36387
  void *argp1 = 0 ;
 
36388
  int res1 = 0 ;
 
36389
  PyObject *swig_obj[1] ;
 
36390
  
 
36391
  if (!args) SWIG_fail;
 
36392
  swig_obj[0] = args;
 
36393
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36394
  if (!SWIG_IsOK(res1)) {
 
36395
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_IsEmpty" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36396
  }
 
36397
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36398
  {
 
36399
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36400
    result = (bool)((wxPyTreeCtrl const *)arg1)->IsEmpty();
 
36401
    wxPyEndAllowThreads(__tstate);
 
36402
    if (PyErr_Occurred()) SWIG_fail;
 
36403
  }
 
36404
  {
 
36405
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
36406
  }
 
36407
  return resultobj;
 
36408
fail:
 
36409
  return NULL;
 
36410
}
 
36411
 
 
36412
 
 
36413
SWIGINTERN PyObject *_wrap_TreeCtrl_GetChildrenCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36414
  PyObject *resultobj = 0;
 
36415
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36416
  wxTreeItemId *arg2 = 0 ;
 
36417
  bool arg3 = (bool) true ;
 
36418
  size_t result;
 
36419
  void *argp1 = 0 ;
 
36420
  int res1 = 0 ;
 
36421
  void *argp2 = 0 ;
 
36422
  int res2 = 0 ;
 
36423
  bool val3 ;
 
36424
  int ecode3 = 0 ;
 
36425
  PyObject * obj0 = 0 ;
 
36426
  PyObject * obj1 = 0 ;
 
36427
  PyObject * obj2 = 0 ;
 
36428
  char *  kwnames[] = {
 
36429
    (char *) "self",(char *) "item",(char *) "recursively", NULL 
 
36430
  };
 
36431
  
 
36432
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_GetChildrenCount",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
36433
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36434
  if (!SWIG_IsOK(res1)) {
 
36435
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetChildrenCount" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
36436
  }
 
36437
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36438
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36439
  if (!SWIG_IsOK(res2)) {
 
36440
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetChildrenCount" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36441
  }
 
36442
  if (!argp2) {
 
36443
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetChildrenCount" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36444
  }
 
36445
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36446
  if (obj2) {
 
36447
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
36448
    if (!SWIG_IsOK(ecode3)) {
 
36449
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_GetChildrenCount" "', expected argument " "3"" of type '" "bool""'");
 
36450
    } 
 
36451
    arg3 = static_cast< bool >(val3);
 
36452
  }
 
36453
  {
 
36454
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36455
    result = (size_t)(arg1)->GetChildrenCount((wxTreeItemId const &)*arg2,arg3);
 
36456
    wxPyEndAllowThreads(__tstate);
 
36457
    if (PyErr_Occurred()) SWIG_fail;
 
36458
  }
 
36459
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
 
36460
  return resultobj;
 
36461
fail:
 
36462
  return NULL;
 
36463
}
 
36464
 
 
36465
 
 
36466
SWIGINTERN PyObject *_wrap_TreeCtrl_GetRootItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
36467
  PyObject *resultobj = 0;
 
36468
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36469
  wxTreeItemId result;
 
36470
  void *argp1 = 0 ;
 
36471
  int res1 = 0 ;
 
36472
  PyObject *swig_obj[1] ;
 
36473
  
 
36474
  if (!args) SWIG_fail;
 
36475
  swig_obj[0] = args;
 
36476
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36477
  if (!SWIG_IsOK(res1)) {
 
36478
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetRootItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36479
  }
 
36480
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36481
  {
 
36482
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36483
    result = ((wxPyTreeCtrl const *)arg1)->GetRootItem();
 
36484
    wxPyEndAllowThreads(__tstate);
 
36485
    if (PyErr_Occurred()) SWIG_fail;
 
36486
  }
 
36487
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
36488
  return resultobj;
 
36489
fail:
 
36490
  return NULL;
 
36491
}
 
36492
 
 
36493
 
 
36494
SWIGINTERN PyObject *_wrap_TreeCtrl_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
36495
  PyObject *resultobj = 0;
 
36496
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36497
  wxTreeItemId result;
 
36498
  void *argp1 = 0 ;
 
36499
  int res1 = 0 ;
 
36500
  PyObject *swig_obj[1] ;
 
36501
  
 
36502
  if (!args) SWIG_fail;
 
36503
  swig_obj[0] = args;
 
36504
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36505
  if (!SWIG_IsOK(res1)) {
 
36506
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetSelection" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36507
  }
 
36508
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36509
  {
 
36510
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36511
    result = ((wxPyTreeCtrl const *)arg1)->GetSelection();
 
36512
    wxPyEndAllowThreads(__tstate);
 
36513
    if (PyErr_Occurred()) SWIG_fail;
 
36514
  }
 
36515
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
36516
  return resultobj;
 
36517
fail:
 
36518
  return NULL;
 
36519
}
 
36520
 
 
36521
 
 
36522
SWIGINTERN PyObject *_wrap_TreeCtrl_GetSelections(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
36523
  PyObject *resultobj = 0;
 
36524
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36525
  PyObject *result = 0 ;
 
36526
  void *argp1 = 0 ;
 
36527
  int res1 = 0 ;
 
36528
  PyObject *swig_obj[1] ;
 
36529
  
 
36530
  if (!args) SWIG_fail;
 
36531
  swig_obj[0] = args;
 
36532
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36533
  if (!SWIG_IsOK(res1)) {
 
36534
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetSelections" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
36535
  }
 
36536
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36537
  {
 
36538
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36539
    result = (PyObject *)wxPyTreeCtrl_GetSelections(arg1);
 
36540
    wxPyEndAllowThreads(__tstate);
 
36541
    if (PyErr_Occurred()) SWIG_fail;
 
36542
  }
 
36543
  resultobj = result;
 
36544
  return resultobj;
 
36545
fail:
 
36546
  return NULL;
 
36547
}
 
36548
 
 
36549
 
 
36550
SWIGINTERN PyObject *_wrap_TreeCtrl_GetFocusedItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
36551
  PyObject *resultobj = 0;
 
36552
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36553
  wxTreeItemId result;
 
36554
  void *argp1 = 0 ;
 
36555
  int res1 = 0 ;
 
36556
  PyObject *swig_obj[1] ;
 
36557
  
 
36558
  if (!args) SWIG_fail;
 
36559
  swig_obj[0] = args;
 
36560
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36561
  if (!SWIG_IsOK(res1)) {
 
36562
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetFocusedItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36563
  }
 
36564
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36565
  {
 
36566
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36567
    result = ((wxPyTreeCtrl const *)arg1)->GetFocusedItem();
 
36568
    wxPyEndAllowThreads(__tstate);
 
36569
    if (PyErr_Occurred()) SWIG_fail;
 
36570
  }
 
36571
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
36572
  return resultobj;
 
36573
fail:
 
36574
  return NULL;
 
36575
}
 
36576
 
 
36577
 
 
36578
SWIGINTERN PyObject *_wrap_TreeCtrl_ClearFocusedItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
36579
  PyObject *resultobj = 0;
 
36580
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36581
  void *argp1 = 0 ;
 
36582
  int res1 = 0 ;
 
36583
  PyObject *swig_obj[1] ;
 
36584
  
 
36585
  if (!args) SWIG_fail;
 
36586
  swig_obj[0] = args;
 
36587
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36588
  if (!SWIG_IsOK(res1)) {
 
36589
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_ClearFocusedItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
36590
  }
 
36591
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36592
  {
 
36593
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36594
    (arg1)->ClearFocusedItem();
 
36595
    wxPyEndAllowThreads(__tstate);
 
36596
    if (PyErr_Occurred()) SWIG_fail;
 
36597
  }
 
36598
  resultobj = SWIG_Py_Void();
 
36599
  return resultobj;
 
36600
fail:
 
36601
  return NULL;
 
36602
}
 
36603
 
 
36604
 
 
36605
SWIGINTERN PyObject *_wrap_TreeCtrl_SetFocusedItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36606
  PyObject *resultobj = 0;
 
36607
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36608
  wxTreeItemId *arg2 = 0 ;
 
36609
  void *argp1 = 0 ;
 
36610
  int res1 = 0 ;
 
36611
  void *argp2 = 0 ;
 
36612
  int res2 = 0 ;
 
36613
  PyObject * obj0 = 0 ;
 
36614
  PyObject * obj1 = 0 ;
 
36615
  char *  kwnames[] = {
 
36616
    (char *) "self",(char *) "item", NULL 
 
36617
  };
 
36618
  
 
36619
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetFocusedItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
36620
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36621
  if (!SWIG_IsOK(res1)) {
 
36622
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetFocusedItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
36623
  }
 
36624
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36625
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36626
  if (!SWIG_IsOK(res2)) {
 
36627
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SetFocusedItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36628
  }
 
36629
  if (!argp2) {
 
36630
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SetFocusedItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36631
  }
 
36632
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36633
  {
 
36634
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36635
    (arg1)->SetFocusedItem((wxTreeItemId const &)*arg2);
 
36636
    wxPyEndAllowThreads(__tstate);
 
36637
    if (PyErr_Occurred()) SWIG_fail;
 
36638
  }
 
36639
  resultobj = SWIG_Py_Void();
 
36640
  return resultobj;
 
36641
fail:
 
36642
  return NULL;
 
36643
}
 
36644
 
 
36645
 
 
36646
SWIGINTERN PyObject *_wrap_TreeCtrl_GetItemParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36647
  PyObject *resultobj = 0;
 
36648
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36649
  wxTreeItemId *arg2 = 0 ;
 
36650
  wxTreeItemId result;
 
36651
  void *argp1 = 0 ;
 
36652
  int res1 = 0 ;
 
36653
  void *argp2 = 0 ;
 
36654
  int res2 = 0 ;
 
36655
  PyObject * obj0 = 0 ;
 
36656
  PyObject * obj1 = 0 ;
 
36657
  char *  kwnames[] = {
 
36658
    (char *) "self",(char *) "item", NULL 
 
36659
  };
 
36660
  
 
36661
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetItemParent",kwnames,&obj0,&obj1)) SWIG_fail;
 
36662
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36663
  if (!SWIG_IsOK(res1)) {
 
36664
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetItemParent" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36665
  }
 
36666
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36667
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36668
  if (!SWIG_IsOK(res2)) {
 
36669
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetItemParent" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36670
  }
 
36671
  if (!argp2) {
 
36672
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetItemParent" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36673
  }
 
36674
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36675
  {
 
36676
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36677
    result = ((wxPyTreeCtrl const *)arg1)->GetItemParent((wxTreeItemId const &)*arg2);
 
36678
    wxPyEndAllowThreads(__tstate);
 
36679
    if (PyErr_Occurred()) SWIG_fail;
 
36680
  }
 
36681
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
36682
  return resultobj;
 
36683
fail:
 
36684
  return NULL;
 
36685
}
 
36686
 
 
36687
 
 
36688
SWIGINTERN PyObject *_wrap_TreeCtrl_GetFirstChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36689
  PyObject *resultobj = 0;
 
36690
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36691
  wxTreeItemId *arg2 = 0 ;
 
36692
  PyObject *result = 0 ;
 
36693
  void *argp1 = 0 ;
 
36694
  int res1 = 0 ;
 
36695
  void *argp2 = 0 ;
 
36696
  int res2 = 0 ;
 
36697
  PyObject * obj0 = 0 ;
 
36698
  PyObject * obj1 = 0 ;
 
36699
  char *  kwnames[] = {
 
36700
    (char *) "self",(char *) "item", NULL 
 
36701
  };
 
36702
  
 
36703
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetFirstChild",kwnames,&obj0,&obj1)) SWIG_fail;
 
36704
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36705
  if (!SWIG_IsOK(res1)) {
 
36706
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetFirstChild" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
36707
  }
 
36708
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36709
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36710
  if (!SWIG_IsOK(res2)) {
 
36711
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetFirstChild" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36712
  }
 
36713
  if (!argp2) {
 
36714
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetFirstChild" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36715
  }
 
36716
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36717
  {
 
36718
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36719
    result = (PyObject *)wxPyTreeCtrl_GetFirstChild(arg1,(wxTreeItemId const &)*arg2);
 
36720
    wxPyEndAllowThreads(__tstate);
 
36721
    if (PyErr_Occurred()) SWIG_fail;
 
36722
  }
 
36723
  resultobj = result;
 
36724
  return resultobj;
 
36725
fail:
 
36726
  return NULL;
 
36727
}
 
36728
 
 
36729
 
 
36730
SWIGINTERN PyObject *_wrap_TreeCtrl_GetNextChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36731
  PyObject *resultobj = 0;
 
36732
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36733
  wxTreeItemId *arg2 = 0 ;
 
36734
  void *arg3 = (void *) 0 ;
 
36735
  PyObject *result = 0 ;
 
36736
  void *argp1 = 0 ;
 
36737
  int res1 = 0 ;
 
36738
  void *argp2 = 0 ;
 
36739
  int res2 = 0 ;
 
36740
  int res3 ;
 
36741
  PyObject * obj0 = 0 ;
 
36742
  PyObject * obj1 = 0 ;
 
36743
  PyObject * obj2 = 0 ;
 
36744
  char *  kwnames[] = {
 
36745
    (char *) "self",(char *) "item",(char *) "cookie", NULL 
 
36746
  };
 
36747
  
 
36748
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TreeCtrl_GetNextChild",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
36749
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36750
  if (!SWIG_IsOK(res1)) {
 
36751
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetNextChild" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
36752
  }
 
36753
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36754
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36755
  if (!SWIG_IsOK(res2)) {
 
36756
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetNextChild" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36757
  }
 
36758
  if (!argp2) {
 
36759
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetNextChild" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36760
  }
 
36761
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36762
  res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
 
36763
  if (!SWIG_IsOK(res3)) {
 
36764
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TreeCtrl_GetNextChild" "', expected argument " "3"" of type '" "void *""'"); 
 
36765
  }
 
36766
  {
 
36767
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36768
    result = (PyObject *)wxPyTreeCtrl_GetNextChild(arg1,(wxTreeItemId const &)*arg2,arg3);
 
36769
    wxPyEndAllowThreads(__tstate);
 
36770
    if (PyErr_Occurred()) SWIG_fail;
 
36771
  }
 
36772
  resultobj = result;
 
36773
  return resultobj;
 
36774
fail:
 
36775
  return NULL;
 
36776
}
 
36777
 
 
36778
 
 
36779
SWIGINTERN PyObject *_wrap_TreeCtrl_GetLastChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36780
  PyObject *resultobj = 0;
 
36781
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36782
  wxTreeItemId *arg2 = 0 ;
 
36783
  wxTreeItemId result;
 
36784
  void *argp1 = 0 ;
 
36785
  int res1 = 0 ;
 
36786
  void *argp2 = 0 ;
 
36787
  int res2 = 0 ;
 
36788
  PyObject * obj0 = 0 ;
 
36789
  PyObject * obj1 = 0 ;
 
36790
  char *  kwnames[] = {
 
36791
    (char *) "self",(char *) "item", NULL 
 
36792
  };
 
36793
  
 
36794
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetLastChild",kwnames,&obj0,&obj1)) SWIG_fail;
 
36795
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36796
  if (!SWIG_IsOK(res1)) {
 
36797
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetLastChild" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36798
  }
 
36799
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36800
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36801
  if (!SWIG_IsOK(res2)) {
 
36802
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetLastChild" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36803
  }
 
36804
  if (!argp2) {
 
36805
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetLastChild" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36806
  }
 
36807
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36808
  {
 
36809
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36810
    result = ((wxPyTreeCtrl const *)arg1)->GetLastChild((wxTreeItemId const &)*arg2);
 
36811
    wxPyEndAllowThreads(__tstate);
 
36812
    if (PyErr_Occurred()) SWIG_fail;
 
36813
  }
 
36814
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
36815
  return resultobj;
 
36816
fail:
 
36817
  return NULL;
 
36818
}
 
36819
 
 
36820
 
 
36821
SWIGINTERN PyObject *_wrap_TreeCtrl_GetNextSibling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36822
  PyObject *resultobj = 0;
 
36823
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36824
  wxTreeItemId *arg2 = 0 ;
 
36825
  wxTreeItemId result;
 
36826
  void *argp1 = 0 ;
 
36827
  int res1 = 0 ;
 
36828
  void *argp2 = 0 ;
 
36829
  int res2 = 0 ;
 
36830
  PyObject * obj0 = 0 ;
 
36831
  PyObject * obj1 = 0 ;
 
36832
  char *  kwnames[] = {
 
36833
    (char *) "self",(char *) "item", NULL 
 
36834
  };
 
36835
  
 
36836
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetNextSibling",kwnames,&obj0,&obj1)) SWIG_fail;
 
36837
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36838
  if (!SWIG_IsOK(res1)) {
 
36839
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetNextSibling" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36840
  }
 
36841
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36842
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36843
  if (!SWIG_IsOK(res2)) {
 
36844
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetNextSibling" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36845
  }
 
36846
  if (!argp2) {
 
36847
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetNextSibling" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36848
  }
 
36849
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36850
  {
 
36851
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36852
    result = ((wxPyTreeCtrl const *)arg1)->GetNextSibling((wxTreeItemId const &)*arg2);
 
36853
    wxPyEndAllowThreads(__tstate);
 
36854
    if (PyErr_Occurred()) SWIG_fail;
 
36855
  }
 
36856
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
36857
  return resultobj;
 
36858
fail:
 
36859
  return NULL;
 
36860
}
 
36861
 
 
36862
 
 
36863
SWIGINTERN PyObject *_wrap_TreeCtrl_GetPrevSibling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36864
  PyObject *resultobj = 0;
 
36865
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36866
  wxTreeItemId *arg2 = 0 ;
 
36867
  wxTreeItemId result;
 
36868
  void *argp1 = 0 ;
 
36869
  int res1 = 0 ;
 
36870
  void *argp2 = 0 ;
 
36871
  int res2 = 0 ;
 
36872
  PyObject * obj0 = 0 ;
 
36873
  PyObject * obj1 = 0 ;
 
36874
  char *  kwnames[] = {
 
36875
    (char *) "self",(char *) "item", NULL 
 
36876
  };
 
36877
  
 
36878
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetPrevSibling",kwnames,&obj0,&obj1)) SWIG_fail;
 
36879
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36880
  if (!SWIG_IsOK(res1)) {
 
36881
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetPrevSibling" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36882
  }
 
36883
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36884
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36885
  if (!SWIG_IsOK(res2)) {
 
36886
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetPrevSibling" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36887
  }
 
36888
  if (!argp2) {
 
36889
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetPrevSibling" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36890
  }
 
36891
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36892
  {
 
36893
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36894
    result = ((wxPyTreeCtrl const *)arg1)->GetPrevSibling((wxTreeItemId const &)*arg2);
 
36895
    wxPyEndAllowThreads(__tstate);
 
36896
    if (PyErr_Occurred()) SWIG_fail;
 
36897
  }
 
36898
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
36899
  return resultobj;
 
36900
fail:
 
36901
  return NULL;
 
36902
}
 
36903
 
 
36904
 
 
36905
SWIGINTERN PyObject *_wrap_TreeCtrl_GetFirstVisibleItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
36906
  PyObject *resultobj = 0;
 
36907
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36908
  wxTreeItemId result;
 
36909
  void *argp1 = 0 ;
 
36910
  int res1 = 0 ;
 
36911
  PyObject *swig_obj[1] ;
 
36912
  
 
36913
  if (!args) SWIG_fail;
 
36914
  swig_obj[0] = args;
 
36915
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36916
  if (!SWIG_IsOK(res1)) {
 
36917
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetFirstVisibleItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36918
  }
 
36919
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36920
  {
 
36921
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36922
    result = ((wxPyTreeCtrl const *)arg1)->GetFirstVisibleItem();
 
36923
    wxPyEndAllowThreads(__tstate);
 
36924
    if (PyErr_Occurred()) SWIG_fail;
 
36925
  }
 
36926
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
36927
  return resultobj;
 
36928
fail:
 
36929
  return NULL;
 
36930
}
 
36931
 
 
36932
 
 
36933
SWIGINTERN PyObject *_wrap_TreeCtrl_GetNextVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36934
  PyObject *resultobj = 0;
 
36935
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36936
  wxTreeItemId *arg2 = 0 ;
 
36937
  wxTreeItemId result;
 
36938
  void *argp1 = 0 ;
 
36939
  int res1 = 0 ;
 
36940
  void *argp2 = 0 ;
 
36941
  int res2 = 0 ;
 
36942
  PyObject * obj0 = 0 ;
 
36943
  PyObject * obj1 = 0 ;
 
36944
  char *  kwnames[] = {
 
36945
    (char *) "self",(char *) "item", NULL 
 
36946
  };
 
36947
  
 
36948
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetNextVisible",kwnames,&obj0,&obj1)) SWIG_fail;
 
36949
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36950
  if (!SWIG_IsOK(res1)) {
 
36951
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetNextVisible" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36952
  }
 
36953
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36954
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36955
  if (!SWIG_IsOK(res2)) {
 
36956
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetNextVisible" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36957
  }
 
36958
  if (!argp2) {
 
36959
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetNextVisible" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36960
  }
 
36961
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
36962
  {
 
36963
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
36964
    result = ((wxPyTreeCtrl const *)arg1)->GetNextVisible((wxTreeItemId const &)*arg2);
 
36965
    wxPyEndAllowThreads(__tstate);
 
36966
    if (PyErr_Occurred()) SWIG_fail;
 
36967
  }
 
36968
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
36969
  return resultobj;
 
36970
fail:
 
36971
  return NULL;
 
36972
}
 
36973
 
 
36974
 
 
36975
SWIGINTERN PyObject *_wrap_TreeCtrl_GetPrevVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
36976
  PyObject *resultobj = 0;
 
36977
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
36978
  wxTreeItemId *arg2 = 0 ;
 
36979
  wxTreeItemId result;
 
36980
  void *argp1 = 0 ;
 
36981
  int res1 = 0 ;
 
36982
  void *argp2 = 0 ;
 
36983
  int res2 = 0 ;
 
36984
  PyObject * obj0 = 0 ;
 
36985
  PyObject * obj1 = 0 ;
 
36986
  char *  kwnames[] = {
 
36987
    (char *) "self",(char *) "item", NULL 
 
36988
  };
 
36989
  
 
36990
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_GetPrevVisible",kwnames,&obj0,&obj1)) SWIG_fail;
 
36991
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
36992
  if (!SWIG_IsOK(res1)) {
 
36993
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetPrevVisible" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
36994
  }
 
36995
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
36996
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
36997
  if (!SWIG_IsOK(res2)) {
 
36998
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetPrevVisible" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
36999
  }
 
37000
  if (!argp2) {
 
37001
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetPrevVisible" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37002
  }
 
37003
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37004
  {
 
37005
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37006
    result = ((wxPyTreeCtrl const *)arg1)->GetPrevVisible((wxTreeItemId const &)*arg2);
 
37007
    wxPyEndAllowThreads(__tstate);
 
37008
    if (PyErr_Occurred()) SWIG_fail;
 
37009
  }
 
37010
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
37011
  return resultobj;
 
37012
fail:
 
37013
  return NULL;
 
37014
}
 
37015
 
 
37016
 
 
37017
SWIGINTERN PyObject *_wrap_TreeCtrl_AddRoot(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37018
  PyObject *resultobj = 0;
 
37019
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37020
  wxString *arg2 = 0 ;
 
37021
  int arg3 = (int) -1 ;
 
37022
  int arg4 = (int) -1 ;
 
37023
  wxPyTreeItemData *arg5 = (wxPyTreeItemData *) NULL ;
 
37024
  wxTreeItemId result;
 
37025
  void *argp1 = 0 ;
 
37026
  int res1 = 0 ;
 
37027
  bool temp2 = false ;
 
37028
  int val3 ;
 
37029
  int ecode3 = 0 ;
 
37030
  int val4 ;
 
37031
  int ecode4 = 0 ;
 
37032
  int res5 = 0 ;
 
37033
  PyObject * obj0 = 0 ;
 
37034
  PyObject * obj1 = 0 ;
 
37035
  PyObject * obj2 = 0 ;
 
37036
  PyObject * obj3 = 0 ;
 
37037
  PyObject * obj4 = 0 ;
 
37038
  char *  kwnames[] = {
 
37039
    (char *) "self",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL 
 
37040
  };
 
37041
  
 
37042
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:TreeCtrl_AddRoot",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
37043
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37044
  if (!SWIG_IsOK(res1)) {
 
37045
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_AddRoot" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37046
  }
 
37047
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37048
  {
 
37049
    arg2 = wxString_in_helper(obj1);
 
37050
    if (arg2 == NULL) SWIG_fail;
 
37051
    temp2 = true;
 
37052
  }
 
37053
  if (obj2) {
 
37054
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
37055
    if (!SWIG_IsOK(ecode3)) {
 
37056
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_AddRoot" "', expected argument " "3"" of type '" "int""'");
 
37057
    } 
 
37058
    arg3 = static_cast< int >(val3);
 
37059
  }
 
37060
  if (obj3) {
 
37061
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
37062
    if (!SWIG_IsOK(ecode4)) {
 
37063
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TreeCtrl_AddRoot" "', expected argument " "4"" of type '" "int""'");
 
37064
    } 
 
37065
    arg4 = static_cast< int >(val4);
 
37066
  }
 
37067
  if (obj4) {
 
37068
    res5 = SWIG_ConvertPtr(obj4, SWIG_as_voidptrptr(&arg5), SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_DISOWN |  0 );
 
37069
    if (!SWIG_IsOK(res5)) {
 
37070
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TreeCtrl_AddRoot" "', expected argument " "5"" of type '" "wxPyTreeItemData *""'");
 
37071
    }
 
37072
  }
 
37073
  {
 
37074
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37075
    result = (arg1)->AddRoot((wxString const &)*arg2,arg3,arg4,arg5);
 
37076
    wxPyEndAllowThreads(__tstate);
 
37077
    if (PyErr_Occurred()) SWIG_fail;
 
37078
  }
 
37079
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
37080
  {
 
37081
    if (temp2)
 
37082
    delete arg2;
 
37083
  }
 
37084
  return resultobj;
 
37085
fail:
 
37086
  {
 
37087
    if (temp2)
 
37088
    delete arg2;
 
37089
  }
 
37090
  return NULL;
 
37091
}
 
37092
 
 
37093
 
 
37094
SWIGINTERN PyObject *_wrap_TreeCtrl_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37095
  PyObject *resultobj = 0;
 
37096
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37097
  wxTreeItemId *arg2 = 0 ;
 
37098
  wxString *arg3 = 0 ;
 
37099
  int arg4 = (int) -1 ;
 
37100
  int arg5 = (int) -1 ;
 
37101
  wxPyTreeItemData *arg6 = (wxPyTreeItemData *) NULL ;
 
37102
  wxTreeItemId result;
 
37103
  void *argp1 = 0 ;
 
37104
  int res1 = 0 ;
 
37105
  void *argp2 = 0 ;
 
37106
  int res2 = 0 ;
 
37107
  bool temp3 = false ;
 
37108
  int val4 ;
 
37109
  int ecode4 = 0 ;
 
37110
  int val5 ;
 
37111
  int ecode5 = 0 ;
 
37112
  int res6 = 0 ;
 
37113
  PyObject * obj0 = 0 ;
 
37114
  PyObject * obj1 = 0 ;
 
37115
  PyObject * obj2 = 0 ;
 
37116
  PyObject * obj3 = 0 ;
 
37117
  PyObject * obj4 = 0 ;
 
37118
  PyObject * obj5 = 0 ;
 
37119
  char *  kwnames[] = {
 
37120
    (char *) "self",(char *) "parent",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL 
 
37121
  };
 
37122
  
 
37123
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:TreeCtrl_PrependItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
37124
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37125
  if (!SWIG_IsOK(res1)) {
 
37126
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_PrependItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37127
  }
 
37128
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37129
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37130
  if (!SWIG_IsOK(res2)) {
 
37131
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_PrependItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37132
  }
 
37133
  if (!argp2) {
 
37134
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_PrependItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37135
  }
 
37136
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37137
  {
 
37138
    arg3 = wxString_in_helper(obj2);
 
37139
    if (arg3 == NULL) SWIG_fail;
 
37140
    temp3 = true;
 
37141
  }
 
37142
  if (obj3) {
 
37143
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
37144
    if (!SWIG_IsOK(ecode4)) {
 
37145
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TreeCtrl_PrependItem" "', expected argument " "4"" of type '" "int""'");
 
37146
    } 
 
37147
    arg4 = static_cast< int >(val4);
 
37148
  }
 
37149
  if (obj4) {
 
37150
    ecode5 = SWIG_AsVal_int(obj4, &val5);
 
37151
    if (!SWIG_IsOK(ecode5)) {
 
37152
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TreeCtrl_PrependItem" "', expected argument " "5"" of type '" "int""'");
 
37153
    } 
 
37154
    arg5 = static_cast< int >(val5);
 
37155
  }
 
37156
  if (obj5) {
 
37157
    res6 = SWIG_ConvertPtr(obj5, SWIG_as_voidptrptr(&arg6), SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_DISOWN |  0 );
 
37158
    if (!SWIG_IsOK(res6)) {
 
37159
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TreeCtrl_PrependItem" "', expected argument " "6"" of type '" "wxPyTreeItemData *""'");
 
37160
    }
 
37161
  }
 
37162
  {
 
37163
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37164
    result = (arg1)->PrependItem((wxTreeItemId const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6);
 
37165
    wxPyEndAllowThreads(__tstate);
 
37166
    if (PyErr_Occurred()) SWIG_fail;
 
37167
  }
 
37168
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
37169
  {
 
37170
    if (temp3)
 
37171
    delete arg3;
 
37172
  }
 
37173
  return resultobj;
 
37174
fail:
 
37175
  {
 
37176
    if (temp3)
 
37177
    delete arg3;
 
37178
  }
 
37179
  return NULL;
 
37180
}
 
37181
 
 
37182
 
 
37183
SWIGINTERN PyObject *_wrap_TreeCtrl_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37184
  PyObject *resultobj = 0;
 
37185
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37186
  wxTreeItemId *arg2 = 0 ;
 
37187
  wxTreeItemId *arg3 = 0 ;
 
37188
  wxString *arg4 = 0 ;
 
37189
  int arg5 = (int) -1 ;
 
37190
  int arg6 = (int) -1 ;
 
37191
  wxPyTreeItemData *arg7 = (wxPyTreeItemData *) NULL ;
 
37192
  wxTreeItemId result;
 
37193
  void *argp1 = 0 ;
 
37194
  int res1 = 0 ;
 
37195
  void *argp2 = 0 ;
 
37196
  int res2 = 0 ;
 
37197
  void *argp3 = 0 ;
 
37198
  int res3 = 0 ;
 
37199
  bool temp4 = false ;
 
37200
  int val5 ;
 
37201
  int ecode5 = 0 ;
 
37202
  int val6 ;
 
37203
  int ecode6 = 0 ;
 
37204
  int res7 = 0 ;
 
37205
  PyObject * obj0 = 0 ;
 
37206
  PyObject * obj1 = 0 ;
 
37207
  PyObject * obj2 = 0 ;
 
37208
  PyObject * obj3 = 0 ;
 
37209
  PyObject * obj4 = 0 ;
 
37210
  PyObject * obj5 = 0 ;
 
37211
  PyObject * obj6 = 0 ;
 
37212
  char *  kwnames[] = {
 
37213
    (char *) "self",(char *) "parent",(char *) "idPrevious",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL 
 
37214
  };
 
37215
  
 
37216
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:TreeCtrl_InsertItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
37217
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37218
  if (!SWIG_IsOK(res1)) {
 
37219
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_InsertItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37220
  }
 
37221
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37222
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37223
  if (!SWIG_IsOK(res2)) {
 
37224
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_InsertItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37225
  }
 
37226
  if (!argp2) {
 
37227
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_InsertItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37228
  }
 
37229
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37230
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37231
  if (!SWIG_IsOK(res3)) {
 
37232
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TreeCtrl_InsertItem" "', expected argument " "3"" of type '" "wxTreeItemId const &""'"); 
 
37233
  }
 
37234
  if (!argp3) {
 
37235
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_InsertItem" "', expected argument " "3"" of type '" "wxTreeItemId const &""'"); 
 
37236
  }
 
37237
  arg3 = reinterpret_cast< wxTreeItemId * >(argp3);
 
37238
  {
 
37239
    arg4 = wxString_in_helper(obj3);
 
37240
    if (arg4 == NULL) SWIG_fail;
 
37241
    temp4 = true;
 
37242
  }
 
37243
  if (obj4) {
 
37244
    ecode5 = SWIG_AsVal_int(obj4, &val5);
 
37245
    if (!SWIG_IsOK(ecode5)) {
 
37246
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TreeCtrl_InsertItem" "', expected argument " "5"" of type '" "int""'");
 
37247
    } 
 
37248
    arg5 = static_cast< int >(val5);
 
37249
  }
 
37250
  if (obj5) {
 
37251
    ecode6 = SWIG_AsVal_int(obj5, &val6);
 
37252
    if (!SWIG_IsOK(ecode6)) {
 
37253
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TreeCtrl_InsertItem" "', expected argument " "6"" of type '" "int""'");
 
37254
    } 
 
37255
    arg6 = static_cast< int >(val6);
 
37256
  }
 
37257
  if (obj6) {
 
37258
    res7 = SWIG_ConvertPtr(obj6, SWIG_as_voidptrptr(&arg7), SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_DISOWN |  0 );
 
37259
    if (!SWIG_IsOK(res7)) {
 
37260
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TreeCtrl_InsertItem" "', expected argument " "7"" of type '" "wxPyTreeItemData *""'");
 
37261
    }
 
37262
  }
 
37263
  {
 
37264
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37265
    result = (arg1)->InsertItem((wxTreeItemId const &)*arg2,(wxTreeItemId const &)*arg3,(wxString const &)*arg4,arg5,arg6,arg7);
 
37266
    wxPyEndAllowThreads(__tstate);
 
37267
    if (PyErr_Occurred()) SWIG_fail;
 
37268
  }
 
37269
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
37270
  {
 
37271
    if (temp4)
 
37272
    delete arg4;
 
37273
  }
 
37274
  return resultobj;
 
37275
fail:
 
37276
  {
 
37277
    if (temp4)
 
37278
    delete arg4;
 
37279
  }
 
37280
  return NULL;
 
37281
}
 
37282
 
 
37283
 
 
37284
SWIGINTERN PyObject *_wrap_TreeCtrl_InsertItemBefore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37285
  PyObject *resultobj = 0;
 
37286
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37287
  wxTreeItemId *arg2 = 0 ;
 
37288
  size_t arg3 ;
 
37289
  wxString *arg4 = 0 ;
 
37290
  int arg5 = (int) -1 ;
 
37291
  int arg6 = (int) -1 ;
 
37292
  wxPyTreeItemData *arg7 = (wxPyTreeItemData *) NULL ;
 
37293
  wxTreeItemId result;
 
37294
  void *argp1 = 0 ;
 
37295
  int res1 = 0 ;
 
37296
  void *argp2 = 0 ;
 
37297
  int res2 = 0 ;
 
37298
  size_t val3 ;
 
37299
  int ecode3 = 0 ;
 
37300
  bool temp4 = false ;
 
37301
  int val5 ;
 
37302
  int ecode5 = 0 ;
 
37303
  int val6 ;
 
37304
  int ecode6 = 0 ;
 
37305
  int res7 = 0 ;
 
37306
  PyObject * obj0 = 0 ;
 
37307
  PyObject * obj1 = 0 ;
 
37308
  PyObject * obj2 = 0 ;
 
37309
  PyObject * obj3 = 0 ;
 
37310
  PyObject * obj4 = 0 ;
 
37311
  PyObject * obj5 = 0 ;
 
37312
  PyObject * obj6 = 0 ;
 
37313
  char *  kwnames[] = {
 
37314
    (char *) "self",(char *) "parent",(char *) "index",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL 
 
37315
  };
 
37316
  
 
37317
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:TreeCtrl_InsertItemBefore",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
37318
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37319
  if (!SWIG_IsOK(res1)) {
 
37320
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_InsertItemBefore" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37321
  }
 
37322
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37323
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37324
  if (!SWIG_IsOK(res2)) {
 
37325
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_InsertItemBefore" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37326
  }
 
37327
  if (!argp2) {
 
37328
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_InsertItemBefore" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37329
  }
 
37330
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37331
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
 
37332
  if (!SWIG_IsOK(ecode3)) {
 
37333
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_InsertItemBefore" "', expected argument " "3"" of type '" "size_t""'");
 
37334
  } 
 
37335
  arg3 = static_cast< size_t >(val3);
 
37336
  {
 
37337
    arg4 = wxString_in_helper(obj3);
 
37338
    if (arg4 == NULL) SWIG_fail;
 
37339
    temp4 = true;
 
37340
  }
 
37341
  if (obj4) {
 
37342
    ecode5 = SWIG_AsVal_int(obj4, &val5);
 
37343
    if (!SWIG_IsOK(ecode5)) {
 
37344
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TreeCtrl_InsertItemBefore" "', expected argument " "5"" of type '" "int""'");
 
37345
    } 
 
37346
    arg5 = static_cast< int >(val5);
 
37347
  }
 
37348
  if (obj5) {
 
37349
    ecode6 = SWIG_AsVal_int(obj5, &val6);
 
37350
    if (!SWIG_IsOK(ecode6)) {
 
37351
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TreeCtrl_InsertItemBefore" "', expected argument " "6"" of type '" "int""'");
 
37352
    } 
 
37353
    arg6 = static_cast< int >(val6);
 
37354
  }
 
37355
  if (obj6) {
 
37356
    res7 = SWIG_ConvertPtr(obj6, SWIG_as_voidptrptr(&arg7), SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_DISOWN |  0 );
 
37357
    if (!SWIG_IsOK(res7)) {
 
37358
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TreeCtrl_InsertItemBefore" "', expected argument " "7"" of type '" "wxPyTreeItemData *""'");
 
37359
    }
 
37360
  }
 
37361
  {
 
37362
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37363
    result = (arg1)->InsertItem((wxTreeItemId const &)*arg2,arg3,(wxString const &)*arg4,arg5,arg6,arg7);
 
37364
    wxPyEndAllowThreads(__tstate);
 
37365
    if (PyErr_Occurred()) SWIG_fail;
 
37366
  }
 
37367
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
37368
  {
 
37369
    if (temp4)
 
37370
    delete arg4;
 
37371
  }
 
37372
  return resultobj;
 
37373
fail:
 
37374
  {
 
37375
    if (temp4)
 
37376
    delete arg4;
 
37377
  }
 
37378
  return NULL;
 
37379
}
 
37380
 
 
37381
 
 
37382
SWIGINTERN PyObject *_wrap_TreeCtrl_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37383
  PyObject *resultobj = 0;
 
37384
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37385
  wxTreeItemId *arg2 = 0 ;
 
37386
  wxString *arg3 = 0 ;
 
37387
  int arg4 = (int) -1 ;
 
37388
  int arg5 = (int) -1 ;
 
37389
  wxPyTreeItemData *arg6 = (wxPyTreeItemData *) NULL ;
 
37390
  wxTreeItemId result;
 
37391
  void *argp1 = 0 ;
 
37392
  int res1 = 0 ;
 
37393
  void *argp2 = 0 ;
 
37394
  int res2 = 0 ;
 
37395
  bool temp3 = false ;
 
37396
  int val4 ;
 
37397
  int ecode4 = 0 ;
 
37398
  int val5 ;
 
37399
  int ecode5 = 0 ;
 
37400
  int res6 = 0 ;
 
37401
  PyObject * obj0 = 0 ;
 
37402
  PyObject * obj1 = 0 ;
 
37403
  PyObject * obj2 = 0 ;
 
37404
  PyObject * obj3 = 0 ;
 
37405
  PyObject * obj4 = 0 ;
 
37406
  PyObject * obj5 = 0 ;
 
37407
  char *  kwnames[] = {
 
37408
    (char *) "self",(char *) "parent",(char *) "text",(char *) "image",(char *) "selectedImage",(char *) "data", NULL 
 
37409
  };
 
37410
  
 
37411
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:TreeCtrl_AppendItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
37412
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37413
  if (!SWIG_IsOK(res1)) {
 
37414
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_AppendItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37415
  }
 
37416
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37417
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37418
  if (!SWIG_IsOK(res2)) {
 
37419
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_AppendItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37420
  }
 
37421
  if (!argp2) {
 
37422
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_AppendItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37423
  }
 
37424
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37425
  {
 
37426
    arg3 = wxString_in_helper(obj2);
 
37427
    if (arg3 == NULL) SWIG_fail;
 
37428
    temp3 = true;
 
37429
  }
 
37430
  if (obj3) {
 
37431
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
37432
    if (!SWIG_IsOK(ecode4)) {
 
37433
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TreeCtrl_AppendItem" "', expected argument " "4"" of type '" "int""'");
 
37434
    } 
 
37435
    arg4 = static_cast< int >(val4);
 
37436
  }
 
37437
  if (obj4) {
 
37438
    ecode5 = SWIG_AsVal_int(obj4, &val5);
 
37439
    if (!SWIG_IsOK(ecode5)) {
 
37440
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TreeCtrl_AppendItem" "', expected argument " "5"" of type '" "int""'");
 
37441
    } 
 
37442
    arg5 = static_cast< int >(val5);
 
37443
  }
 
37444
  if (obj5) {
 
37445
    res6 = SWIG_ConvertPtr(obj5, SWIG_as_voidptrptr(&arg6), SWIGTYPE_p_wxPyTreeItemData, SWIG_POINTER_DISOWN |  0 );
 
37446
    if (!SWIG_IsOK(res6)) {
 
37447
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TreeCtrl_AppendItem" "', expected argument " "6"" of type '" "wxPyTreeItemData *""'");
 
37448
    }
 
37449
  }
 
37450
  {
 
37451
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37452
    result = (arg1)->AppendItem((wxTreeItemId const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6);
 
37453
    wxPyEndAllowThreads(__tstate);
 
37454
    if (PyErr_Occurred()) SWIG_fail;
 
37455
  }
 
37456
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
37457
  {
 
37458
    if (temp3)
 
37459
    delete arg3;
 
37460
  }
 
37461
  return resultobj;
 
37462
fail:
 
37463
  {
 
37464
    if (temp3)
 
37465
    delete arg3;
 
37466
  }
 
37467
  return NULL;
 
37468
}
 
37469
 
 
37470
 
 
37471
SWIGINTERN PyObject *_wrap_TreeCtrl_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37472
  PyObject *resultobj = 0;
 
37473
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37474
  wxTreeItemId *arg2 = 0 ;
 
37475
  void *argp1 = 0 ;
 
37476
  int res1 = 0 ;
 
37477
  void *argp2 = 0 ;
 
37478
  int res2 = 0 ;
 
37479
  PyObject * obj0 = 0 ;
 
37480
  PyObject * obj1 = 0 ;
 
37481
  char *  kwnames[] = {
 
37482
    (char *) "self",(char *) "item", NULL 
 
37483
  };
 
37484
  
 
37485
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
 
37486
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37487
  if (!SWIG_IsOK(res1)) {
 
37488
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_Delete" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37489
  }
 
37490
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37491
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37492
  if (!SWIG_IsOK(res2)) {
 
37493
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_Delete" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37494
  }
 
37495
  if (!argp2) {
 
37496
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_Delete" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37497
  }
 
37498
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37499
  {
 
37500
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37501
    (arg1)->Delete((wxTreeItemId const &)*arg2);
 
37502
    wxPyEndAllowThreads(__tstate);
 
37503
    if (PyErr_Occurred()) SWIG_fail;
 
37504
  }
 
37505
  resultobj = SWIG_Py_Void();
 
37506
  return resultobj;
 
37507
fail:
 
37508
  return NULL;
 
37509
}
 
37510
 
 
37511
 
 
37512
SWIGINTERN PyObject *_wrap_TreeCtrl_DeleteChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37513
  PyObject *resultobj = 0;
 
37514
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37515
  wxTreeItemId *arg2 = 0 ;
 
37516
  void *argp1 = 0 ;
 
37517
  int res1 = 0 ;
 
37518
  void *argp2 = 0 ;
 
37519
  int res2 = 0 ;
 
37520
  PyObject * obj0 = 0 ;
 
37521
  PyObject * obj1 = 0 ;
 
37522
  char *  kwnames[] = {
 
37523
    (char *) "self",(char *) "item", NULL 
 
37524
  };
 
37525
  
 
37526
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_DeleteChildren",kwnames,&obj0,&obj1)) SWIG_fail;
 
37527
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37528
  if (!SWIG_IsOK(res1)) {
 
37529
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_DeleteChildren" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37530
  }
 
37531
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37532
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37533
  if (!SWIG_IsOK(res2)) {
 
37534
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_DeleteChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37535
  }
 
37536
  if (!argp2) {
 
37537
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_DeleteChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37538
  }
 
37539
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37540
  {
 
37541
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37542
    (arg1)->DeleteChildren((wxTreeItemId const &)*arg2);
 
37543
    wxPyEndAllowThreads(__tstate);
 
37544
    if (PyErr_Occurred()) SWIG_fail;
 
37545
  }
 
37546
  resultobj = SWIG_Py_Void();
 
37547
  return resultobj;
 
37548
fail:
 
37549
  return NULL;
 
37550
}
 
37551
 
 
37552
 
 
37553
SWIGINTERN PyObject *_wrap_TreeCtrl_DeleteAllItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
37554
  PyObject *resultobj = 0;
 
37555
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37556
  void *argp1 = 0 ;
 
37557
  int res1 = 0 ;
 
37558
  PyObject *swig_obj[1] ;
 
37559
  
 
37560
  if (!args) SWIG_fail;
 
37561
  swig_obj[0] = args;
 
37562
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37563
  if (!SWIG_IsOK(res1)) {
 
37564
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_DeleteAllItems" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37565
  }
 
37566
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37567
  {
 
37568
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37569
    (arg1)->DeleteAllItems();
 
37570
    wxPyEndAllowThreads(__tstate);
 
37571
    if (PyErr_Occurred()) SWIG_fail;
 
37572
  }
 
37573
  resultobj = SWIG_Py_Void();
 
37574
  return resultobj;
 
37575
fail:
 
37576
  return NULL;
 
37577
}
 
37578
 
 
37579
 
 
37580
SWIGINTERN PyObject *_wrap_TreeCtrl_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37581
  PyObject *resultobj = 0;
 
37582
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37583
  wxTreeItemId *arg2 = 0 ;
 
37584
  void *argp1 = 0 ;
 
37585
  int res1 = 0 ;
 
37586
  void *argp2 = 0 ;
 
37587
  int res2 = 0 ;
 
37588
  PyObject * obj0 = 0 ;
 
37589
  PyObject * obj1 = 0 ;
 
37590
  char *  kwnames[] = {
 
37591
    (char *) "self",(char *) "item", NULL 
 
37592
  };
 
37593
  
 
37594
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Expand",kwnames,&obj0,&obj1)) SWIG_fail;
 
37595
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37596
  if (!SWIG_IsOK(res1)) {
 
37597
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_Expand" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37598
  }
 
37599
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37600
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37601
  if (!SWIG_IsOK(res2)) {
 
37602
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_Expand" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37603
  }
 
37604
  if (!argp2) {
 
37605
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_Expand" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37606
  }
 
37607
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37608
  {
 
37609
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37610
    (arg1)->Expand((wxTreeItemId const &)*arg2);
 
37611
    wxPyEndAllowThreads(__tstate);
 
37612
    if (PyErr_Occurred()) SWIG_fail;
 
37613
  }
 
37614
  resultobj = SWIG_Py_Void();
 
37615
  return resultobj;
 
37616
fail:
 
37617
  return NULL;
 
37618
}
 
37619
 
 
37620
 
 
37621
SWIGINTERN PyObject *_wrap_TreeCtrl_ExpandAllChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37622
  PyObject *resultobj = 0;
 
37623
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37624
  wxTreeItemId *arg2 = 0 ;
 
37625
  void *argp1 = 0 ;
 
37626
  int res1 = 0 ;
 
37627
  void *argp2 = 0 ;
 
37628
  int res2 = 0 ;
 
37629
  PyObject * obj0 = 0 ;
 
37630
  PyObject * obj1 = 0 ;
 
37631
  char *  kwnames[] = {
 
37632
    (char *) "self",(char *) "item", NULL 
 
37633
  };
 
37634
  
 
37635
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_ExpandAllChildren",kwnames,&obj0,&obj1)) SWIG_fail;
 
37636
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37637
  if (!SWIG_IsOK(res1)) {
 
37638
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_ExpandAllChildren" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37639
  }
 
37640
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37641
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37642
  if (!SWIG_IsOK(res2)) {
 
37643
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_ExpandAllChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37644
  }
 
37645
  if (!argp2) {
 
37646
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_ExpandAllChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37647
  }
 
37648
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37649
  {
 
37650
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37651
    (arg1)->ExpandAllChildren((wxTreeItemId const &)*arg2);
 
37652
    wxPyEndAllowThreads(__tstate);
 
37653
    if (PyErr_Occurred()) SWIG_fail;
 
37654
  }
 
37655
  resultobj = SWIG_Py_Void();
 
37656
  return resultobj;
 
37657
fail:
 
37658
  return NULL;
 
37659
}
 
37660
 
 
37661
 
 
37662
SWIGINTERN PyObject *_wrap_TreeCtrl_ExpandAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
37663
  PyObject *resultobj = 0;
 
37664
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37665
  void *argp1 = 0 ;
 
37666
  int res1 = 0 ;
 
37667
  PyObject *swig_obj[1] ;
 
37668
  
 
37669
  if (!args) SWIG_fail;
 
37670
  swig_obj[0] = args;
 
37671
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37672
  if (!SWIG_IsOK(res1)) {
 
37673
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_ExpandAll" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37674
  }
 
37675
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37676
  {
 
37677
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37678
    (arg1)->ExpandAll();
 
37679
    wxPyEndAllowThreads(__tstate);
 
37680
    if (PyErr_Occurred()) SWIG_fail;
 
37681
  }
 
37682
  resultobj = SWIG_Py_Void();
 
37683
  return resultobj;
 
37684
fail:
 
37685
  return NULL;
 
37686
}
 
37687
 
 
37688
 
 
37689
SWIGINTERN PyObject *_wrap_TreeCtrl_Collapse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37690
  PyObject *resultobj = 0;
 
37691
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37692
  wxTreeItemId *arg2 = 0 ;
 
37693
  void *argp1 = 0 ;
 
37694
  int res1 = 0 ;
 
37695
  void *argp2 = 0 ;
 
37696
  int res2 = 0 ;
 
37697
  PyObject * obj0 = 0 ;
 
37698
  PyObject * obj1 = 0 ;
 
37699
  char *  kwnames[] = {
 
37700
    (char *) "self",(char *) "item", NULL 
 
37701
  };
 
37702
  
 
37703
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Collapse",kwnames,&obj0,&obj1)) SWIG_fail;
 
37704
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37705
  if (!SWIG_IsOK(res1)) {
 
37706
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_Collapse" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37707
  }
 
37708
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37709
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37710
  if (!SWIG_IsOK(res2)) {
 
37711
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_Collapse" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37712
  }
 
37713
  if (!argp2) {
 
37714
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_Collapse" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37715
  }
 
37716
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37717
  {
 
37718
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37719
    (arg1)->Collapse((wxTreeItemId const &)*arg2);
 
37720
    wxPyEndAllowThreads(__tstate);
 
37721
    if (PyErr_Occurred()) SWIG_fail;
 
37722
  }
 
37723
  resultobj = SWIG_Py_Void();
 
37724
  return resultobj;
 
37725
fail:
 
37726
  return NULL;
 
37727
}
 
37728
 
 
37729
 
 
37730
SWIGINTERN PyObject *_wrap_TreeCtrl_CollapseAllChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37731
  PyObject *resultobj = 0;
 
37732
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37733
  wxTreeItemId *arg2 = 0 ;
 
37734
  void *argp1 = 0 ;
 
37735
  int res1 = 0 ;
 
37736
  void *argp2 = 0 ;
 
37737
  int res2 = 0 ;
 
37738
  PyObject * obj0 = 0 ;
 
37739
  PyObject * obj1 = 0 ;
 
37740
  char *  kwnames[] = {
 
37741
    (char *) "self",(char *) "item", NULL 
 
37742
  };
 
37743
  
 
37744
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_CollapseAllChildren",kwnames,&obj0,&obj1)) SWIG_fail;
 
37745
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37746
  if (!SWIG_IsOK(res1)) {
 
37747
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_CollapseAllChildren" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37748
  }
 
37749
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37750
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37751
  if (!SWIG_IsOK(res2)) {
 
37752
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_CollapseAllChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37753
  }
 
37754
  if (!argp2) {
 
37755
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_CollapseAllChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37756
  }
 
37757
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37758
  {
 
37759
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37760
    (arg1)->CollapseAllChildren((wxTreeItemId const &)*arg2);
 
37761
    wxPyEndAllowThreads(__tstate);
 
37762
    if (PyErr_Occurred()) SWIG_fail;
 
37763
  }
 
37764
  resultobj = SWIG_Py_Void();
 
37765
  return resultobj;
 
37766
fail:
 
37767
  return NULL;
 
37768
}
 
37769
 
 
37770
 
 
37771
SWIGINTERN PyObject *_wrap_TreeCtrl_CollapseAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
37772
  PyObject *resultobj = 0;
 
37773
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37774
  void *argp1 = 0 ;
 
37775
  int res1 = 0 ;
 
37776
  PyObject *swig_obj[1] ;
 
37777
  
 
37778
  if (!args) SWIG_fail;
 
37779
  swig_obj[0] = args;
 
37780
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37781
  if (!SWIG_IsOK(res1)) {
 
37782
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_CollapseAll" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37783
  }
 
37784
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37785
  {
 
37786
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37787
    (arg1)->CollapseAll();
 
37788
    wxPyEndAllowThreads(__tstate);
 
37789
    if (PyErr_Occurred()) SWIG_fail;
 
37790
  }
 
37791
  resultobj = SWIG_Py_Void();
 
37792
  return resultobj;
 
37793
fail:
 
37794
  return NULL;
 
37795
}
 
37796
 
 
37797
 
 
37798
SWIGINTERN PyObject *_wrap_TreeCtrl_CollapseAndReset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37799
  PyObject *resultobj = 0;
 
37800
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37801
  wxTreeItemId *arg2 = 0 ;
 
37802
  void *argp1 = 0 ;
 
37803
  int res1 = 0 ;
 
37804
  void *argp2 = 0 ;
 
37805
  int res2 = 0 ;
 
37806
  PyObject * obj0 = 0 ;
 
37807
  PyObject * obj1 = 0 ;
 
37808
  char *  kwnames[] = {
 
37809
    (char *) "self",(char *) "item", NULL 
 
37810
  };
 
37811
  
 
37812
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_CollapseAndReset",kwnames,&obj0,&obj1)) SWIG_fail;
 
37813
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37814
  if (!SWIG_IsOK(res1)) {
 
37815
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_CollapseAndReset" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37816
  }
 
37817
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37818
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37819
  if (!SWIG_IsOK(res2)) {
 
37820
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_CollapseAndReset" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37821
  }
 
37822
  if (!argp2) {
 
37823
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_CollapseAndReset" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37824
  }
 
37825
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37826
  {
 
37827
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37828
    (arg1)->CollapseAndReset((wxTreeItemId const &)*arg2);
 
37829
    wxPyEndAllowThreads(__tstate);
 
37830
    if (PyErr_Occurred()) SWIG_fail;
 
37831
  }
 
37832
  resultobj = SWIG_Py_Void();
 
37833
  return resultobj;
 
37834
fail:
 
37835
  return NULL;
 
37836
}
 
37837
 
 
37838
 
 
37839
SWIGINTERN PyObject *_wrap_TreeCtrl_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37840
  PyObject *resultobj = 0;
 
37841
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37842
  wxTreeItemId *arg2 = 0 ;
 
37843
  void *argp1 = 0 ;
 
37844
  int res1 = 0 ;
 
37845
  void *argp2 = 0 ;
 
37846
  int res2 = 0 ;
 
37847
  PyObject * obj0 = 0 ;
 
37848
  PyObject * obj1 = 0 ;
 
37849
  char *  kwnames[] = {
 
37850
    (char *) "self",(char *) "item", NULL 
 
37851
  };
 
37852
  
 
37853
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_Toggle",kwnames,&obj0,&obj1)) SWIG_fail;
 
37854
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37855
  if (!SWIG_IsOK(res1)) {
 
37856
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_Toggle" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37857
  }
 
37858
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37859
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37860
  if (!SWIG_IsOK(res2)) {
 
37861
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_Toggle" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37862
  }
 
37863
  if (!argp2) {
 
37864
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_Toggle" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37865
  }
 
37866
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37867
  {
 
37868
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37869
    (arg1)->Toggle((wxTreeItemId const &)*arg2);
 
37870
    wxPyEndAllowThreads(__tstate);
 
37871
    if (PyErr_Occurred()) SWIG_fail;
 
37872
  }
 
37873
  resultobj = SWIG_Py_Void();
 
37874
  return resultobj;
 
37875
fail:
 
37876
  return NULL;
 
37877
}
 
37878
 
 
37879
 
 
37880
SWIGINTERN PyObject *_wrap_TreeCtrl_Unselect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
37881
  PyObject *resultobj = 0;
 
37882
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37883
  void *argp1 = 0 ;
 
37884
  int res1 = 0 ;
 
37885
  PyObject *swig_obj[1] ;
 
37886
  
 
37887
  if (!args) SWIG_fail;
 
37888
  swig_obj[0] = args;
 
37889
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37890
  if (!SWIG_IsOK(res1)) {
 
37891
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_Unselect" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37892
  }
 
37893
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37894
  {
 
37895
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37896
    (arg1)->Unselect();
 
37897
    wxPyEndAllowThreads(__tstate);
 
37898
    if (PyErr_Occurred()) SWIG_fail;
 
37899
  }
 
37900
  resultobj = SWIG_Py_Void();
 
37901
  return resultobj;
 
37902
fail:
 
37903
  return NULL;
 
37904
}
 
37905
 
 
37906
 
 
37907
SWIGINTERN PyObject *_wrap_TreeCtrl_UnselectItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37908
  PyObject *resultobj = 0;
 
37909
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37910
  wxTreeItemId *arg2 = 0 ;
 
37911
  void *argp1 = 0 ;
 
37912
  int res1 = 0 ;
 
37913
  void *argp2 = 0 ;
 
37914
  int res2 = 0 ;
 
37915
  PyObject * obj0 = 0 ;
 
37916
  PyObject * obj1 = 0 ;
 
37917
  char *  kwnames[] = {
 
37918
    (char *) "self",(char *) "item", NULL 
 
37919
  };
 
37920
  
 
37921
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_UnselectItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
37922
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37923
  if (!SWIG_IsOK(res1)) {
 
37924
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_UnselectItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37925
  }
 
37926
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37927
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
37928
  if (!SWIG_IsOK(res2)) {
 
37929
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_UnselectItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37930
  }
 
37931
  if (!argp2) {
 
37932
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_UnselectItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
37933
  }
 
37934
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
37935
  {
 
37936
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37937
    (arg1)->UnselectItem((wxTreeItemId const &)*arg2);
 
37938
    wxPyEndAllowThreads(__tstate);
 
37939
    if (PyErr_Occurred()) SWIG_fail;
 
37940
  }
 
37941
  resultobj = SWIG_Py_Void();
 
37942
  return resultobj;
 
37943
fail:
 
37944
  return NULL;
 
37945
}
 
37946
 
 
37947
 
 
37948
SWIGINTERN PyObject *_wrap_TreeCtrl_UnselectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
37949
  PyObject *resultobj = 0;
 
37950
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37951
  void *argp1 = 0 ;
 
37952
  int res1 = 0 ;
 
37953
  PyObject *swig_obj[1] ;
 
37954
  
 
37955
  if (!args) SWIG_fail;
 
37956
  swig_obj[0] = args;
 
37957
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37958
  if (!SWIG_IsOK(res1)) {
 
37959
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_UnselectAll" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37960
  }
 
37961
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37962
  {
 
37963
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
37964
    (arg1)->UnselectAll();
 
37965
    wxPyEndAllowThreads(__tstate);
 
37966
    if (PyErr_Occurred()) SWIG_fail;
 
37967
  }
 
37968
  resultobj = SWIG_Py_Void();
 
37969
  return resultobj;
 
37970
fail:
 
37971
  return NULL;
 
37972
}
 
37973
 
 
37974
 
 
37975
SWIGINTERN PyObject *_wrap_TreeCtrl_SelectItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
37976
  PyObject *resultobj = 0;
 
37977
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
37978
  wxTreeItemId *arg2 = 0 ;
 
37979
  bool arg3 = (bool) true ;
 
37980
  void *argp1 = 0 ;
 
37981
  int res1 = 0 ;
 
37982
  void *argp2 = 0 ;
 
37983
  int res2 = 0 ;
 
37984
  bool val3 ;
 
37985
  int ecode3 = 0 ;
 
37986
  PyObject * obj0 = 0 ;
 
37987
  PyObject * obj1 = 0 ;
 
37988
  PyObject * obj2 = 0 ;
 
37989
  char *  kwnames[] = {
 
37990
    (char *) "self",(char *) "item",(char *) "select", NULL 
 
37991
  };
 
37992
  
 
37993
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_SelectItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
37994
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
37995
  if (!SWIG_IsOK(res1)) {
 
37996
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SelectItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
37997
  }
 
37998
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
37999
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
38000
  if (!SWIG_IsOK(res2)) {
 
38001
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SelectItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38002
  }
 
38003
  if (!argp2) {
 
38004
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SelectItem" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38005
  }
 
38006
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
38007
  if (obj2) {
 
38008
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
38009
    if (!SWIG_IsOK(ecode3)) {
 
38010
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_SelectItem" "', expected argument " "3"" of type '" "bool""'");
 
38011
    } 
 
38012
    arg3 = static_cast< bool >(val3);
 
38013
  }
 
38014
  {
 
38015
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38016
    (arg1)->SelectItem((wxTreeItemId const &)*arg2,arg3);
 
38017
    wxPyEndAllowThreads(__tstate);
 
38018
    if (PyErr_Occurred()) SWIG_fail;
 
38019
  }
 
38020
  resultobj = SWIG_Py_Void();
 
38021
  return resultobj;
 
38022
fail:
 
38023
  return NULL;
 
38024
}
 
38025
 
 
38026
 
 
38027
SWIGINTERN PyObject *_wrap_TreeCtrl_SelectChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38028
  PyObject *resultobj = 0;
 
38029
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38030
  wxTreeItemId *arg2 = 0 ;
 
38031
  void *argp1 = 0 ;
 
38032
  int res1 = 0 ;
 
38033
  void *argp2 = 0 ;
 
38034
  int res2 = 0 ;
 
38035
  PyObject * obj0 = 0 ;
 
38036
  PyObject * obj1 = 0 ;
 
38037
  char *  kwnames[] = {
 
38038
    (char *) "self",(char *) "parent", NULL 
 
38039
  };
 
38040
  
 
38041
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SelectChildren",kwnames,&obj0,&obj1)) SWIG_fail;
 
38042
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38043
  if (!SWIG_IsOK(res1)) {
 
38044
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SelectChildren" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
38045
  }
 
38046
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38047
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
38048
  if (!SWIG_IsOK(res2)) {
 
38049
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SelectChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38050
  }
 
38051
  if (!argp2) {
 
38052
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SelectChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38053
  }
 
38054
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
38055
  {
 
38056
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38057
    (arg1)->SelectChildren((wxTreeItemId const &)*arg2);
 
38058
    wxPyEndAllowThreads(__tstate);
 
38059
    if (PyErr_Occurred()) SWIG_fail;
 
38060
  }
 
38061
  resultobj = SWIG_Py_Void();
 
38062
  return resultobj;
 
38063
fail:
 
38064
  return NULL;
 
38065
}
 
38066
 
 
38067
 
 
38068
SWIGINTERN PyObject *_wrap_TreeCtrl_ToggleItemSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38069
  PyObject *resultobj = 0;
 
38070
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38071
  wxTreeItemId *arg2 = 0 ;
 
38072
  void *argp1 = 0 ;
 
38073
  int res1 = 0 ;
 
38074
  void *argp2 = 0 ;
 
38075
  int res2 = 0 ;
 
38076
  PyObject * obj0 = 0 ;
 
38077
  PyObject * obj1 = 0 ;
 
38078
  char *  kwnames[] = {
 
38079
    (char *) "self",(char *) "item", NULL 
 
38080
  };
 
38081
  
 
38082
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_ToggleItemSelection",kwnames,&obj0,&obj1)) SWIG_fail;
 
38083
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38084
  if (!SWIG_IsOK(res1)) {
 
38085
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_ToggleItemSelection" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
38086
  }
 
38087
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38088
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
38089
  if (!SWIG_IsOK(res2)) {
 
38090
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_ToggleItemSelection" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38091
  }
 
38092
  if (!argp2) {
 
38093
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_ToggleItemSelection" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38094
  }
 
38095
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
38096
  {
 
38097
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38098
    (arg1)->ToggleItemSelection((wxTreeItemId const &)*arg2);
 
38099
    wxPyEndAllowThreads(__tstate);
 
38100
    if (PyErr_Occurred()) SWIG_fail;
 
38101
  }
 
38102
  resultobj = SWIG_Py_Void();
 
38103
  return resultobj;
 
38104
fail:
 
38105
  return NULL;
 
38106
}
 
38107
 
 
38108
 
 
38109
SWIGINTERN PyObject *_wrap_TreeCtrl_EnsureVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38110
  PyObject *resultobj = 0;
 
38111
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38112
  wxTreeItemId *arg2 = 0 ;
 
38113
  void *argp1 = 0 ;
 
38114
  int res1 = 0 ;
 
38115
  void *argp2 = 0 ;
 
38116
  int res2 = 0 ;
 
38117
  PyObject * obj0 = 0 ;
 
38118
  PyObject * obj1 = 0 ;
 
38119
  char *  kwnames[] = {
 
38120
    (char *) "self",(char *) "item", NULL 
 
38121
  };
 
38122
  
 
38123
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_EnsureVisible",kwnames,&obj0,&obj1)) SWIG_fail;
 
38124
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38125
  if (!SWIG_IsOK(res1)) {
 
38126
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_EnsureVisible" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
38127
  }
 
38128
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38129
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
38130
  if (!SWIG_IsOK(res2)) {
 
38131
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_EnsureVisible" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38132
  }
 
38133
  if (!argp2) {
 
38134
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_EnsureVisible" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38135
  }
 
38136
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
38137
  {
 
38138
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38139
    (arg1)->EnsureVisible((wxTreeItemId const &)*arg2);
 
38140
    wxPyEndAllowThreads(__tstate);
 
38141
    if (PyErr_Occurred()) SWIG_fail;
 
38142
  }
 
38143
  resultobj = SWIG_Py_Void();
 
38144
  return resultobj;
 
38145
fail:
 
38146
  return NULL;
 
38147
}
 
38148
 
 
38149
 
 
38150
SWIGINTERN PyObject *_wrap_TreeCtrl_ScrollTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38151
  PyObject *resultobj = 0;
 
38152
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38153
  wxTreeItemId *arg2 = 0 ;
 
38154
  void *argp1 = 0 ;
 
38155
  int res1 = 0 ;
 
38156
  void *argp2 = 0 ;
 
38157
  int res2 = 0 ;
 
38158
  PyObject * obj0 = 0 ;
 
38159
  PyObject * obj1 = 0 ;
 
38160
  char *  kwnames[] = {
 
38161
    (char *) "self",(char *) "item", NULL 
 
38162
  };
 
38163
  
 
38164
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_ScrollTo",kwnames,&obj0,&obj1)) SWIG_fail;
 
38165
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38166
  if (!SWIG_IsOK(res1)) {
 
38167
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_ScrollTo" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
38168
  }
 
38169
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38170
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
38171
  if (!SWIG_IsOK(res2)) {
 
38172
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_ScrollTo" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38173
  }
 
38174
  if (!argp2) {
 
38175
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_ScrollTo" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38176
  }
 
38177
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
38178
  {
 
38179
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38180
    (arg1)->ScrollTo((wxTreeItemId const &)*arg2);
 
38181
    wxPyEndAllowThreads(__tstate);
 
38182
    if (PyErr_Occurred()) SWIG_fail;
 
38183
  }
 
38184
  resultobj = SWIG_Py_Void();
 
38185
  return resultobj;
 
38186
fail:
 
38187
  return NULL;
 
38188
}
 
38189
 
 
38190
 
 
38191
SWIGINTERN PyObject *_wrap_TreeCtrl_EditLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38192
  PyObject *resultobj = 0;
 
38193
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38194
  wxTreeItemId *arg2 = 0 ;
 
38195
  void *argp1 = 0 ;
 
38196
  int res1 = 0 ;
 
38197
  void *argp2 = 0 ;
 
38198
  int res2 = 0 ;
 
38199
  PyObject * obj0 = 0 ;
 
38200
  PyObject * obj1 = 0 ;
 
38201
  char *  kwnames[] = {
 
38202
    (char *) "self",(char *) "item", NULL 
 
38203
  };
 
38204
  
 
38205
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_EditLabel",kwnames,&obj0,&obj1)) SWIG_fail;
 
38206
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38207
  if (!SWIG_IsOK(res1)) {
 
38208
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_EditLabel" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
38209
  }
 
38210
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38211
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
38212
  if (!SWIG_IsOK(res2)) {
 
38213
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_EditLabel" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38214
  }
 
38215
  if (!argp2) {
 
38216
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_EditLabel" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38217
  }
 
38218
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
38219
  {
 
38220
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38221
    (arg1)->EditLabel((wxTreeItemId const &)*arg2);
 
38222
    wxPyEndAllowThreads(__tstate);
 
38223
    if (PyErr_Occurred()) SWIG_fail;
 
38224
  }
 
38225
  resultobj = SWIG_Py_Void();
 
38226
  return resultobj;
 
38227
fail:
 
38228
  return NULL;
 
38229
}
 
38230
 
 
38231
 
 
38232
SWIGINTERN PyObject *_wrap_TreeCtrl_GetEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38233
  PyObject *resultobj = 0;
 
38234
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38235
  wxTextCtrl *result = 0 ;
 
38236
  void *argp1 = 0 ;
 
38237
  int res1 = 0 ;
 
38238
  PyObject *swig_obj[1] ;
 
38239
  
 
38240
  if (!args) SWIG_fail;
 
38241
  swig_obj[0] = args;
 
38242
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38243
  if (!SWIG_IsOK(res1)) {
 
38244
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetEditControl" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
38245
  }
 
38246
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38247
  {
 
38248
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38249
    result = (wxTextCtrl *)((wxPyTreeCtrl const *)arg1)->GetEditControl();
 
38250
    wxPyEndAllowThreads(__tstate);
 
38251
    if (PyErr_Occurred()) SWIG_fail;
 
38252
  }
 
38253
  {
 
38254
    resultobj = wxPyMake_wxObject(result, 0); 
 
38255
  }
 
38256
  return resultobj;
 
38257
fail:
 
38258
  return NULL;
 
38259
}
 
38260
 
 
38261
 
 
38262
SWIGINTERN PyObject *_wrap_TreeCtrl_SortChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38263
  PyObject *resultobj = 0;
 
38264
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38265
  wxTreeItemId *arg2 = 0 ;
 
38266
  void *argp1 = 0 ;
 
38267
  int res1 = 0 ;
 
38268
  void *argp2 = 0 ;
 
38269
  int res2 = 0 ;
 
38270
  PyObject * obj0 = 0 ;
 
38271
  PyObject * obj1 = 0 ;
 
38272
  char *  kwnames[] = {
 
38273
    (char *) "self",(char *) "item", NULL 
 
38274
  };
 
38275
  
 
38276
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SortChildren",kwnames,&obj0,&obj1)) SWIG_fail;
 
38277
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38278
  if (!SWIG_IsOK(res1)) {
 
38279
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SortChildren" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
38280
  }
 
38281
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38282
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
38283
  if (!SWIG_IsOK(res2)) {
 
38284
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_SortChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38285
  }
 
38286
  if (!argp2) {
 
38287
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_SortChildren" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38288
  }
 
38289
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
38290
  {
 
38291
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38292
    (arg1)->SortChildren((wxTreeItemId const &)*arg2);
 
38293
    wxPyEndAllowThreads(__tstate);
 
38294
    if (PyErr_Occurred()) SWIG_fail;
 
38295
  }
 
38296
  resultobj = SWIG_Py_Void();
 
38297
  return resultobj;
 
38298
fail:
 
38299
  return NULL;
 
38300
}
 
38301
 
 
38302
 
 
38303
SWIGINTERN PyObject *_wrap_TreeCtrl_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38304
  PyObject *resultobj = 0;
 
38305
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38306
  wxPoint *arg2 = 0 ;
 
38307
  int *arg3 = 0 ;
 
38308
  wxTreeItemId result;
 
38309
  void *argp1 = 0 ;
 
38310
  int res1 = 0 ;
 
38311
  wxPoint temp2 ;
 
38312
  int temp3 ;
 
38313
  int res3 = SWIG_TMPOBJ ;
 
38314
  PyObject * obj0 = 0 ;
 
38315
  PyObject * obj1 = 0 ;
 
38316
  char *  kwnames[] = {
 
38317
    (char *) "self",(char *) "point", NULL 
 
38318
  };
 
38319
  
 
38320
  arg3 = &temp3;
 
38321
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
 
38322
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38323
  if (!SWIG_IsOK(res1)) {
 
38324
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_HitTest" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
38325
  }
 
38326
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38327
  {
 
38328
    arg2 = &temp2;
 
38329
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
38330
  }
 
38331
  {
 
38332
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38333
    result = (arg1)->HitTest((wxPoint const &)*arg2,*arg3);
 
38334
    wxPyEndAllowThreads(__tstate);
 
38335
    if (PyErr_Occurred()) SWIG_fail;
 
38336
  }
 
38337
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
38338
  if (SWIG_IsTmpObj(res3)) {
 
38339
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
 
38340
  } else {
 
38341
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
38342
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
 
38343
  }
 
38344
  return resultobj;
 
38345
fail:
 
38346
  return NULL;
 
38347
}
 
38348
 
 
38349
 
 
38350
SWIGINTERN PyObject *_wrap_TreeCtrl_GetBoundingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38351
  PyObject *resultobj = 0;
 
38352
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38353
  wxTreeItemId *arg2 = 0 ;
 
38354
  bool arg3 = (bool) false ;
 
38355
  PyObject *result = 0 ;
 
38356
  void *argp1 = 0 ;
 
38357
  int res1 = 0 ;
 
38358
  void *argp2 = 0 ;
 
38359
  int res2 = 0 ;
 
38360
  bool val3 ;
 
38361
  int ecode3 = 0 ;
 
38362
  PyObject * obj0 = 0 ;
 
38363
  PyObject * obj1 = 0 ;
 
38364
  PyObject * obj2 = 0 ;
 
38365
  char *  kwnames[] = {
 
38366
    (char *) "self",(char *) "item",(char *) "textOnly", NULL 
 
38367
  };
 
38368
  
 
38369
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TreeCtrl_GetBoundingRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
38370
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38371
  if (!SWIG_IsOK(res1)) {
 
38372
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetBoundingRect" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
38373
  }
 
38374
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38375
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
38376
  if (!SWIG_IsOK(res2)) {
 
38377
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeCtrl_GetBoundingRect" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38378
  }
 
38379
  if (!argp2) {
 
38380
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TreeCtrl_GetBoundingRect" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
38381
  }
 
38382
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
38383
  if (obj2) {
 
38384
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
38385
    if (!SWIG_IsOK(ecode3)) {
 
38386
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TreeCtrl_GetBoundingRect" "', expected argument " "3"" of type '" "bool""'");
 
38387
    } 
 
38388
    arg3 = static_cast< bool >(val3);
 
38389
  }
 
38390
  {
 
38391
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38392
    result = (PyObject *)wxPyTreeCtrl_GetBoundingRect(arg1,(wxTreeItemId const &)*arg2,arg3);
 
38393
    wxPyEndAllowThreads(__tstate);
 
38394
    if (PyErr_Occurred()) SWIG_fail;
 
38395
  }
 
38396
  resultobj = result;
 
38397
  return resultobj;
 
38398
fail:
 
38399
  return NULL;
 
38400
}
 
38401
 
 
38402
 
 
38403
SWIGINTERN PyObject *_wrap_TreeCtrl_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38404
  PyObject *resultobj = 0;
 
38405
  wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
 
38406
  SwigValueWrapper<wxVisualAttributes > result;
 
38407
  int val1 ;
 
38408
  int ecode1 = 0 ;
 
38409
  PyObject * obj0 = 0 ;
 
38410
  char *  kwnames[] = {
 
38411
    (char *) "variant", NULL 
 
38412
  };
 
38413
  
 
38414
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:TreeCtrl_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
 
38415
  if (obj0) {
 
38416
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
38417
    if (!SWIG_IsOK(ecode1)) {
 
38418
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TreeCtrl_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
 
38419
    } 
 
38420
    arg1 = static_cast< wxWindowVariant >(val1);
 
38421
  }
 
38422
  {
 
38423
    if (!wxPyCheckForApp()) SWIG_fail;
 
38424
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38425
    result = wxPyTreeCtrl::GetClassDefaultAttributes(arg1);
 
38426
    wxPyEndAllowThreads(__tstate);
 
38427
    if (PyErr_Occurred()) SWIG_fail;
 
38428
  }
 
38429
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
38430
  return resultobj;
 
38431
fail:
 
38432
  return NULL;
 
38433
}
 
38434
 
 
38435
 
 
38436
SWIGINTERN PyObject *_wrap_TreeCtrl_SetQuickBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38437
  PyObject *resultobj = 0;
 
38438
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38439
  bool arg2 ;
 
38440
  void *argp1 = 0 ;
 
38441
  int res1 = 0 ;
 
38442
  bool val2 ;
 
38443
  int ecode2 = 0 ;
 
38444
  PyObject * obj0 = 0 ;
 
38445
  PyObject * obj1 = 0 ;
 
38446
  char *  kwnames[] = {
 
38447
    (char *) "self",(char *) "q", NULL 
 
38448
  };
 
38449
  
 
38450
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TreeCtrl_SetQuickBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
 
38451
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38452
  if (!SWIG_IsOK(res1)) {
 
38453
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_SetQuickBestSize" "', expected argument " "1"" of type '" "wxPyTreeCtrl *""'"); 
 
38454
  }
 
38455
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38456
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
38457
  if (!SWIG_IsOK(ecode2)) {
 
38458
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeCtrl_SetQuickBestSize" "', expected argument " "2"" of type '" "bool""'");
 
38459
  } 
 
38460
  arg2 = static_cast< bool >(val2);
 
38461
  {
 
38462
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38463
    (arg1)->SetQuickBestSize(arg2);
 
38464
    wxPyEndAllowThreads(__tstate);
 
38465
    if (PyErr_Occurred()) SWIG_fail;
 
38466
  }
 
38467
  resultobj = SWIG_Py_Void();
 
38468
  return resultobj;
 
38469
fail:
 
38470
  return NULL;
 
38471
}
 
38472
 
 
38473
 
 
38474
SWIGINTERN PyObject *_wrap_TreeCtrl_GetQuickBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38475
  PyObject *resultobj = 0;
 
38476
  wxPyTreeCtrl *arg1 = (wxPyTreeCtrl *) 0 ;
 
38477
  bool result;
 
38478
  void *argp1 = 0 ;
 
38479
  int res1 = 0 ;
 
38480
  PyObject *swig_obj[1] ;
 
38481
  
 
38482
  if (!args) SWIG_fail;
 
38483
  swig_obj[0] = args;
 
38484
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTreeCtrl, 0 |  0 );
 
38485
  if (!SWIG_IsOK(res1)) {
 
38486
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeCtrl_GetQuickBestSize" "', expected argument " "1"" of type '" "wxPyTreeCtrl const *""'"); 
 
38487
  }
 
38488
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
38489
  {
 
38490
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38491
    result = (bool)((wxPyTreeCtrl const *)arg1)->GetQuickBestSize();
 
38492
    wxPyEndAllowThreads(__tstate);
 
38493
    if (PyErr_Occurred()) SWIG_fail;
 
38494
  }
 
38495
  {
 
38496
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
38497
  }
 
38498
  return resultobj;
 
38499
fail:
 
38500
  return NULL;
 
38501
}
 
38502
 
 
38503
 
 
38504
SWIGINTERN PyObject *TreeCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38505
  PyObject *obj;
 
38506
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
38507
  SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTreeCtrl, SWIG_NewClientData(obj));
 
38508
  return SWIG_Py_Void();
 
38509
}
 
38510
 
 
38511
SWIGINTERN PyObject *TreeCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38512
  return SWIG_Python_InitShadowInstance(args);
 
38513
}
 
38514
 
 
38515
SWIGINTERN int DirDialogDefaultFolderStr_set(PyObject *) {
 
38516
  SWIG_Error(SWIG_AttributeError,"Variable DirDialogDefaultFolderStr is read-only.");
 
38517
  return 1;
 
38518
}
 
38519
 
 
38520
 
 
38521
SWIGINTERN PyObject *DirDialogDefaultFolderStr_get(void) {
 
38522
  PyObject *pyobj = 0;
 
38523
  
 
38524
  {
 
38525
#if wxUSE_UNICODE
 
38526
    pyobj = PyUnicode_FromWideChar((&wxPyDirDialogDefaultFolderStr)->c_str(), (&wxPyDirDialogDefaultFolderStr)->Len());
 
38527
#else
 
38528
    pyobj = PyString_FromStringAndSize((&wxPyDirDialogDefaultFolderStr)->c_str(), (&wxPyDirDialogDefaultFolderStr)->Len());
 
38529
#endif
 
38530
  }
 
38531
  return pyobj;
 
38532
}
 
38533
 
 
38534
 
 
38535
SWIGINTERN PyObject *_wrap_DirItemData_SetNewDirName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38536
  PyObject *resultobj = 0;
 
38537
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38538
  wxString arg2 ;
 
38539
  void *argp1 = 0 ;
 
38540
  int res1 = 0 ;
 
38541
  PyObject * obj0 = 0 ;
 
38542
  PyObject * obj1 = 0 ;
 
38543
  char *  kwnames[] = {
 
38544
    (char *) "self",(char *) "path", NULL 
 
38545
  };
 
38546
  
 
38547
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirItemData_SetNewDirName",kwnames,&obj0,&obj1)) SWIG_fail;
 
38548
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38549
  if (!SWIG_IsOK(res1)) {
 
38550
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_SetNewDirName" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38551
  }
 
38552
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38553
  {
 
38554
    wxString* sptr = wxString_in_helper(obj1);
 
38555
    if (sptr == NULL) SWIG_fail;
 
38556
    arg2 = *sptr;
 
38557
    delete sptr;
 
38558
  }
 
38559
  {
 
38560
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38561
    (arg1)->SetNewDirName(arg2);
 
38562
    wxPyEndAllowThreads(__tstate);
 
38563
    if (PyErr_Occurred()) SWIG_fail;
 
38564
  }
 
38565
  resultobj = SWIG_Py_Void();
 
38566
  return resultobj;
 
38567
fail:
 
38568
  return NULL;
 
38569
}
 
38570
 
 
38571
 
 
38572
SWIGINTERN PyObject *_wrap_DirItemData_m_path_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38573
  PyObject *resultobj = 0;
 
38574
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38575
  wxString *arg2 = (wxString *) 0 ;
 
38576
  void *argp1 = 0 ;
 
38577
  int res1 = 0 ;
 
38578
  bool temp2 = false ;
 
38579
  PyObject *swig_obj[2] ;
 
38580
  
 
38581
  if (!SWIG_Python_UnpackTuple(args,"DirItemData_m_path_set",2,2,swig_obj)) SWIG_fail;
 
38582
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38583
  if (!SWIG_IsOK(res1)) {
 
38584
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_m_path_set" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38585
  }
 
38586
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38587
  {
 
38588
    arg2 = wxString_in_helper(swig_obj[1]);
 
38589
    if (arg2 == NULL) SWIG_fail;
 
38590
    temp2 = true;
 
38591
  }
 
38592
  if (arg1) (arg1)->m_path = *arg2;
 
38593
  
 
38594
  resultobj = SWIG_Py_Void();
 
38595
  {
 
38596
    if (temp2)
 
38597
    delete arg2;
 
38598
  }
 
38599
  return resultobj;
 
38600
fail:
 
38601
  {
 
38602
    if (temp2)
 
38603
    delete arg2;
 
38604
  }
 
38605
  return NULL;
 
38606
}
 
38607
 
 
38608
 
 
38609
SWIGINTERN PyObject *_wrap_DirItemData_m_path_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38610
  PyObject *resultobj = 0;
 
38611
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38612
  wxString *result = 0 ;
 
38613
  void *argp1 = 0 ;
 
38614
  int res1 = 0 ;
 
38615
  PyObject *swig_obj[1] ;
 
38616
  
 
38617
  if (!args) SWIG_fail;
 
38618
  swig_obj[0] = args;
 
38619
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38620
  if (!SWIG_IsOK(res1)) {
 
38621
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_m_path_get" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38622
  }
 
38623
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38624
  result = (wxString *)& ((arg1)->m_path);
 
38625
  {
 
38626
#if wxUSE_UNICODE
 
38627
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
38628
#else
 
38629
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
38630
#endif
 
38631
  }
 
38632
  return resultobj;
 
38633
fail:
 
38634
  return NULL;
 
38635
}
 
38636
 
 
38637
 
 
38638
SWIGINTERN PyObject *_wrap_DirItemData_m_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38639
  PyObject *resultobj = 0;
 
38640
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38641
  wxString *arg2 = (wxString *) 0 ;
 
38642
  void *argp1 = 0 ;
 
38643
  int res1 = 0 ;
 
38644
  bool temp2 = false ;
 
38645
  PyObject *swig_obj[2] ;
 
38646
  
 
38647
  if (!SWIG_Python_UnpackTuple(args,"DirItemData_m_name_set",2,2,swig_obj)) SWIG_fail;
 
38648
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38649
  if (!SWIG_IsOK(res1)) {
 
38650
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_m_name_set" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38651
  }
 
38652
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38653
  {
 
38654
    arg2 = wxString_in_helper(swig_obj[1]);
 
38655
    if (arg2 == NULL) SWIG_fail;
 
38656
    temp2 = true;
 
38657
  }
 
38658
  if (arg1) (arg1)->m_name = *arg2;
 
38659
  
 
38660
  resultobj = SWIG_Py_Void();
 
38661
  {
 
38662
    if (temp2)
 
38663
    delete arg2;
 
38664
  }
 
38665
  return resultobj;
 
38666
fail:
 
38667
  {
 
38668
    if (temp2)
 
38669
    delete arg2;
 
38670
  }
 
38671
  return NULL;
 
38672
}
 
38673
 
 
38674
 
 
38675
SWIGINTERN PyObject *_wrap_DirItemData_m_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38676
  PyObject *resultobj = 0;
 
38677
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38678
  wxString *result = 0 ;
 
38679
  void *argp1 = 0 ;
 
38680
  int res1 = 0 ;
 
38681
  PyObject *swig_obj[1] ;
 
38682
  
 
38683
  if (!args) SWIG_fail;
 
38684
  swig_obj[0] = args;
 
38685
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38686
  if (!SWIG_IsOK(res1)) {
 
38687
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_m_name_get" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38688
  }
 
38689
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38690
  result = (wxString *)& ((arg1)->m_name);
 
38691
  {
 
38692
#if wxUSE_UNICODE
 
38693
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
38694
#else
 
38695
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
38696
#endif
 
38697
  }
 
38698
  return resultobj;
 
38699
fail:
 
38700
  return NULL;
 
38701
}
 
38702
 
 
38703
 
 
38704
SWIGINTERN PyObject *_wrap_DirItemData_m_isHidden_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38705
  PyObject *resultobj = 0;
 
38706
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38707
  bool arg2 ;
 
38708
  void *argp1 = 0 ;
 
38709
  int res1 = 0 ;
 
38710
  bool val2 ;
 
38711
  int ecode2 = 0 ;
 
38712
  PyObject *swig_obj[2] ;
 
38713
  
 
38714
  if (!SWIG_Python_UnpackTuple(args,"DirItemData_m_isHidden_set",2,2,swig_obj)) SWIG_fail;
 
38715
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38716
  if (!SWIG_IsOK(res1)) {
 
38717
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_m_isHidden_set" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38718
  }
 
38719
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38720
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
 
38721
  if (!SWIG_IsOK(ecode2)) {
 
38722
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirItemData_m_isHidden_set" "', expected argument " "2"" of type '" "bool""'");
 
38723
  } 
 
38724
  arg2 = static_cast< bool >(val2);
 
38725
  if (arg1) (arg1)->m_isHidden = arg2;
 
38726
  
 
38727
  resultobj = SWIG_Py_Void();
 
38728
  return resultobj;
 
38729
fail:
 
38730
  return NULL;
 
38731
}
 
38732
 
 
38733
 
 
38734
SWIGINTERN PyObject *_wrap_DirItemData_m_isHidden_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38735
  PyObject *resultobj = 0;
 
38736
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38737
  bool result;
 
38738
  void *argp1 = 0 ;
 
38739
  int res1 = 0 ;
 
38740
  PyObject *swig_obj[1] ;
 
38741
  
 
38742
  if (!args) SWIG_fail;
 
38743
  swig_obj[0] = args;
 
38744
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38745
  if (!SWIG_IsOK(res1)) {
 
38746
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_m_isHidden_get" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38747
  }
 
38748
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38749
  result = (bool) ((arg1)->m_isHidden);
 
38750
  {
 
38751
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
38752
  }
 
38753
  return resultobj;
 
38754
fail:
 
38755
  return NULL;
 
38756
}
 
38757
 
 
38758
 
 
38759
SWIGINTERN PyObject *_wrap_DirItemData_m_isExpanded_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38760
  PyObject *resultobj = 0;
 
38761
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38762
  bool arg2 ;
 
38763
  void *argp1 = 0 ;
 
38764
  int res1 = 0 ;
 
38765
  bool val2 ;
 
38766
  int ecode2 = 0 ;
 
38767
  PyObject *swig_obj[2] ;
 
38768
  
 
38769
  if (!SWIG_Python_UnpackTuple(args,"DirItemData_m_isExpanded_set",2,2,swig_obj)) SWIG_fail;
 
38770
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38771
  if (!SWIG_IsOK(res1)) {
 
38772
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_m_isExpanded_set" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38773
  }
 
38774
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38775
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
 
38776
  if (!SWIG_IsOK(ecode2)) {
 
38777
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirItemData_m_isExpanded_set" "', expected argument " "2"" of type '" "bool""'");
 
38778
  } 
 
38779
  arg2 = static_cast< bool >(val2);
 
38780
  if (arg1) (arg1)->m_isExpanded = arg2;
 
38781
  
 
38782
  resultobj = SWIG_Py_Void();
 
38783
  return resultobj;
 
38784
fail:
 
38785
  return NULL;
 
38786
}
 
38787
 
 
38788
 
 
38789
SWIGINTERN PyObject *_wrap_DirItemData_m_isExpanded_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38790
  PyObject *resultobj = 0;
 
38791
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38792
  bool result;
 
38793
  void *argp1 = 0 ;
 
38794
  int res1 = 0 ;
 
38795
  PyObject *swig_obj[1] ;
 
38796
  
 
38797
  if (!args) SWIG_fail;
 
38798
  swig_obj[0] = args;
 
38799
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38800
  if (!SWIG_IsOK(res1)) {
 
38801
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_m_isExpanded_get" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38802
  }
 
38803
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38804
  result = (bool) ((arg1)->m_isExpanded);
 
38805
  {
 
38806
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
38807
  }
 
38808
  return resultobj;
 
38809
fail:
 
38810
  return NULL;
 
38811
}
 
38812
 
 
38813
 
 
38814
SWIGINTERN PyObject *_wrap_DirItemData_m_isDir_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38815
  PyObject *resultobj = 0;
 
38816
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38817
  bool arg2 ;
 
38818
  void *argp1 = 0 ;
 
38819
  int res1 = 0 ;
 
38820
  bool val2 ;
 
38821
  int ecode2 = 0 ;
 
38822
  PyObject *swig_obj[2] ;
 
38823
  
 
38824
  if (!SWIG_Python_UnpackTuple(args,"DirItemData_m_isDir_set",2,2,swig_obj)) SWIG_fail;
 
38825
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38826
  if (!SWIG_IsOK(res1)) {
 
38827
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_m_isDir_set" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38828
  }
 
38829
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38830
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
 
38831
  if (!SWIG_IsOK(ecode2)) {
 
38832
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirItemData_m_isDir_set" "', expected argument " "2"" of type '" "bool""'");
 
38833
  } 
 
38834
  arg2 = static_cast< bool >(val2);
 
38835
  if (arg1) (arg1)->m_isDir = arg2;
 
38836
  
 
38837
  resultobj = SWIG_Py_Void();
 
38838
  return resultobj;
 
38839
fail:
 
38840
  return NULL;
 
38841
}
 
38842
 
 
38843
 
 
38844
SWIGINTERN PyObject *_wrap_DirItemData_m_isDir_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38845
  PyObject *resultobj = 0;
 
38846
  wxDirItemData *arg1 = (wxDirItemData *) 0 ;
 
38847
  bool result;
 
38848
  void *argp1 = 0 ;
 
38849
  int res1 = 0 ;
 
38850
  PyObject *swig_obj[1] ;
 
38851
  
 
38852
  if (!args) SWIG_fail;
 
38853
  swig_obj[0] = args;
 
38854
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
38855
  if (!SWIG_IsOK(res1)) {
 
38856
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirItemData_m_isDir_get" "', expected argument " "1"" of type '" "wxDirItemData *""'"); 
 
38857
  }
 
38858
  arg1 = reinterpret_cast< wxDirItemData * >(argp1);
 
38859
  result = (bool) ((arg1)->m_isDir);
 
38860
  {
 
38861
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
38862
  }
 
38863
  return resultobj;
 
38864
fail:
 
38865
  return NULL;
 
38866
}
 
38867
 
 
38868
 
 
38869
SWIGINTERN PyObject *DirItemData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
38870
  PyObject *obj;
 
38871
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
38872
  SWIG_TypeNewClientData(SWIGTYPE_p_wxDirItemData, SWIG_NewClientData(obj));
 
38873
  return SWIG_Py_Void();
 
38874
}
 
38875
 
 
38876
SWIGINTERN PyObject *_wrap_new_GenericDirCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
38877
  PyObject *resultobj = 0;
 
38878
  wxWindow *arg1 = (wxWindow *) 0 ;
 
38879
  int arg2 = (int) (int)-1 ;
 
38880
  wxString const &arg3_defvalue = wxPyDirDialogDefaultFolderStr ;
 
38881
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
38882
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
38883
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
38884
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
38885
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
38886
  long arg6 = (long) wxDIRCTRL_3D_INTERNAL ;
 
38887
  wxString const &arg7_defvalue = wxPyEmptyString ;
 
38888
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
38889
  int arg8 = (int) 0 ;
 
38890
  wxString const &arg9_defvalue = wxPyTreeCtrlNameStr ;
 
38891
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
38892
  wxGenericDirCtrl *result = 0 ;
 
38893
  void *argp1 = 0 ;
 
38894
  int res1 = 0 ;
 
38895
  int val2 ;
 
38896
  int ecode2 = 0 ;
 
38897
  bool temp3 = false ;
 
38898
  wxPoint temp4 ;
 
38899
  wxSize temp5 ;
 
38900
  long val6 ;
 
38901
  int ecode6 = 0 ;
 
38902
  bool temp7 = false ;
 
38903
  int val8 ;
 
38904
  int ecode8 = 0 ;
 
38905
  bool temp9 = false ;
 
38906
  PyObject * obj0 = 0 ;
 
38907
  PyObject * obj1 = 0 ;
 
38908
  PyObject * obj2 = 0 ;
 
38909
  PyObject * obj3 = 0 ;
 
38910
  PyObject * obj4 = 0 ;
 
38911
  PyObject * obj5 = 0 ;
 
38912
  PyObject * obj6 = 0 ;
 
38913
  PyObject * obj7 = 0 ;
 
38914
  PyObject * obj8 = 0 ;
 
38915
  char *  kwnames[] = {
 
38916
    (char *) "parent",(char *) "id",(char *) "dir",(char *) "pos",(char *) "size",(char *) "style",(char *) "filter",(char *) "defaultFilter",(char *) "name", NULL 
 
38917
  };
 
38918
  
 
38919
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_GenericDirCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
38920
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
38921
  if (!SWIG_IsOK(res1)) {
 
38922
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GenericDirCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
38923
  }
 
38924
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
38925
  if (obj1) {
 
38926
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
38927
    if (!SWIG_IsOK(ecode2)) {
 
38928
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GenericDirCtrl" "', expected argument " "2"" of type '" "int""'");
 
38929
    } 
 
38930
    arg2 = static_cast< int >(val2);
 
38931
  }
 
38932
  if (obj2) {
 
38933
    {
 
38934
      arg3 = wxString_in_helper(obj2);
 
38935
      if (arg3 == NULL) SWIG_fail;
 
38936
      temp3 = true;
 
38937
    }
 
38938
  }
 
38939
  if (obj3) {
 
38940
    {
 
38941
      arg4 = &temp4;
 
38942
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
38943
    }
 
38944
  }
 
38945
  if (obj4) {
 
38946
    {
 
38947
      arg5 = &temp5;
 
38948
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
38949
    }
 
38950
  }
 
38951
  if (obj5) {
 
38952
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
38953
    if (!SWIG_IsOK(ecode6)) {
 
38954
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GenericDirCtrl" "', expected argument " "6"" of type '" "long""'");
 
38955
    } 
 
38956
    arg6 = static_cast< long >(val6);
 
38957
  }
 
38958
  if (obj6) {
 
38959
    {
 
38960
      arg7 = wxString_in_helper(obj6);
 
38961
      if (arg7 == NULL) SWIG_fail;
 
38962
      temp7 = true;
 
38963
    }
 
38964
  }
 
38965
  if (obj7) {
 
38966
    ecode8 = SWIG_AsVal_int(obj7, &val8);
 
38967
    if (!SWIG_IsOK(ecode8)) {
 
38968
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GenericDirCtrl" "', expected argument " "8"" of type '" "int""'");
 
38969
    } 
 
38970
    arg8 = static_cast< int >(val8);
 
38971
  }
 
38972
  if (obj8) {
 
38973
    {
 
38974
      arg9 = wxString_in_helper(obj8);
 
38975
      if (arg9 == NULL) SWIG_fail;
 
38976
      temp9 = true;
 
38977
    }
 
38978
  }
 
38979
  {
 
38980
    if (!wxPyCheckForApp()) SWIG_fail;
 
38981
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
38982
    result = (wxGenericDirCtrl *)new wxGenericDirCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7,arg8,(wxString const &)*arg9);
 
38983
    wxPyEndAllowThreads(__tstate);
 
38984
    if (PyErr_Occurred()) SWIG_fail;
 
38985
  }
 
38986
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_NEW |  0 );
 
38987
  {
 
38988
    if (temp3)
 
38989
    delete arg3;
 
38990
  }
 
38991
  {
 
38992
    if (temp7)
 
38993
    delete arg7;
 
38994
  }
 
38995
  {
 
38996
    if (temp9)
 
38997
    delete arg9;
 
38998
  }
 
38999
  return resultobj;
 
39000
fail:
 
39001
  {
 
39002
    if (temp3)
 
39003
    delete arg3;
 
39004
  }
 
39005
  {
 
39006
    if (temp7)
 
39007
    delete arg7;
 
39008
  }
 
39009
  {
 
39010
    if (temp9)
 
39011
    delete arg9;
 
39012
  }
 
39013
  return NULL;
 
39014
}
 
39015
 
 
39016
 
 
39017
SWIGINTERN PyObject *_wrap_new_PreGenericDirCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39018
  PyObject *resultobj = 0;
 
39019
  wxGenericDirCtrl *result = 0 ;
 
39020
  
 
39021
  if (!SWIG_Python_UnpackTuple(args,"new_PreGenericDirCtrl",0,0,0)) SWIG_fail;
 
39022
  {
 
39023
    if (!wxPyCheckForApp()) SWIG_fail;
 
39024
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39025
    result = (wxGenericDirCtrl *)new wxGenericDirCtrl();
 
39026
    wxPyEndAllowThreads(__tstate);
 
39027
    if (PyErr_Occurred()) SWIG_fail;
 
39028
  }
 
39029
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGenericDirCtrl, SWIG_POINTER_OWN |  0 );
 
39030
  return resultobj;
 
39031
fail:
 
39032
  return NULL;
 
39033
}
 
39034
 
 
39035
 
 
39036
SWIGINTERN PyObject *_wrap_GenericDirCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39037
  PyObject *resultobj = 0;
 
39038
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39039
  wxWindow *arg2 = (wxWindow *) 0 ;
 
39040
  int arg3 = (int) (int)-1 ;
 
39041
  wxString const &arg4_defvalue = wxPyDirDialogDefaultFolderStr ;
 
39042
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
39043
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
39044
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
39045
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
39046
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
39047
  long arg7 = (long) wxDIRCTRL_3D_INTERNAL ;
 
39048
  wxString const &arg8_defvalue = wxPyEmptyString ;
 
39049
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
39050
  int arg9 = (int) 0 ;
 
39051
  wxString const &arg10_defvalue = wxPyTreeCtrlNameStr ;
 
39052
  wxString *arg10 = (wxString *) &arg10_defvalue ;
 
39053
  bool result;
 
39054
  void *argp1 = 0 ;
 
39055
  int res1 = 0 ;
 
39056
  void *argp2 = 0 ;
 
39057
  int res2 = 0 ;
 
39058
  int val3 ;
 
39059
  int ecode3 = 0 ;
 
39060
  bool temp4 = false ;
 
39061
  wxPoint temp5 ;
 
39062
  wxSize temp6 ;
 
39063
  long val7 ;
 
39064
  int ecode7 = 0 ;
 
39065
  bool temp8 = false ;
 
39066
  int val9 ;
 
39067
  int ecode9 = 0 ;
 
39068
  bool temp10 = false ;
 
39069
  PyObject * obj0 = 0 ;
 
39070
  PyObject * obj1 = 0 ;
 
39071
  PyObject * obj2 = 0 ;
 
39072
  PyObject * obj3 = 0 ;
 
39073
  PyObject * obj4 = 0 ;
 
39074
  PyObject * obj5 = 0 ;
 
39075
  PyObject * obj6 = 0 ;
 
39076
  PyObject * obj7 = 0 ;
 
39077
  PyObject * obj8 = 0 ;
 
39078
  PyObject * obj9 = 0 ;
 
39079
  char *  kwnames[] = {
 
39080
    (char *) "self",(char *) "parent",(char *) "id",(char *) "dir",(char *) "pos",(char *) "size",(char *) "style",(char *) "filter",(char *) "defaultFilter",(char *) "name", NULL 
 
39081
  };
 
39082
  
 
39083
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:GenericDirCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
 
39084
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39085
  if (!SWIG_IsOK(res1)) {
 
39086
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_Create" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39087
  }
 
39088
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39089
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
39090
  if (!SWIG_IsOK(res2)) {
 
39091
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenericDirCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
39092
  }
 
39093
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
39094
  if (obj2) {
 
39095
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
39096
    if (!SWIG_IsOK(ecode3)) {
 
39097
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenericDirCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
39098
    } 
 
39099
    arg3 = static_cast< int >(val3);
 
39100
  }
 
39101
  if (obj3) {
 
39102
    {
 
39103
      arg4 = wxString_in_helper(obj3);
 
39104
      if (arg4 == NULL) SWIG_fail;
 
39105
      temp4 = true;
 
39106
    }
 
39107
  }
 
39108
  if (obj4) {
 
39109
    {
 
39110
      arg5 = &temp5;
 
39111
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
39112
    }
 
39113
  }
 
39114
  if (obj5) {
 
39115
    {
 
39116
      arg6 = &temp6;
 
39117
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
39118
    }
 
39119
  }
 
39120
  if (obj6) {
 
39121
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
39122
    if (!SWIG_IsOK(ecode7)) {
 
39123
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GenericDirCtrl_Create" "', expected argument " "7"" of type '" "long""'");
 
39124
    } 
 
39125
    arg7 = static_cast< long >(val7);
 
39126
  }
 
39127
  if (obj7) {
 
39128
    {
 
39129
      arg8 = wxString_in_helper(obj7);
 
39130
      if (arg8 == NULL) SWIG_fail;
 
39131
      temp8 = true;
 
39132
    }
 
39133
  }
 
39134
  if (obj8) {
 
39135
    ecode9 = SWIG_AsVal_int(obj8, &val9);
 
39136
    if (!SWIG_IsOK(ecode9)) {
 
39137
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GenericDirCtrl_Create" "', expected argument " "9"" of type '" "int""'");
 
39138
    } 
 
39139
    arg9 = static_cast< int >(val9);
 
39140
  }
 
39141
  if (obj9) {
 
39142
    {
 
39143
      arg10 = wxString_in_helper(obj9);
 
39144
      if (arg10 == NULL) SWIG_fail;
 
39145
      temp10 = true;
 
39146
    }
 
39147
  }
 
39148
  {
 
39149
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39150
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8,arg9,(wxString const &)*arg10);
 
39151
    wxPyEndAllowThreads(__tstate);
 
39152
    if (PyErr_Occurred()) SWIG_fail;
 
39153
  }
 
39154
  {
 
39155
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
39156
  }
 
39157
  {
 
39158
    if (temp4)
 
39159
    delete arg4;
 
39160
  }
 
39161
  {
 
39162
    if (temp8)
 
39163
    delete arg8;
 
39164
  }
 
39165
  {
 
39166
    if (temp10)
 
39167
    delete arg10;
 
39168
  }
 
39169
  return resultobj;
 
39170
fail:
 
39171
  {
 
39172
    if (temp4)
 
39173
    delete arg4;
 
39174
  }
 
39175
  {
 
39176
    if (temp8)
 
39177
    delete arg8;
 
39178
  }
 
39179
  {
 
39180
    if (temp10)
 
39181
    delete arg10;
 
39182
  }
 
39183
  return NULL;
 
39184
}
 
39185
 
 
39186
 
 
39187
SWIGINTERN PyObject *_wrap_GenericDirCtrl_ExpandPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39188
  PyObject *resultobj = 0;
 
39189
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39190
  wxString *arg2 = 0 ;
 
39191
  bool result;
 
39192
  void *argp1 = 0 ;
 
39193
  int res1 = 0 ;
 
39194
  bool temp2 = false ;
 
39195
  PyObject * obj0 = 0 ;
 
39196
  PyObject * obj1 = 0 ;
 
39197
  char *  kwnames[] = {
 
39198
    (char *) "self",(char *) "path", NULL 
 
39199
  };
 
39200
  
 
39201
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_ExpandPath",kwnames,&obj0,&obj1)) SWIG_fail;
 
39202
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39203
  if (!SWIG_IsOK(res1)) {
 
39204
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_ExpandPath" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39205
  }
 
39206
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39207
  {
 
39208
    arg2 = wxString_in_helper(obj1);
 
39209
    if (arg2 == NULL) SWIG_fail;
 
39210
    temp2 = true;
 
39211
  }
 
39212
  {
 
39213
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39214
    result = (bool)(arg1)->ExpandPath((wxString const &)*arg2);
 
39215
    wxPyEndAllowThreads(__tstate);
 
39216
    if (PyErr_Occurred()) SWIG_fail;
 
39217
  }
 
39218
  {
 
39219
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
39220
  }
 
39221
  {
 
39222
    if (temp2)
 
39223
    delete arg2;
 
39224
  }
 
39225
  return resultobj;
 
39226
fail:
 
39227
  {
 
39228
    if (temp2)
 
39229
    delete arg2;
 
39230
  }
 
39231
  return NULL;
 
39232
}
 
39233
 
 
39234
 
 
39235
SWIGINTERN PyObject *_wrap_GenericDirCtrl_CollapsePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39236
  PyObject *resultobj = 0;
 
39237
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39238
  wxString *arg2 = 0 ;
 
39239
  bool result;
 
39240
  void *argp1 = 0 ;
 
39241
  int res1 = 0 ;
 
39242
  bool temp2 = false ;
 
39243
  PyObject * obj0 = 0 ;
 
39244
  PyObject * obj1 = 0 ;
 
39245
  char *  kwnames[] = {
 
39246
    (char *) "self",(char *) "path", NULL 
 
39247
  };
 
39248
  
 
39249
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_CollapsePath",kwnames,&obj0,&obj1)) SWIG_fail;
 
39250
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39251
  if (!SWIG_IsOK(res1)) {
 
39252
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_CollapsePath" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39253
  }
 
39254
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39255
  {
 
39256
    arg2 = wxString_in_helper(obj1);
 
39257
    if (arg2 == NULL) SWIG_fail;
 
39258
    temp2 = true;
 
39259
  }
 
39260
  {
 
39261
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39262
    result = (bool)(arg1)->CollapsePath((wxString const &)*arg2);
 
39263
    wxPyEndAllowThreads(__tstate);
 
39264
    if (PyErr_Occurred()) SWIG_fail;
 
39265
  }
 
39266
  {
 
39267
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
39268
  }
 
39269
  {
 
39270
    if (temp2)
 
39271
    delete arg2;
 
39272
  }
 
39273
  return resultobj;
 
39274
fail:
 
39275
  {
 
39276
    if (temp2)
 
39277
    delete arg2;
 
39278
  }
 
39279
  return NULL;
 
39280
}
 
39281
 
 
39282
 
 
39283
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetDefaultPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39284
  PyObject *resultobj = 0;
 
39285
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39286
  wxString result;
 
39287
  void *argp1 = 0 ;
 
39288
  int res1 = 0 ;
 
39289
  PyObject *swig_obj[1] ;
 
39290
  
 
39291
  if (!args) SWIG_fail;
 
39292
  swig_obj[0] = args;
 
39293
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39294
  if (!SWIG_IsOK(res1)) {
 
39295
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetDefaultPath" "', expected argument " "1"" of type '" "wxGenericDirCtrl const *""'"); 
 
39296
  }
 
39297
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39298
  {
 
39299
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39300
    result = ((wxGenericDirCtrl const *)arg1)->GetDefaultPath();
 
39301
    wxPyEndAllowThreads(__tstate);
 
39302
    if (PyErr_Occurred()) SWIG_fail;
 
39303
  }
 
39304
  {
 
39305
#if wxUSE_UNICODE
 
39306
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
39307
#else
 
39308
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
39309
#endif
 
39310
  }
 
39311
  return resultobj;
 
39312
fail:
 
39313
  return NULL;
 
39314
}
 
39315
 
 
39316
 
 
39317
SWIGINTERN PyObject *_wrap_GenericDirCtrl_SetDefaultPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39318
  PyObject *resultobj = 0;
 
39319
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39320
  wxString *arg2 = 0 ;
 
39321
  void *argp1 = 0 ;
 
39322
  int res1 = 0 ;
 
39323
  bool temp2 = false ;
 
39324
  PyObject * obj0 = 0 ;
 
39325
  PyObject * obj1 = 0 ;
 
39326
  char *  kwnames[] = {
 
39327
    (char *) "self",(char *) "path", NULL 
 
39328
  };
 
39329
  
 
39330
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetDefaultPath",kwnames,&obj0,&obj1)) SWIG_fail;
 
39331
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39332
  if (!SWIG_IsOK(res1)) {
 
39333
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_SetDefaultPath" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39334
  }
 
39335
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39336
  {
 
39337
    arg2 = wxString_in_helper(obj1);
 
39338
    if (arg2 == NULL) SWIG_fail;
 
39339
    temp2 = true;
 
39340
  }
 
39341
  {
 
39342
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39343
    (arg1)->SetDefaultPath((wxString const &)*arg2);
 
39344
    wxPyEndAllowThreads(__tstate);
 
39345
    if (PyErr_Occurred()) SWIG_fail;
 
39346
  }
 
39347
  resultobj = SWIG_Py_Void();
 
39348
  {
 
39349
    if (temp2)
 
39350
    delete arg2;
 
39351
  }
 
39352
  return resultobj;
 
39353
fail:
 
39354
  {
 
39355
    if (temp2)
 
39356
    delete arg2;
 
39357
  }
 
39358
  return NULL;
 
39359
}
 
39360
 
 
39361
 
 
39362
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39363
  PyObject *resultobj = 0;
 
39364
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39365
  wxString result;
 
39366
  void *argp1 = 0 ;
 
39367
  int res1 = 0 ;
 
39368
  PyObject *swig_obj[1] ;
 
39369
  
 
39370
  if (!args) SWIG_fail;
 
39371
  swig_obj[0] = args;
 
39372
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39373
  if (!SWIG_IsOK(res1)) {
 
39374
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetPath" "', expected argument " "1"" of type '" "wxGenericDirCtrl const *""'"); 
 
39375
  }
 
39376
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39377
  {
 
39378
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39379
    result = ((wxGenericDirCtrl const *)arg1)->GetPath();
 
39380
    wxPyEndAllowThreads(__tstate);
 
39381
    if (PyErr_Occurred()) SWIG_fail;
 
39382
  }
 
39383
  {
 
39384
#if wxUSE_UNICODE
 
39385
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
39386
#else
 
39387
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
39388
#endif
 
39389
  }
 
39390
  return resultobj;
 
39391
fail:
 
39392
  return NULL;
 
39393
}
 
39394
 
 
39395
 
 
39396
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetPaths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39397
  PyObject *resultobj = 0;
 
39398
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39399
  wxArrayString result;
 
39400
  void *argp1 = 0 ;
 
39401
  int res1 = 0 ;
 
39402
  PyObject *swig_obj[1] ;
 
39403
  
 
39404
  if (!args) SWIG_fail;
 
39405
  swig_obj[0] = args;
 
39406
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39407
  if (!SWIG_IsOK(res1)) {
 
39408
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetPaths" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39409
  }
 
39410
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39411
  {
 
39412
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39413
    result = wxGenericDirCtrl_GetPaths(arg1);
 
39414
    wxPyEndAllowThreads(__tstate);
 
39415
    if (PyErr_Occurred()) SWIG_fail;
 
39416
  }
 
39417
  {
 
39418
    resultobj = wxArrayString2PyList_helper(result);
 
39419
  }
 
39420
  return resultobj;
 
39421
fail:
 
39422
  return NULL;
 
39423
}
 
39424
 
 
39425
 
 
39426
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetFilePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39427
  PyObject *resultobj = 0;
 
39428
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39429
  wxString result;
 
39430
  void *argp1 = 0 ;
 
39431
  int res1 = 0 ;
 
39432
  PyObject *swig_obj[1] ;
 
39433
  
 
39434
  if (!args) SWIG_fail;
 
39435
  swig_obj[0] = args;
 
39436
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39437
  if (!SWIG_IsOK(res1)) {
 
39438
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetFilePath" "', expected argument " "1"" of type '" "wxGenericDirCtrl const *""'"); 
 
39439
  }
 
39440
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39441
  {
 
39442
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39443
    result = ((wxGenericDirCtrl const *)arg1)->GetFilePath();
 
39444
    wxPyEndAllowThreads(__tstate);
 
39445
    if (PyErr_Occurred()) SWIG_fail;
 
39446
  }
 
39447
  {
 
39448
#if wxUSE_UNICODE
 
39449
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
39450
#else
 
39451
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
39452
#endif
 
39453
  }
 
39454
  return resultobj;
 
39455
fail:
 
39456
  return NULL;
 
39457
}
 
39458
 
 
39459
 
 
39460
SWIGINTERN PyObject *_wrap_GenericDirCtrl_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39461
  PyObject *resultobj = 0;
 
39462
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39463
  wxString *arg2 = 0 ;
 
39464
  void *argp1 = 0 ;
 
39465
  int res1 = 0 ;
 
39466
  bool temp2 = false ;
 
39467
  PyObject * obj0 = 0 ;
 
39468
  PyObject * obj1 = 0 ;
 
39469
  char *  kwnames[] = {
 
39470
    (char *) "self",(char *) "path", NULL 
 
39471
  };
 
39472
  
 
39473
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
 
39474
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39475
  if (!SWIG_IsOK(res1)) {
 
39476
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_SetPath" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39477
  }
 
39478
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39479
  {
 
39480
    arg2 = wxString_in_helper(obj1);
 
39481
    if (arg2 == NULL) SWIG_fail;
 
39482
    temp2 = true;
 
39483
  }
 
39484
  {
 
39485
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39486
    (arg1)->SetPath((wxString const &)*arg2);
 
39487
    wxPyEndAllowThreads(__tstate);
 
39488
    if (PyErr_Occurred()) SWIG_fail;
 
39489
  }
 
39490
  resultobj = SWIG_Py_Void();
 
39491
  {
 
39492
    if (temp2)
 
39493
    delete arg2;
 
39494
  }
 
39495
  return resultobj;
 
39496
fail:
 
39497
  {
 
39498
    if (temp2)
 
39499
    delete arg2;
 
39500
  }
 
39501
  return NULL;
 
39502
}
 
39503
 
 
39504
 
 
39505
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetFilePaths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39506
  PyObject *resultobj = 0;
 
39507
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39508
  wxArrayString result;
 
39509
  void *argp1 = 0 ;
 
39510
  int res1 = 0 ;
 
39511
  PyObject *swig_obj[1] ;
 
39512
  
 
39513
  if (!args) SWIG_fail;
 
39514
  swig_obj[0] = args;
 
39515
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39516
  if (!SWIG_IsOK(res1)) {
 
39517
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetFilePaths" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39518
  }
 
39519
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39520
  {
 
39521
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39522
    result = wxGenericDirCtrl_GetFilePaths(arg1);
 
39523
    wxPyEndAllowThreads(__tstate);
 
39524
    if (PyErr_Occurred()) SWIG_fail;
 
39525
  }
 
39526
  {
 
39527
    resultobj = wxArrayString2PyList_helper(result);
 
39528
  }
 
39529
  return resultobj;
 
39530
fail:
 
39531
  return NULL;
 
39532
}
 
39533
 
 
39534
 
 
39535
SWIGINTERN PyObject *_wrap_GenericDirCtrl_SelectPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39536
  PyObject *resultobj = 0;
 
39537
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39538
  wxString *arg2 = 0 ;
 
39539
  bool arg3 = (bool) true ;
 
39540
  void *argp1 = 0 ;
 
39541
  int res1 = 0 ;
 
39542
  bool temp2 = false ;
 
39543
  bool val3 ;
 
39544
  int ecode3 = 0 ;
 
39545
  PyObject * obj0 = 0 ;
 
39546
  PyObject * obj1 = 0 ;
 
39547
  PyObject * obj2 = 0 ;
 
39548
  char *  kwnames[] = {
 
39549
    (char *) "self",(char *) "path",(char *) "select", NULL 
 
39550
  };
 
39551
  
 
39552
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GenericDirCtrl_SelectPath",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
39553
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39554
  if (!SWIG_IsOK(res1)) {
 
39555
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_SelectPath" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39556
  }
 
39557
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39558
  {
 
39559
    arg2 = wxString_in_helper(obj1);
 
39560
    if (arg2 == NULL) SWIG_fail;
 
39561
    temp2 = true;
 
39562
  }
 
39563
  if (obj2) {
 
39564
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
39565
    if (!SWIG_IsOK(ecode3)) {
 
39566
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenericDirCtrl_SelectPath" "', expected argument " "3"" of type '" "bool""'");
 
39567
    } 
 
39568
    arg3 = static_cast< bool >(val3);
 
39569
  }
 
39570
  {
 
39571
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39572
    (arg1)->SelectPath((wxString const &)*arg2,arg3);
 
39573
    wxPyEndAllowThreads(__tstate);
 
39574
    if (PyErr_Occurred()) SWIG_fail;
 
39575
  }
 
39576
  resultobj = SWIG_Py_Void();
 
39577
  {
 
39578
    if (temp2)
 
39579
    delete arg2;
 
39580
  }
 
39581
  return resultobj;
 
39582
fail:
 
39583
  {
 
39584
    if (temp2)
 
39585
    delete arg2;
 
39586
  }
 
39587
  return NULL;
 
39588
}
 
39589
 
 
39590
 
 
39591
SWIGINTERN PyObject *_wrap_GenericDirCtrl_SelectPaths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39592
  PyObject *resultobj = 0;
 
39593
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39594
  wxArrayString *arg2 = 0 ;
 
39595
  void *argp1 = 0 ;
 
39596
  int res1 = 0 ;
 
39597
  bool temp2 = false ;
 
39598
  PyObject * obj0 = 0 ;
 
39599
  PyObject * obj1 = 0 ;
 
39600
  char *  kwnames[] = {
 
39601
    (char *) "self",(char *) "paths", NULL 
 
39602
  };
 
39603
  
 
39604
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SelectPaths",kwnames,&obj0,&obj1)) SWIG_fail;
 
39605
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39606
  if (!SWIG_IsOK(res1)) {
 
39607
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_SelectPaths" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39608
  }
 
39609
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39610
  {
 
39611
    if (! PySequence_Check(obj1)) {
 
39612
      PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
39613
      SWIG_fail;
 
39614
    }
 
39615
    arg2 = new wxArrayString;
 
39616
    temp2 = true;
 
39617
    int i, len=PySequence_Length(obj1);
 
39618
    for (i=0; i<len; i++) {
 
39619
      PyObject* item = PySequence_GetItem(obj1, i);
 
39620
      wxString* s = wxString_in_helper(item);
 
39621
      if (PyErr_Occurred())  SWIG_fail;
 
39622
      arg2->Add(*s);
 
39623
      delete s;
 
39624
      Py_DECREF(item);
 
39625
    }
 
39626
  }
 
39627
  {
 
39628
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39629
    (arg1)->SelectPaths((wxArrayString const &)*arg2);
 
39630
    wxPyEndAllowThreads(__tstate);
 
39631
    if (PyErr_Occurred()) SWIG_fail;
 
39632
  }
 
39633
  resultobj = SWIG_Py_Void();
 
39634
  {
 
39635
    if (temp2) delete arg2;
 
39636
  }
 
39637
  return resultobj;
 
39638
fail:
 
39639
  {
 
39640
    if (temp2) delete arg2;
 
39641
  }
 
39642
  return NULL;
 
39643
}
 
39644
 
 
39645
 
 
39646
SWIGINTERN PyObject *_wrap_GenericDirCtrl_ShowHidden(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39647
  PyObject *resultobj = 0;
 
39648
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39649
  bool arg2 ;
 
39650
  void *argp1 = 0 ;
 
39651
  int res1 = 0 ;
 
39652
  bool val2 ;
 
39653
  int ecode2 = 0 ;
 
39654
  PyObject * obj0 = 0 ;
 
39655
  PyObject * obj1 = 0 ;
 
39656
  char *  kwnames[] = {
 
39657
    (char *) "self",(char *) "show", NULL 
 
39658
  };
 
39659
  
 
39660
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_ShowHidden",kwnames,&obj0,&obj1)) SWIG_fail;
 
39661
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39662
  if (!SWIG_IsOK(res1)) {
 
39663
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_ShowHidden" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39664
  }
 
39665
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39666
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
39667
  if (!SWIG_IsOK(ecode2)) {
 
39668
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericDirCtrl_ShowHidden" "', expected argument " "2"" of type '" "bool""'");
 
39669
  } 
 
39670
  arg2 = static_cast< bool >(val2);
 
39671
  {
 
39672
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39673
    (arg1)->ShowHidden(arg2);
 
39674
    wxPyEndAllowThreads(__tstate);
 
39675
    if (PyErr_Occurred()) SWIG_fail;
 
39676
  }
 
39677
  resultobj = SWIG_Py_Void();
 
39678
  return resultobj;
 
39679
fail:
 
39680
  return NULL;
 
39681
}
 
39682
 
 
39683
 
 
39684
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetShowHidden(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39685
  PyObject *resultobj = 0;
 
39686
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39687
  bool result;
 
39688
  void *argp1 = 0 ;
 
39689
  int res1 = 0 ;
 
39690
  PyObject *swig_obj[1] ;
 
39691
  
 
39692
  if (!args) SWIG_fail;
 
39693
  swig_obj[0] = args;
 
39694
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39695
  if (!SWIG_IsOK(res1)) {
 
39696
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetShowHidden" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39697
  }
 
39698
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39699
  {
 
39700
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39701
    result = (bool)(arg1)->GetShowHidden();
 
39702
    wxPyEndAllowThreads(__tstate);
 
39703
    if (PyErr_Occurred()) SWIG_fail;
 
39704
  }
 
39705
  {
 
39706
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
39707
  }
 
39708
  return resultobj;
 
39709
fail:
 
39710
  return NULL;
 
39711
}
 
39712
 
 
39713
 
 
39714
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39715
  PyObject *resultobj = 0;
 
39716
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39717
  wxString result;
 
39718
  void *argp1 = 0 ;
 
39719
  int res1 = 0 ;
 
39720
  PyObject *swig_obj[1] ;
 
39721
  
 
39722
  if (!args) SWIG_fail;
 
39723
  swig_obj[0] = args;
 
39724
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39725
  if (!SWIG_IsOK(res1)) {
 
39726
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetFilter" "', expected argument " "1"" of type '" "wxGenericDirCtrl const *""'"); 
 
39727
  }
 
39728
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39729
  {
 
39730
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39731
    result = ((wxGenericDirCtrl const *)arg1)->GetFilter();
 
39732
    wxPyEndAllowThreads(__tstate);
 
39733
    if (PyErr_Occurred()) SWIG_fail;
 
39734
  }
 
39735
  {
 
39736
#if wxUSE_UNICODE
 
39737
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
39738
#else
 
39739
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
39740
#endif
 
39741
  }
 
39742
  return resultobj;
 
39743
fail:
 
39744
  return NULL;
 
39745
}
 
39746
 
 
39747
 
 
39748
SWIGINTERN PyObject *_wrap_GenericDirCtrl_SetFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39749
  PyObject *resultobj = 0;
 
39750
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39751
  wxString *arg2 = 0 ;
 
39752
  void *argp1 = 0 ;
 
39753
  int res1 = 0 ;
 
39754
  bool temp2 = false ;
 
39755
  PyObject * obj0 = 0 ;
 
39756
  PyObject * obj1 = 0 ;
 
39757
  char *  kwnames[] = {
 
39758
    (char *) "self",(char *) "filter", NULL 
 
39759
  };
 
39760
  
 
39761
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetFilter",kwnames,&obj0,&obj1)) SWIG_fail;
 
39762
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39763
  if (!SWIG_IsOK(res1)) {
 
39764
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_SetFilter" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39765
  }
 
39766
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39767
  {
 
39768
    arg2 = wxString_in_helper(obj1);
 
39769
    if (arg2 == NULL) SWIG_fail;
 
39770
    temp2 = true;
 
39771
  }
 
39772
  {
 
39773
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39774
    (arg1)->SetFilter((wxString const &)*arg2);
 
39775
    wxPyEndAllowThreads(__tstate);
 
39776
    if (PyErr_Occurred()) SWIG_fail;
 
39777
  }
 
39778
  resultobj = SWIG_Py_Void();
 
39779
  {
 
39780
    if (temp2)
 
39781
    delete arg2;
 
39782
  }
 
39783
  return resultobj;
 
39784
fail:
 
39785
  {
 
39786
    if (temp2)
 
39787
    delete arg2;
 
39788
  }
 
39789
  return NULL;
 
39790
}
 
39791
 
 
39792
 
 
39793
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetFilterIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39794
  PyObject *resultobj = 0;
 
39795
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39796
  int result;
 
39797
  void *argp1 = 0 ;
 
39798
  int res1 = 0 ;
 
39799
  PyObject *swig_obj[1] ;
 
39800
  
 
39801
  if (!args) SWIG_fail;
 
39802
  swig_obj[0] = args;
 
39803
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39804
  if (!SWIG_IsOK(res1)) {
 
39805
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetFilterIndex" "', expected argument " "1"" of type '" "wxGenericDirCtrl const *""'"); 
 
39806
  }
 
39807
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39808
  {
 
39809
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39810
    result = (int)((wxGenericDirCtrl const *)arg1)->GetFilterIndex();
 
39811
    wxPyEndAllowThreads(__tstate);
 
39812
    if (PyErr_Occurred()) SWIG_fail;
 
39813
  }
 
39814
  resultobj = SWIG_From_int(static_cast< int >(result));
 
39815
  return resultobj;
 
39816
fail:
 
39817
  return NULL;
 
39818
}
 
39819
 
 
39820
 
 
39821
SWIGINTERN PyObject *_wrap_GenericDirCtrl_SetFilterIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39822
  PyObject *resultobj = 0;
 
39823
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39824
  int arg2 ;
 
39825
  void *argp1 = 0 ;
 
39826
  int res1 = 0 ;
 
39827
  int val2 ;
 
39828
  int ecode2 = 0 ;
 
39829
  PyObject * obj0 = 0 ;
 
39830
  PyObject * obj1 = 0 ;
 
39831
  char *  kwnames[] = {
 
39832
    (char *) "self",(char *) "n", NULL 
 
39833
  };
 
39834
  
 
39835
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_SetFilterIndex",kwnames,&obj0,&obj1)) SWIG_fail;
 
39836
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39837
  if (!SWIG_IsOK(res1)) {
 
39838
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_SetFilterIndex" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39839
  }
 
39840
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39841
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
39842
  if (!SWIG_IsOK(ecode2)) {
 
39843
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenericDirCtrl_SetFilterIndex" "', expected argument " "2"" of type '" "int""'");
 
39844
  } 
 
39845
  arg2 = static_cast< int >(val2);
 
39846
  {
 
39847
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39848
    (arg1)->SetFilterIndex(arg2);
 
39849
    wxPyEndAllowThreads(__tstate);
 
39850
    if (PyErr_Occurred()) SWIG_fail;
 
39851
  }
 
39852
  resultobj = SWIG_Py_Void();
 
39853
  return resultobj;
 
39854
fail:
 
39855
  return NULL;
 
39856
}
 
39857
 
 
39858
 
 
39859
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetRootId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39860
  PyObject *resultobj = 0;
 
39861
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39862
  wxTreeItemId result;
 
39863
  void *argp1 = 0 ;
 
39864
  int res1 = 0 ;
 
39865
  PyObject *swig_obj[1] ;
 
39866
  
 
39867
  if (!args) SWIG_fail;
 
39868
  swig_obj[0] = args;
 
39869
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39870
  if (!SWIG_IsOK(res1)) {
 
39871
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetRootId" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39872
  }
 
39873
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39874
  {
 
39875
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39876
    result = (arg1)->GetRootId();
 
39877
    wxPyEndAllowThreads(__tstate);
 
39878
    if (PyErr_Occurred()) SWIG_fail;
 
39879
  }
 
39880
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
39881
  return resultobj;
 
39882
fail:
 
39883
  return NULL;
 
39884
}
 
39885
 
 
39886
 
 
39887
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetTreeCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39888
  PyObject *resultobj = 0;
 
39889
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39890
  wxPyTreeCtrl *result = 0 ;
 
39891
  void *argp1 = 0 ;
 
39892
  int res1 = 0 ;
 
39893
  PyObject *swig_obj[1] ;
 
39894
  
 
39895
  if (!args) SWIG_fail;
 
39896
  swig_obj[0] = args;
 
39897
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39898
  if (!SWIG_IsOK(res1)) {
 
39899
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetTreeCtrl" "', expected argument " "1"" of type '" "wxGenericDirCtrl const *""'"); 
 
39900
  }
 
39901
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39902
  {
 
39903
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39904
    result = (wxPyTreeCtrl *)((wxGenericDirCtrl const *)arg1)->GetTreeCtrl();
 
39905
    wxPyEndAllowThreads(__tstate);
 
39906
    if (PyErr_Occurred()) SWIG_fail;
 
39907
  }
 
39908
  {
 
39909
    resultobj = wxPyMake_wxObject(result, 0); 
 
39910
  }
 
39911
  return resultobj;
 
39912
fail:
 
39913
  return NULL;
 
39914
}
 
39915
 
 
39916
 
 
39917
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetFilterListCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39918
  PyObject *resultobj = 0;
 
39919
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39920
  wxDirFilterListCtrl *result = 0 ;
 
39921
  void *argp1 = 0 ;
 
39922
  int res1 = 0 ;
 
39923
  PyObject *swig_obj[1] ;
 
39924
  
 
39925
  if (!args) SWIG_fail;
 
39926
  swig_obj[0] = args;
 
39927
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39928
  if (!SWIG_IsOK(res1)) {
 
39929
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetFilterListCtrl" "', expected argument " "1"" of type '" "wxGenericDirCtrl const *""'"); 
 
39930
  }
 
39931
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39932
  {
 
39933
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39934
    result = (wxDirFilterListCtrl *)((wxGenericDirCtrl const *)arg1)->GetFilterListCtrl();
 
39935
    wxPyEndAllowThreads(__tstate);
 
39936
    if (PyErr_Occurred()) SWIG_fail;
 
39937
  }
 
39938
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDirFilterListCtrl, 0 |  0 );
 
39939
  return resultobj;
 
39940
fail:
 
39941
  return NULL;
 
39942
}
 
39943
 
 
39944
 
 
39945
SWIGINTERN PyObject *_wrap_GenericDirCtrl_UnselectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
39946
  PyObject *resultobj = 0;
 
39947
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39948
  void *argp1 = 0 ;
 
39949
  int res1 = 0 ;
 
39950
  PyObject *swig_obj[1] ;
 
39951
  
 
39952
  if (!args) SWIG_fail;
 
39953
  swig_obj[0] = args;
 
39954
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39955
  if (!SWIG_IsOK(res1)) {
 
39956
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_UnselectAll" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
39957
  }
 
39958
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39959
  {
 
39960
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
39961
    (arg1)->UnselectAll();
 
39962
    wxPyEndAllowThreads(__tstate);
 
39963
    if (PyErr_Occurred()) SWIG_fail;
 
39964
  }
 
39965
  resultobj = SWIG_Py_Void();
 
39966
  return resultobj;
 
39967
fail:
 
39968
  return NULL;
 
39969
}
 
39970
 
 
39971
 
 
39972
SWIGINTERN PyObject *_wrap_GenericDirCtrl_GetDirItemData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
39973
  PyObject *resultobj = 0;
 
39974
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
39975
  wxTreeItemId *arg2 = 0 ;
 
39976
  wxDirItemData *result = 0 ;
 
39977
  void *argp1 = 0 ;
 
39978
  int res1 = 0 ;
 
39979
  void *argp2 = 0 ;
 
39980
  int res2 = 0 ;
 
39981
  PyObject * obj0 = 0 ;
 
39982
  PyObject * obj1 = 0 ;
 
39983
  char *  kwnames[] = {
 
39984
    (char *) "self",(char *) "id", NULL 
 
39985
  };
 
39986
  
 
39987
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GenericDirCtrl_GetDirItemData",kwnames,&obj0,&obj1)) SWIG_fail;
 
39988
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
39989
  if (!SWIG_IsOK(res1)) {
 
39990
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_GetDirItemData" "', expected argument " "1"" of type '" "wxGenericDirCtrl const *""'"); 
 
39991
  }
 
39992
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
39993
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
39994
  if (!SWIG_IsOK(res2)) {
 
39995
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenericDirCtrl_GetDirItemData" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
39996
  }
 
39997
  if (!argp2) {
 
39998
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericDirCtrl_GetDirItemData" "', expected argument " "2"" of type '" "wxTreeItemId const &""'"); 
 
39999
  }
 
40000
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
40001
  {
 
40002
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40003
    result = (wxDirItemData *)wxGenericDirCtrl_GetDirItemData((wxGenericDirCtrl const *)arg1,(wxTreeItemId const &)*arg2);
 
40004
    wxPyEndAllowThreads(__tstate);
 
40005
    if (PyErr_Occurred()) SWIG_fail;
 
40006
  }
 
40007
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDirItemData, 0 |  0 );
 
40008
  return resultobj;
 
40009
fail:
 
40010
  return NULL;
 
40011
}
 
40012
 
 
40013
 
 
40014
SWIGINTERN PyObject *_wrap_GenericDirCtrl_FindChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40015
  PyObject *resultobj = 0;
 
40016
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
40017
  wxTreeItemId arg2 ;
 
40018
  wxString *arg3 = 0 ;
 
40019
  bool *arg4 = 0 ;
 
40020
  wxTreeItemId result;
 
40021
  void *argp1 = 0 ;
 
40022
  int res1 = 0 ;
 
40023
  void *argp2 ;
 
40024
  int res2 = 0 ;
 
40025
  bool temp3 = false ;
 
40026
  bool temp4 ;
 
40027
  int res4 = SWIG_TMPOBJ ;
 
40028
  PyObject * obj0 = 0 ;
 
40029
  PyObject * obj1 = 0 ;
 
40030
  PyObject * obj2 = 0 ;
 
40031
  char *  kwnames[] = {
 
40032
    (char *) "self",(char *) "parentId",(char *) "path", NULL 
 
40033
  };
 
40034
  
 
40035
  arg4 = &temp4;
 
40036
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GenericDirCtrl_FindChild",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
40037
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
40038
  if (!SWIG_IsOK(res1)) {
 
40039
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_FindChild" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
40040
  }
 
40041
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
40042
  {
 
40043
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0  | 0);
 
40044
    if (!SWIG_IsOK(res2)) {
 
40045
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenericDirCtrl_FindChild" "', expected argument " "2"" of type '" "wxTreeItemId""'"); 
 
40046
    }  
 
40047
    if (!argp2) {
 
40048
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericDirCtrl_FindChild" "', expected argument " "2"" of type '" "wxTreeItemId""'");
 
40049
    } else {
 
40050
      wxTreeItemId * temp = reinterpret_cast< wxTreeItemId * >(argp2);
 
40051
      arg2 = *temp;
 
40052
      if (SWIG_IsNewObj(res2)) delete temp;
 
40053
    }
 
40054
  }
 
40055
  {
 
40056
    arg3 = wxString_in_helper(obj2);
 
40057
    if (arg3 == NULL) SWIG_fail;
 
40058
    temp3 = true;
 
40059
  }
 
40060
  {
 
40061
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40062
    result = (arg1)->FindChild(arg2,(wxString const &)*arg3,*arg4);
 
40063
    wxPyEndAllowThreads(__tstate);
 
40064
    if (PyErr_Occurred()) SWIG_fail;
 
40065
  }
 
40066
  resultobj = SWIG_NewPointerObj((new wxTreeItemId(static_cast< const wxTreeItemId& >(result))), SWIGTYPE_p_wxTreeItemId, SWIG_POINTER_OWN |  0 );
 
40067
  if (SWIG_IsTmpObj(res4)) {
 
40068
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_bool((*arg4)));
 
40069
  } else {
 
40070
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
40071
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_bool, new_flags));
 
40072
  }
 
40073
  {
 
40074
    if (temp3)
 
40075
    delete arg3;
 
40076
  }
 
40077
  return resultobj;
 
40078
fail:
 
40079
  {
 
40080
    if (temp3)
 
40081
    delete arg3;
 
40082
  }
 
40083
  return NULL;
 
40084
}
 
40085
 
 
40086
 
 
40087
SWIGINTERN PyObject *_wrap_GenericDirCtrl_DoResize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40088
  PyObject *resultobj = 0;
 
40089
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
40090
  void *argp1 = 0 ;
 
40091
  int res1 = 0 ;
 
40092
  PyObject *swig_obj[1] ;
 
40093
  
 
40094
  if (!args) SWIG_fail;
 
40095
  swig_obj[0] = args;
 
40096
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
40097
  if (!SWIG_IsOK(res1)) {
 
40098
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_DoResize" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
40099
  }
 
40100
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
40101
  {
 
40102
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40103
    (arg1)->DoResize();
 
40104
    wxPyEndAllowThreads(__tstate);
 
40105
    if (PyErr_Occurred()) SWIG_fail;
 
40106
  }
 
40107
  resultobj = SWIG_Py_Void();
 
40108
  return resultobj;
 
40109
fail:
 
40110
  return NULL;
 
40111
}
 
40112
 
 
40113
 
 
40114
SWIGINTERN PyObject *_wrap_GenericDirCtrl_ReCreateTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40115
  PyObject *resultobj = 0;
 
40116
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
40117
  void *argp1 = 0 ;
 
40118
  int res1 = 0 ;
 
40119
  PyObject *swig_obj[1] ;
 
40120
  
 
40121
  if (!args) SWIG_fail;
 
40122
  swig_obj[0] = args;
 
40123
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
40124
  if (!SWIG_IsOK(res1)) {
 
40125
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDirCtrl_ReCreateTree" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
40126
  }
 
40127
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
40128
  {
 
40129
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40130
    (arg1)->ReCreateTree();
 
40131
    wxPyEndAllowThreads(__tstate);
 
40132
    if (PyErr_Occurred()) SWIG_fail;
 
40133
  }
 
40134
  resultobj = SWIG_Py_Void();
 
40135
  return resultobj;
 
40136
fail:
 
40137
  return NULL;
 
40138
}
 
40139
 
 
40140
 
 
40141
SWIGINTERN PyObject *GenericDirCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40142
  PyObject *obj;
 
40143
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
40144
  SWIG_TypeNewClientData(SWIGTYPE_p_wxGenericDirCtrl, SWIG_NewClientData(obj));
 
40145
  return SWIG_Py_Void();
 
40146
}
 
40147
 
 
40148
SWIGINTERN PyObject *GenericDirCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40149
  return SWIG_Python_InitShadowInstance(args);
 
40150
}
 
40151
 
 
40152
SWIGINTERN PyObject *_wrap_new_DirFilterListCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40153
  PyObject *resultobj = 0;
 
40154
  wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
 
40155
  int arg2 = (int) (int)-1 ;
 
40156
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
40157
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
40158
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
40159
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
40160
  long arg5 = (long) 0 ;
 
40161
  wxDirFilterListCtrl *result = 0 ;
 
40162
  void *argp1 = 0 ;
 
40163
  int res1 = 0 ;
 
40164
  int val2 ;
 
40165
  int ecode2 = 0 ;
 
40166
  wxPoint temp3 ;
 
40167
  wxSize temp4 ;
 
40168
  long val5 ;
 
40169
  int ecode5 = 0 ;
 
40170
  PyObject * obj0 = 0 ;
 
40171
  PyObject * obj1 = 0 ;
 
40172
  PyObject * obj2 = 0 ;
 
40173
  PyObject * obj3 = 0 ;
 
40174
  PyObject * obj4 = 0 ;
 
40175
  char *  kwnames[] = {
 
40176
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL 
 
40177
  };
 
40178
  
 
40179
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:new_DirFilterListCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
40180
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
40181
  if (!SWIG_IsOK(res1)) {
 
40182
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DirFilterListCtrl" "', expected argument " "1"" of type '" "wxGenericDirCtrl *""'"); 
 
40183
  }
 
40184
  arg1 = reinterpret_cast< wxGenericDirCtrl * >(argp1);
 
40185
  if (obj1) {
 
40186
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
40187
    if (!SWIG_IsOK(ecode2)) {
 
40188
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DirFilterListCtrl" "', expected argument " "2"" of type '" "int""'");
 
40189
    } 
 
40190
    arg2 = static_cast< int >(val2);
 
40191
  }
 
40192
  if (obj2) {
 
40193
    {
 
40194
      arg3 = &temp3;
 
40195
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
40196
    }
 
40197
  }
 
40198
  if (obj3) {
 
40199
    {
 
40200
      arg4 = &temp4;
 
40201
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
40202
    }
 
40203
  }
 
40204
  if (obj4) {
 
40205
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
40206
    if (!SWIG_IsOK(ecode5)) {
 
40207
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DirFilterListCtrl" "', expected argument " "5"" of type '" "long""'");
 
40208
    } 
 
40209
    arg5 = static_cast< long >(val5);
 
40210
  }
 
40211
  {
 
40212
    if (!wxPyCheckForApp()) SWIG_fail;
 
40213
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40214
    result = (wxDirFilterListCtrl *)new wxDirFilterListCtrl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5);
 
40215
    wxPyEndAllowThreads(__tstate);
 
40216
    if (PyErr_Occurred()) SWIG_fail;
 
40217
  }
 
40218
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDirFilterListCtrl, SWIG_POINTER_NEW |  0 );
 
40219
  return resultobj;
 
40220
fail:
 
40221
  return NULL;
 
40222
}
 
40223
 
 
40224
 
 
40225
SWIGINTERN PyObject *_wrap_new_PreDirFilterListCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40226
  PyObject *resultobj = 0;
 
40227
  wxDirFilterListCtrl *result = 0 ;
 
40228
  
 
40229
  if (!SWIG_Python_UnpackTuple(args,"new_PreDirFilterListCtrl",0,0,0)) SWIG_fail;
 
40230
  {
 
40231
    if (!wxPyCheckForApp()) SWIG_fail;
 
40232
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40233
    result = (wxDirFilterListCtrl *)new wxDirFilterListCtrl();
 
40234
    wxPyEndAllowThreads(__tstate);
 
40235
    if (PyErr_Occurred()) SWIG_fail;
 
40236
  }
 
40237
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDirFilterListCtrl, SWIG_POINTER_OWN |  0 );
 
40238
  return resultobj;
 
40239
fail:
 
40240
  return NULL;
 
40241
}
 
40242
 
 
40243
 
 
40244
SWIGINTERN PyObject *_wrap_DirFilterListCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40245
  PyObject *resultobj = 0;
 
40246
  wxDirFilterListCtrl *arg1 = (wxDirFilterListCtrl *) 0 ;
 
40247
  wxGenericDirCtrl *arg2 = (wxGenericDirCtrl *) 0 ;
 
40248
  int arg3 = (int) (int)-1 ;
 
40249
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
40250
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
40251
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
40252
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
40253
  long arg6 = (long) 0 ;
 
40254
  bool result;
 
40255
  void *argp1 = 0 ;
 
40256
  int res1 = 0 ;
 
40257
  void *argp2 = 0 ;
 
40258
  int res2 = 0 ;
 
40259
  int val3 ;
 
40260
  int ecode3 = 0 ;
 
40261
  wxPoint temp4 ;
 
40262
  wxSize temp5 ;
 
40263
  long val6 ;
 
40264
  int ecode6 = 0 ;
 
40265
  PyObject * obj0 = 0 ;
 
40266
  PyObject * obj1 = 0 ;
 
40267
  PyObject * obj2 = 0 ;
 
40268
  PyObject * obj3 = 0 ;
 
40269
  PyObject * obj4 = 0 ;
 
40270
  PyObject * obj5 = 0 ;
 
40271
  char *  kwnames[] = {
 
40272
    (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL 
 
40273
  };
 
40274
  
 
40275
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:DirFilterListCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
40276
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDirFilterListCtrl, 0 |  0 );
 
40277
  if (!SWIG_IsOK(res1)) {
 
40278
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirFilterListCtrl_Create" "', expected argument " "1"" of type '" "wxDirFilterListCtrl *""'"); 
 
40279
  }
 
40280
  arg1 = reinterpret_cast< wxDirFilterListCtrl * >(argp1);
 
40281
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGenericDirCtrl, 0 |  0 );
 
40282
  if (!SWIG_IsOK(res2)) {
 
40283
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DirFilterListCtrl_Create" "', expected argument " "2"" of type '" "wxGenericDirCtrl *""'"); 
 
40284
  }
 
40285
  arg2 = reinterpret_cast< wxGenericDirCtrl * >(argp2);
 
40286
  if (obj2) {
 
40287
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
40288
    if (!SWIG_IsOK(ecode3)) {
 
40289
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirFilterListCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
40290
    } 
 
40291
    arg3 = static_cast< int >(val3);
 
40292
  }
 
40293
  if (obj3) {
 
40294
    {
 
40295
      arg4 = &temp4;
 
40296
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
40297
    }
 
40298
  }
 
40299
  if (obj4) {
 
40300
    {
 
40301
      arg5 = &temp5;
 
40302
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
40303
    }
 
40304
  }
 
40305
  if (obj5) {
 
40306
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
40307
    if (!SWIG_IsOK(ecode6)) {
 
40308
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DirFilterListCtrl_Create" "', expected argument " "6"" of type '" "long""'");
 
40309
    } 
 
40310
    arg6 = static_cast< long >(val6);
 
40311
  }
 
40312
  {
 
40313
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40314
    result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6);
 
40315
    wxPyEndAllowThreads(__tstate);
 
40316
    if (PyErr_Occurred()) SWIG_fail;
 
40317
  }
 
40318
  {
 
40319
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
40320
  }
 
40321
  return resultobj;
 
40322
fail:
 
40323
  return NULL;
 
40324
}
 
40325
 
 
40326
 
 
40327
SWIGINTERN PyObject *_wrap_DirFilterListCtrl_FillFilterList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40328
  PyObject *resultobj = 0;
 
40329
  wxDirFilterListCtrl *arg1 = (wxDirFilterListCtrl *) 0 ;
 
40330
  wxString *arg2 = 0 ;
 
40331
  int arg3 ;
 
40332
  void *argp1 = 0 ;
 
40333
  int res1 = 0 ;
 
40334
  bool temp2 = false ;
 
40335
  int val3 ;
 
40336
  int ecode3 = 0 ;
 
40337
  PyObject * obj0 = 0 ;
 
40338
  PyObject * obj1 = 0 ;
 
40339
  PyObject * obj2 = 0 ;
 
40340
  char *  kwnames[] = {
 
40341
    (char *) "self",(char *) "filter",(char *) "defaultFilter", NULL 
 
40342
  };
 
40343
  
 
40344
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DirFilterListCtrl_FillFilterList",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
40345
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDirFilterListCtrl, 0 |  0 );
 
40346
  if (!SWIG_IsOK(res1)) {
 
40347
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirFilterListCtrl_FillFilterList" "', expected argument " "1"" of type '" "wxDirFilterListCtrl *""'"); 
 
40348
  }
 
40349
  arg1 = reinterpret_cast< wxDirFilterListCtrl * >(argp1);
 
40350
  {
 
40351
    arg2 = wxString_in_helper(obj1);
 
40352
    if (arg2 == NULL) SWIG_fail;
 
40353
    temp2 = true;
 
40354
  }
 
40355
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
40356
  if (!SWIG_IsOK(ecode3)) {
 
40357
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirFilterListCtrl_FillFilterList" "', expected argument " "3"" of type '" "int""'");
 
40358
  } 
 
40359
  arg3 = static_cast< int >(val3);
 
40360
  {
 
40361
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40362
    (arg1)->FillFilterList((wxString const &)*arg2,arg3);
 
40363
    wxPyEndAllowThreads(__tstate);
 
40364
    if (PyErr_Occurred()) SWIG_fail;
 
40365
  }
 
40366
  resultobj = SWIG_Py_Void();
 
40367
  {
 
40368
    if (temp2)
 
40369
    delete arg2;
 
40370
  }
 
40371
  return resultobj;
 
40372
fail:
 
40373
  {
 
40374
    if (temp2)
 
40375
    delete arg2;
 
40376
  }
 
40377
  return NULL;
 
40378
}
 
40379
 
 
40380
 
 
40381
SWIGINTERN PyObject *DirFilterListCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40382
  PyObject *obj;
 
40383
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
40384
  SWIG_TypeNewClientData(SWIGTYPE_p_wxDirFilterListCtrl, SWIG_NewClientData(obj));
 
40385
  return SWIG_Py_Void();
 
40386
}
 
40387
 
 
40388
SWIGINTERN PyObject *DirFilterListCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40389
  return SWIG_Python_InitShadowInstance(args);
 
40390
}
 
40391
 
 
40392
SWIGINTERN PyObject *_wrap_new_PyControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40393
  PyObject *resultobj = 0;
 
40394
  wxWindow *arg1 = (wxWindow *) 0 ;
 
40395
  int arg2 = (int) (int)-1 ;
 
40396
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
40397
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
40398
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
40399
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
40400
  long arg5 = (long) 0 ;
 
40401
  wxValidator const &arg6_defvalue = wxDefaultValidator ;
 
40402
  wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
 
40403
  wxString const &arg7_defvalue = wxPyControlNameStr ;
 
40404
  wxString *arg7 = (wxString *) &arg7_defvalue ;
 
40405
  wxPyControl *result = 0 ;
 
40406
  void *argp1 = 0 ;
 
40407
  int res1 = 0 ;
 
40408
  int val2 ;
 
40409
  int ecode2 = 0 ;
 
40410
  wxPoint temp3 ;
 
40411
  wxSize temp4 ;
 
40412
  long val5 ;
 
40413
  int ecode5 = 0 ;
 
40414
  void *argp6 = 0 ;
 
40415
  int res6 = 0 ;
 
40416
  bool temp7 = false ;
 
40417
  PyObject * obj0 = 0 ;
 
40418
  PyObject * obj1 = 0 ;
 
40419
  PyObject * obj2 = 0 ;
 
40420
  PyObject * obj3 = 0 ;
 
40421
  PyObject * obj4 = 0 ;
 
40422
  PyObject * obj5 = 0 ;
 
40423
  PyObject * obj6 = 0 ;
 
40424
  char *  kwnames[] = {
 
40425
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
40426
  };
 
40427
  
 
40428
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_PyControl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
 
40429
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
40430
  if (!SWIG_IsOK(res1)) {
 
40431
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyControl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
40432
  }
 
40433
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
40434
  if (obj1) {
 
40435
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
40436
    if (!SWIG_IsOK(ecode2)) {
 
40437
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyControl" "', expected argument " "2"" of type '" "int""'");
 
40438
    } 
 
40439
    arg2 = static_cast< int >(val2);
 
40440
  }
 
40441
  if (obj2) {
 
40442
    {
 
40443
      arg3 = &temp3;
 
40444
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
40445
    }
 
40446
  }
 
40447
  if (obj3) {
 
40448
    {
 
40449
      arg4 = &temp4;
 
40450
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
40451
    }
 
40452
  }
 
40453
  if (obj4) {
 
40454
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
40455
    if (!SWIG_IsOK(ecode5)) {
 
40456
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PyControl" "', expected argument " "5"" of type '" "long""'");
 
40457
    } 
 
40458
    arg5 = static_cast< long >(val5);
 
40459
  }
 
40460
  if (obj5) {
 
40461
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator,  0  | 0);
 
40462
    if (!SWIG_IsOK(res6)) {
 
40463
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PyControl" "', expected argument " "6"" of type '" "wxValidator const &""'"); 
 
40464
    }
 
40465
    if (!argp6) {
 
40466
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyControl" "', expected argument " "6"" of type '" "wxValidator const &""'"); 
 
40467
    }
 
40468
    arg6 = reinterpret_cast< wxValidator * >(argp6);
 
40469
  }
 
40470
  if (obj6) {
 
40471
    {
 
40472
      arg7 = wxString_in_helper(obj6);
 
40473
      if (arg7 == NULL) SWIG_fail;
 
40474
      temp7 = true;
 
40475
    }
 
40476
  }
 
40477
  {
 
40478
    if (!wxPyCheckForApp()) SWIG_fail;
 
40479
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40480
    result = (wxPyControl *)new wxPyControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
 
40481
    wxPyEndAllowThreads(__tstate);
 
40482
    if (PyErr_Occurred()) SWIG_fail;
 
40483
  }
 
40484
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyControl, SWIG_POINTER_NEW |  0 );
 
40485
  {
 
40486
    if (temp7)
 
40487
    delete arg7;
 
40488
  }
 
40489
  return resultobj;
 
40490
fail:
 
40491
  {
 
40492
    if (temp7)
 
40493
    delete arg7;
 
40494
  }
 
40495
  return NULL;
 
40496
}
 
40497
 
 
40498
 
 
40499
SWIGINTERN PyObject *_wrap_new_PrePyControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40500
  PyObject *resultobj = 0;
 
40501
  wxPyControl *result = 0 ;
 
40502
  
 
40503
  if (!SWIG_Python_UnpackTuple(args,"new_PrePyControl",0,0,0)) SWIG_fail;
 
40504
  {
 
40505
    if (!wxPyCheckForApp()) SWIG_fail;
 
40506
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40507
    result = (wxPyControl *)new wxPyControl();
 
40508
    wxPyEndAllowThreads(__tstate);
 
40509
    if (PyErr_Occurred()) SWIG_fail;
 
40510
  }
 
40511
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyControl, SWIG_POINTER_OWN |  0 );
 
40512
  return resultobj;
 
40513
fail:
 
40514
  return NULL;
 
40515
}
 
40516
 
 
40517
 
 
40518
SWIGINTERN PyObject *_wrap_PyControl__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40519
  PyObject *resultobj = 0;
 
40520
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
40521
  PyObject *arg2 = (PyObject *) 0 ;
 
40522
  PyObject *arg3 = (PyObject *) 0 ;
 
40523
  void *argp1 = 0 ;
 
40524
  int res1 = 0 ;
 
40525
  PyObject * obj0 = 0 ;
 
40526
  PyObject * obj1 = 0 ;
 
40527
  PyObject * obj2 = 0 ;
 
40528
  char *  kwnames[] = {
 
40529
    (char *) "self",(char *) "self",(char *) "_class", NULL 
 
40530
  };
 
40531
  
 
40532
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyControl__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
40533
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
40534
  if (!SWIG_IsOK(res1)) {
 
40535
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyControl *""'"); 
 
40536
  }
 
40537
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
40538
  arg2 = obj1;
 
40539
  arg3 = obj2;
 
40540
  {
 
40541
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40542
    (arg1)->_setCallbackInfo(arg2,arg3);
 
40543
    wxPyEndAllowThreads(__tstate);
 
40544
    if (PyErr_Occurred()) SWIG_fail;
 
40545
  }
 
40546
  resultobj = SWIG_Py_Void();
 
40547
  return resultobj;
 
40548
fail:
 
40549
  return NULL;
 
40550
}
 
40551
 
 
40552
 
 
40553
SWIGINTERN PyObject *_wrap_PyControl_DoEraseBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40554
  PyObject *resultobj = 0;
 
40555
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
40556
  wxDC *arg2 = (wxDC *) 0 ;
 
40557
  bool result;
 
40558
  void *argp1 = 0 ;
 
40559
  int res1 = 0 ;
 
40560
  void *argp2 = 0 ;
 
40561
  int res2 = 0 ;
 
40562
  PyObject * obj0 = 0 ;
 
40563
  PyObject * obj1 = 0 ;
 
40564
  char *  kwnames[] = {
 
40565
    (char *) "self",(char *) "dc", NULL 
 
40566
  };
 
40567
  
 
40568
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyControl_DoEraseBackground",kwnames,&obj0,&obj1)) SWIG_fail;
 
40569
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
40570
  if (!SWIG_IsOK(res1)) {
 
40571
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_DoEraseBackground" "', expected argument " "1"" of type '" "wxPyControl *""'"); 
 
40572
  }
 
40573
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
40574
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 |  0 );
 
40575
  if (!SWIG_IsOK(res2)) {
 
40576
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyControl_DoEraseBackground" "', expected argument " "2"" of type '" "wxDC *""'"); 
 
40577
  }
 
40578
  arg2 = reinterpret_cast< wxDC * >(argp2);
 
40579
  {
 
40580
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40581
    result = (bool)(arg1)->DoEraseBackground(arg2);
 
40582
    wxPyEndAllowThreads(__tstate);
 
40583
    if (PyErr_Occurred()) SWIG_fail;
 
40584
  }
 
40585
  {
 
40586
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
40587
  }
 
40588
  return resultobj;
 
40589
fail:
 
40590
  return NULL;
 
40591
}
 
40592
 
 
40593
 
 
40594
SWIGINTERN PyObject *_wrap_PyControl_DoMoveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40595
  PyObject *resultobj = 0;
 
40596
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
40597
  int arg2 ;
 
40598
  int arg3 ;
 
40599
  int arg4 ;
 
40600
  int arg5 ;
 
40601
  void *argp1 = 0 ;
 
40602
  int res1 = 0 ;
 
40603
  int val2 ;
 
40604
  int ecode2 = 0 ;
 
40605
  int val3 ;
 
40606
  int ecode3 = 0 ;
 
40607
  int val4 ;
 
40608
  int ecode4 = 0 ;
 
40609
  int val5 ;
 
40610
  int ecode5 = 0 ;
 
40611
  PyObject * obj0 = 0 ;
 
40612
  PyObject * obj1 = 0 ;
 
40613
  PyObject * obj2 = 0 ;
 
40614
  PyObject * obj3 = 0 ;
 
40615
  PyObject * obj4 = 0 ;
 
40616
  char *  kwnames[] = {
 
40617
    (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL 
 
40618
  };
 
40619
  
 
40620
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PyControl_DoMoveWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
40621
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
40622
  if (!SWIG_IsOK(res1)) {
 
40623
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_DoMoveWindow" "', expected argument " "1"" of type '" "wxPyControl *""'"); 
 
40624
  }
 
40625
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
40626
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
40627
  if (!SWIG_IsOK(ecode2)) {
 
40628
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyControl_DoMoveWindow" "', expected argument " "2"" of type '" "int""'");
 
40629
  } 
 
40630
  arg2 = static_cast< int >(val2);
 
40631
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
40632
  if (!SWIG_IsOK(ecode3)) {
 
40633
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyControl_DoMoveWindow" "', expected argument " "3"" of type '" "int""'");
 
40634
  } 
 
40635
  arg3 = static_cast< int >(val3);
 
40636
  ecode4 = SWIG_AsVal_int(obj3, &val4);
 
40637
  if (!SWIG_IsOK(ecode4)) {
 
40638
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyControl_DoMoveWindow" "', expected argument " "4"" of type '" "int""'");
 
40639
  } 
 
40640
  arg4 = static_cast< int >(val4);
 
40641
  ecode5 = SWIG_AsVal_int(obj4, &val5);
 
40642
  if (!SWIG_IsOK(ecode5)) {
 
40643
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PyControl_DoMoveWindow" "', expected argument " "5"" of type '" "int""'");
 
40644
  } 
 
40645
  arg5 = static_cast< int >(val5);
 
40646
  {
 
40647
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40648
    (arg1)->DoMoveWindow(arg2,arg3,arg4,arg5);
 
40649
    wxPyEndAllowThreads(__tstate);
 
40650
    if (PyErr_Occurred()) SWIG_fail;
 
40651
  }
 
40652
  resultobj = SWIG_Py_Void();
 
40653
  return resultobj;
 
40654
fail:
 
40655
  return NULL;
 
40656
}
 
40657
 
 
40658
 
 
40659
SWIGINTERN PyObject *_wrap_PyControl_DoSetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40660
  PyObject *resultobj = 0;
 
40661
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
40662
  int arg2 ;
 
40663
  int arg3 ;
 
40664
  int arg4 ;
 
40665
  int arg5 ;
 
40666
  int arg6 = (int) wxSIZE_AUTO ;
 
40667
  void *argp1 = 0 ;
 
40668
  int res1 = 0 ;
 
40669
  int val2 ;
 
40670
  int ecode2 = 0 ;
 
40671
  int val3 ;
 
40672
  int ecode3 = 0 ;
 
40673
  int val4 ;
 
40674
  int ecode4 = 0 ;
 
40675
  int val5 ;
 
40676
  int ecode5 = 0 ;
 
40677
  int val6 ;
 
40678
  int ecode6 = 0 ;
 
40679
  PyObject * obj0 = 0 ;
 
40680
  PyObject * obj1 = 0 ;
 
40681
  PyObject * obj2 = 0 ;
 
40682
  PyObject * obj3 = 0 ;
 
40683
  PyObject * obj4 = 0 ;
 
40684
  PyObject * obj5 = 0 ;
 
40685
  char *  kwnames[] = {
 
40686
    (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL 
 
40687
  };
 
40688
  
 
40689
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:PyControl_DoSetSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
 
40690
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
40691
  if (!SWIG_IsOK(res1)) {
 
40692
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_DoSetSize" "', expected argument " "1"" of type '" "wxPyControl *""'"); 
 
40693
  }
 
40694
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
40695
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
40696
  if (!SWIG_IsOK(ecode2)) {
 
40697
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyControl_DoSetSize" "', expected argument " "2"" of type '" "int""'");
 
40698
  } 
 
40699
  arg2 = static_cast< int >(val2);
 
40700
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
40701
  if (!SWIG_IsOK(ecode3)) {
 
40702
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyControl_DoSetSize" "', expected argument " "3"" of type '" "int""'");
 
40703
  } 
 
40704
  arg3 = static_cast< int >(val3);
 
40705
  ecode4 = SWIG_AsVal_int(obj3, &val4);
 
40706
  if (!SWIG_IsOK(ecode4)) {
 
40707
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyControl_DoSetSize" "', expected argument " "4"" of type '" "int""'");
 
40708
  } 
 
40709
  arg4 = static_cast< int >(val4);
 
40710
  ecode5 = SWIG_AsVal_int(obj4, &val5);
 
40711
  if (!SWIG_IsOK(ecode5)) {
 
40712
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PyControl_DoSetSize" "', expected argument " "5"" of type '" "int""'");
 
40713
  } 
 
40714
  arg5 = static_cast< int >(val5);
 
40715
  if (obj5) {
 
40716
    ecode6 = SWIG_AsVal_int(obj5, &val6);
 
40717
    if (!SWIG_IsOK(ecode6)) {
 
40718
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PyControl_DoSetSize" "', expected argument " "6"" of type '" "int""'");
 
40719
    } 
 
40720
    arg6 = static_cast< int >(val6);
 
40721
  }
 
40722
  {
 
40723
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40724
    (arg1)->DoSetSize(arg2,arg3,arg4,arg5,arg6);
 
40725
    wxPyEndAllowThreads(__tstate);
 
40726
    if (PyErr_Occurred()) SWIG_fail;
 
40727
  }
 
40728
  resultobj = SWIG_Py_Void();
 
40729
  return resultobj;
 
40730
fail:
 
40731
  return NULL;
 
40732
}
 
40733
 
 
40734
 
 
40735
SWIGINTERN PyObject *_wrap_PyControl_DoSetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40736
  PyObject *resultobj = 0;
 
40737
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
40738
  int arg2 ;
 
40739
  int arg3 ;
 
40740
  void *argp1 = 0 ;
 
40741
  int res1 = 0 ;
 
40742
  int val2 ;
 
40743
  int ecode2 = 0 ;
 
40744
  int val3 ;
 
40745
  int ecode3 = 0 ;
 
40746
  PyObject * obj0 = 0 ;
 
40747
  PyObject * obj1 = 0 ;
 
40748
  PyObject * obj2 = 0 ;
 
40749
  char *  kwnames[] = {
 
40750
    (char *) "self",(char *) "width",(char *) "height", NULL 
 
40751
  };
 
40752
  
 
40753
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyControl_DoSetClientSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
40754
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
40755
  if (!SWIG_IsOK(res1)) {
 
40756
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_DoSetClientSize" "', expected argument " "1"" of type '" "wxPyControl *""'"); 
 
40757
  }
 
40758
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
40759
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
40760
  if (!SWIG_IsOK(ecode2)) {
 
40761
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyControl_DoSetClientSize" "', expected argument " "2"" of type '" "int""'");
 
40762
  } 
 
40763
  arg2 = static_cast< int >(val2);
 
40764
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
40765
  if (!SWIG_IsOK(ecode3)) {
 
40766
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyControl_DoSetClientSize" "', expected argument " "3"" of type '" "int""'");
 
40767
  } 
 
40768
  arg3 = static_cast< int >(val3);
 
40769
  {
 
40770
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40771
    (arg1)->DoSetClientSize(arg2,arg3);
 
40772
    wxPyEndAllowThreads(__tstate);
 
40773
    if (PyErr_Occurred()) SWIG_fail;
 
40774
  }
 
40775
  resultobj = SWIG_Py_Void();
 
40776
  return resultobj;
 
40777
fail:
 
40778
  return NULL;
 
40779
}
 
40780
 
 
40781
 
 
40782
SWIGINTERN PyObject *_wrap_PyControl_DoSetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
40783
  PyObject *resultobj = 0;
 
40784
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
40785
  int arg2 ;
 
40786
  int arg3 ;
 
40787
  void *argp1 = 0 ;
 
40788
  int res1 = 0 ;
 
40789
  int val2 ;
 
40790
  int ecode2 = 0 ;
 
40791
  int val3 ;
 
40792
  int ecode3 = 0 ;
 
40793
  PyObject * obj0 = 0 ;
 
40794
  PyObject * obj1 = 0 ;
 
40795
  PyObject * obj2 = 0 ;
 
40796
  char *  kwnames[] = {
 
40797
    (char *) "self",(char *) "x",(char *) "y", NULL 
 
40798
  };
 
40799
  
 
40800
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyControl_DoSetVirtualSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
40801
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
40802
  if (!SWIG_IsOK(res1)) {
 
40803
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_DoSetVirtualSize" "', expected argument " "1"" of type '" "wxPyControl *""'"); 
 
40804
  }
 
40805
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
40806
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
40807
  if (!SWIG_IsOK(ecode2)) {
 
40808
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyControl_DoSetVirtualSize" "', expected argument " "2"" of type '" "int""'");
 
40809
  } 
 
40810
  arg2 = static_cast< int >(val2);
 
40811
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
40812
  if (!SWIG_IsOK(ecode3)) {
 
40813
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyControl_DoSetVirtualSize" "', expected argument " "3"" of type '" "int""'");
 
40814
  } 
 
40815
  arg3 = static_cast< int >(val3);
 
40816
  {
 
40817
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40818
    (arg1)->DoSetVirtualSize(arg2,arg3);
 
40819
    wxPyEndAllowThreads(__tstate);
 
40820
    if (PyErr_Occurred()) SWIG_fail;
 
40821
  }
 
40822
  resultobj = SWIG_Py_Void();
 
40823
  return resultobj;
 
40824
fail:
 
40825
  return NULL;
 
40826
}
 
40827
 
 
40828
 
 
40829
SWIGINTERN PyObject *_wrap_PyControl_DoGetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40830
  PyObject *resultobj = 0;
 
40831
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
40832
  int *arg2 = (int *) 0 ;
 
40833
  int *arg3 = (int *) 0 ;
 
40834
  void *argp1 = 0 ;
 
40835
  int res1 = 0 ;
 
40836
  int temp2 ;
 
40837
  int res2 = SWIG_TMPOBJ ;
 
40838
  int temp3 ;
 
40839
  int res3 = SWIG_TMPOBJ ;
 
40840
  PyObject *swig_obj[1] ;
 
40841
  
 
40842
  arg2 = &temp2;
 
40843
  arg3 = &temp3;
 
40844
  if (!args) SWIG_fail;
 
40845
  swig_obj[0] = args;
 
40846
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
40847
  if (!SWIG_IsOK(res1)) {
 
40848
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_DoGetSize" "', expected argument " "1"" of type '" "wxPyControl const *""'"); 
 
40849
  }
 
40850
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
40851
  {
 
40852
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40853
    ((wxPyControl const *)arg1)->DoGetSize(arg2,arg3);
 
40854
    wxPyEndAllowThreads(__tstate);
 
40855
    if (PyErr_Occurred()) SWIG_fail;
 
40856
  }
 
40857
  resultobj = SWIG_Py_Void();
 
40858
  if (SWIG_IsTmpObj(res2)) {
 
40859
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
 
40860
  } else {
 
40861
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
40862
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
 
40863
  }
 
40864
  if (SWIG_IsTmpObj(res3)) {
 
40865
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
 
40866
  } else {
 
40867
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
40868
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
 
40869
  }
 
40870
  return resultobj;
 
40871
fail:
 
40872
  return NULL;
 
40873
}
 
40874
 
 
40875
 
 
40876
SWIGINTERN PyObject *_wrap_PyControl_DoGetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40877
  PyObject *resultobj = 0;
 
40878
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
40879
  int *arg2 = (int *) 0 ;
 
40880
  int *arg3 = (int *) 0 ;
 
40881
  void *argp1 = 0 ;
 
40882
  int res1 = 0 ;
 
40883
  int temp2 ;
 
40884
  int res2 = SWIG_TMPOBJ ;
 
40885
  int temp3 ;
 
40886
  int res3 = SWIG_TMPOBJ ;
 
40887
  PyObject *swig_obj[1] ;
 
40888
  
 
40889
  arg2 = &temp2;
 
40890
  arg3 = &temp3;
 
40891
  if (!args) SWIG_fail;
 
40892
  swig_obj[0] = args;
 
40893
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
40894
  if (!SWIG_IsOK(res1)) {
 
40895
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_DoGetClientSize" "', expected argument " "1"" of type '" "wxPyControl const *""'"); 
 
40896
  }
 
40897
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
40898
  {
 
40899
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40900
    ((wxPyControl const *)arg1)->DoGetClientSize(arg2,arg3);
 
40901
    wxPyEndAllowThreads(__tstate);
 
40902
    if (PyErr_Occurred()) SWIG_fail;
 
40903
  }
 
40904
  resultobj = SWIG_Py_Void();
 
40905
  if (SWIG_IsTmpObj(res2)) {
 
40906
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
 
40907
  } else {
 
40908
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
40909
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
 
40910
  }
 
40911
  if (SWIG_IsTmpObj(res3)) {
 
40912
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
 
40913
  } else {
 
40914
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
40915
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
 
40916
  }
 
40917
  return resultobj;
 
40918
fail:
 
40919
  return NULL;
 
40920
}
 
40921
 
 
40922
 
 
40923
SWIGINTERN PyObject *_wrap_PyControl_DoGetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40924
  PyObject *resultobj = 0;
 
40925
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
40926
  int *arg2 = (int *) 0 ;
 
40927
  int *arg3 = (int *) 0 ;
 
40928
  void *argp1 = 0 ;
 
40929
  int res1 = 0 ;
 
40930
  int temp2 ;
 
40931
  int res2 = SWIG_TMPOBJ ;
 
40932
  int temp3 ;
 
40933
  int res3 = SWIG_TMPOBJ ;
 
40934
  PyObject *swig_obj[1] ;
 
40935
  
 
40936
  arg2 = &temp2;
 
40937
  arg3 = &temp3;
 
40938
  if (!args) SWIG_fail;
 
40939
  swig_obj[0] = args;
 
40940
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
40941
  if (!SWIG_IsOK(res1)) {
 
40942
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_DoGetPosition" "', expected argument " "1"" of type '" "wxPyControl const *""'"); 
 
40943
  }
 
40944
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
40945
  {
 
40946
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40947
    ((wxPyControl const *)arg1)->DoGetPosition(arg2,arg3);
 
40948
    wxPyEndAllowThreads(__tstate);
 
40949
    if (PyErr_Occurred()) SWIG_fail;
 
40950
  }
 
40951
  resultobj = SWIG_Py_Void();
 
40952
  if (SWIG_IsTmpObj(res2)) {
 
40953
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
 
40954
  } else {
 
40955
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
40956
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
 
40957
  }
 
40958
  if (SWIG_IsTmpObj(res3)) {
 
40959
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
 
40960
  } else {
 
40961
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
 
40962
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
 
40963
  }
 
40964
  return resultobj;
 
40965
fail:
 
40966
  return NULL;
 
40967
}
 
40968
 
 
40969
 
 
40970
SWIGINTERN PyObject *_wrap_PyControl_DoGetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40971
  PyObject *resultobj = 0;
 
40972
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
40973
  wxSize result;
 
40974
  void *argp1 = 0 ;
 
40975
  int res1 = 0 ;
 
40976
  PyObject *swig_obj[1] ;
 
40977
  
 
40978
  if (!args) SWIG_fail;
 
40979
  swig_obj[0] = args;
 
40980
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
40981
  if (!SWIG_IsOK(res1)) {
 
40982
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_DoGetVirtualSize" "', expected argument " "1"" of type '" "wxPyControl const *""'"); 
 
40983
  }
 
40984
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
40985
  {
 
40986
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
40987
    result = ((wxPyControl const *)arg1)->DoGetVirtualSize();
 
40988
    wxPyEndAllowThreads(__tstate);
 
40989
    if (PyErr_Occurred()) SWIG_fail;
 
40990
  }
 
40991
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
40992
  return resultobj;
 
40993
fail:
 
40994
  return NULL;
 
40995
}
 
40996
 
 
40997
 
 
40998
SWIGINTERN PyObject *_wrap_PyControl_DoGetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
40999
  PyObject *resultobj = 0;
 
41000
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
41001
  wxSize result;
 
41002
  void *argp1 = 0 ;
 
41003
  int res1 = 0 ;
 
41004
  PyObject *swig_obj[1] ;
 
41005
  
 
41006
  if (!args) SWIG_fail;
 
41007
  swig_obj[0] = args;
 
41008
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
41009
  if (!SWIG_IsOK(res1)) {
 
41010
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_DoGetBestSize" "', expected argument " "1"" of type '" "wxPyControl const *""'"); 
 
41011
  }
 
41012
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
41013
  {
 
41014
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41015
    result = ((wxPyControl const *)arg1)->DoGetBestSize();
 
41016
    wxPyEndAllowThreads(__tstate);
 
41017
    if (PyErr_Occurred()) SWIG_fail;
 
41018
  }
 
41019
  resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN |  0 );
 
41020
  return resultobj;
 
41021
fail:
 
41022
  return NULL;
 
41023
}
 
41024
 
 
41025
 
 
41026
SWIGINTERN PyObject *_wrap_PyControl_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41027
  PyObject *resultobj = 0;
 
41028
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
41029
  SwigValueWrapper<wxVisualAttributes > result;
 
41030
  void *argp1 = 0 ;
 
41031
  int res1 = 0 ;
 
41032
  PyObject *swig_obj[1] ;
 
41033
  
 
41034
  if (!args) SWIG_fail;
 
41035
  swig_obj[0] = args;
 
41036
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
41037
  if (!SWIG_IsOK(res1)) {
 
41038
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxPyControl *""'"); 
 
41039
  }
 
41040
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
41041
  {
 
41042
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41043
    result = (arg1)->GetDefaultAttributes();
 
41044
    wxPyEndAllowThreads(__tstate);
 
41045
    if (PyErr_Occurred()) SWIG_fail;
 
41046
  }
 
41047
  resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN |  0 );
 
41048
  return resultobj;
 
41049
fail:
 
41050
  return NULL;
 
41051
}
 
41052
 
 
41053
 
 
41054
SWIGINTERN PyObject *_wrap_PyControl_OnInternalIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41055
  PyObject *resultobj = 0;
 
41056
  wxPyControl *arg1 = (wxPyControl *) 0 ;
 
41057
  void *argp1 = 0 ;
 
41058
  int res1 = 0 ;
 
41059
  PyObject *swig_obj[1] ;
 
41060
  
 
41061
  if (!args) SWIG_fail;
 
41062
  swig_obj[0] = args;
 
41063
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyControl, 0 |  0 );
 
41064
  if (!SWIG_IsOK(res1)) {
 
41065
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyControl_OnInternalIdle" "', expected argument " "1"" of type '" "wxPyControl *""'"); 
 
41066
  }
 
41067
  arg1 = reinterpret_cast< wxPyControl * >(argp1);
 
41068
  {
 
41069
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41070
    (arg1)->OnInternalIdle();
 
41071
    wxPyEndAllowThreads(__tstate);
 
41072
    if (PyErr_Occurred()) SWIG_fail;
 
41073
  }
 
41074
  resultobj = SWIG_Py_Void();
 
41075
  return resultobj;
 
41076
fail:
 
41077
  return NULL;
 
41078
}
 
41079
 
 
41080
 
 
41081
SWIGINTERN PyObject *PyControl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41082
  PyObject *obj;
 
41083
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
41084
  SWIG_TypeNewClientData(SWIGTYPE_p_wxPyControl, SWIG_NewClientData(obj));
 
41085
  return SWIG_Py_Void();
 
41086
}
 
41087
 
 
41088
SWIGINTERN PyObject *PyControl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41089
  return SWIG_Python_InitShadowInstance(args);
 
41090
}
 
41091
 
 
41092
SWIGINTERN PyObject *_wrap_new_HelpEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41093
  PyObject *resultobj = 0;
 
41094
  wxEventType arg1 = (wxEventType) wxEVT_NULL ;
 
41095
  int arg2 = (int) 0 ;
 
41096
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
41097
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
41098
  wxHelpEvent::Origin arg4 = (wxHelpEvent::Origin) wxHelpEvent::Origin_Unknown ;
 
41099
  wxHelpEvent *result = 0 ;
 
41100
  int val1 ;
 
41101
  int ecode1 = 0 ;
 
41102
  int val2 ;
 
41103
  int ecode2 = 0 ;
 
41104
  wxPoint temp3 ;
 
41105
  int val4 ;
 
41106
  int ecode4 = 0 ;
 
41107
  PyObject * obj0 = 0 ;
 
41108
  PyObject * obj1 = 0 ;
 
41109
  PyObject * obj2 = 0 ;
 
41110
  PyObject * obj3 = 0 ;
 
41111
  char *  kwnames[] = {
 
41112
    (char *) "type",(char *) "winid",(char *) "pt",(char *) "origin", NULL 
 
41113
  };
 
41114
  
 
41115
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_HelpEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
41116
  if (obj0) {
 
41117
    ecode1 = SWIG_AsVal_int(obj0, &val1);
 
41118
    if (!SWIG_IsOK(ecode1)) {
 
41119
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelpEvent" "', expected argument " "1"" of type '" "wxEventType""'");
 
41120
    } 
 
41121
    arg1 = static_cast< wxEventType >(val1);
 
41122
  }
 
41123
  if (obj1) {
 
41124
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
41125
    if (!SWIG_IsOK(ecode2)) {
 
41126
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelpEvent" "', expected argument " "2"" of type '" "int""'");
 
41127
    } 
 
41128
    arg2 = static_cast< int >(val2);
 
41129
  }
 
41130
  if (obj2) {
 
41131
    {
 
41132
      arg3 = &temp3;
 
41133
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
41134
    }
 
41135
  }
 
41136
  if (obj3) {
 
41137
    ecode4 = SWIG_AsVal_int(obj3, &val4);
 
41138
    if (!SWIG_IsOK(ecode4)) {
 
41139
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelpEvent" "', expected argument " "4"" of type '" "wxHelpEvent::Origin""'");
 
41140
    } 
 
41141
    arg4 = static_cast< wxHelpEvent::Origin >(val4);
 
41142
  }
 
41143
  {
 
41144
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41145
    result = (wxHelpEvent *)new wxHelpEvent(arg1,arg2,(wxPoint const &)*arg3,arg4);
 
41146
    wxPyEndAllowThreads(__tstate);
 
41147
    if (PyErr_Occurred()) SWIG_fail;
 
41148
  }
 
41149
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxHelpEvent, SWIG_POINTER_NEW |  0 );
 
41150
  return resultobj;
 
41151
fail:
 
41152
  return NULL;
 
41153
}
 
41154
 
 
41155
 
 
41156
SWIGINTERN PyObject *_wrap_HelpEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41157
  PyObject *resultobj = 0;
 
41158
  wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
 
41159
  wxPoint result;
 
41160
  void *argp1 = 0 ;
 
41161
  int res1 = 0 ;
 
41162
  PyObject *swig_obj[1] ;
 
41163
  
 
41164
  if (!args) SWIG_fail;
 
41165
  swig_obj[0] = args;
 
41166
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHelpEvent, 0 |  0 );
 
41167
  if (!SWIG_IsOK(res1)) {
 
41168
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpEvent_GetPosition" "', expected argument " "1"" of type '" "wxHelpEvent const *""'"); 
 
41169
  }
 
41170
  arg1 = reinterpret_cast< wxHelpEvent * >(argp1);
 
41171
  {
 
41172
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41173
    result = ((wxHelpEvent const *)arg1)->GetPosition();
 
41174
    wxPyEndAllowThreads(__tstate);
 
41175
    if (PyErr_Occurred()) SWIG_fail;
 
41176
  }
 
41177
  resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN |  0 );
 
41178
  return resultobj;
 
41179
fail:
 
41180
  return NULL;
 
41181
}
 
41182
 
 
41183
 
 
41184
SWIGINTERN PyObject *_wrap_HelpEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41185
  PyObject *resultobj = 0;
 
41186
  wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
 
41187
  wxPoint *arg2 = 0 ;
 
41188
  void *argp1 = 0 ;
 
41189
  int res1 = 0 ;
 
41190
  wxPoint temp2 ;
 
41191
  PyObject * obj0 = 0 ;
 
41192
  PyObject * obj1 = 0 ;
 
41193
  char *  kwnames[] = {
 
41194
    (char *) "self",(char *) "pos", NULL 
 
41195
  };
 
41196
  
 
41197
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
 
41198
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHelpEvent, 0 |  0 );
 
41199
  if (!SWIG_IsOK(res1)) {
 
41200
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpEvent_SetPosition" "', expected argument " "1"" of type '" "wxHelpEvent *""'"); 
 
41201
  }
 
41202
  arg1 = reinterpret_cast< wxHelpEvent * >(argp1);
 
41203
  {
 
41204
    arg2 = &temp2;
 
41205
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
41206
  }
 
41207
  {
 
41208
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41209
    (arg1)->SetPosition((wxPoint const &)*arg2);
 
41210
    wxPyEndAllowThreads(__tstate);
 
41211
    if (PyErr_Occurred()) SWIG_fail;
 
41212
  }
 
41213
  resultobj = SWIG_Py_Void();
 
41214
  return resultobj;
 
41215
fail:
 
41216
  return NULL;
 
41217
}
 
41218
 
 
41219
 
 
41220
SWIGINTERN PyObject *_wrap_HelpEvent_GetLink(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41221
  PyObject *resultobj = 0;
 
41222
  wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
 
41223
  wxString *result = 0 ;
 
41224
  void *argp1 = 0 ;
 
41225
  int res1 = 0 ;
 
41226
  PyObject *swig_obj[1] ;
 
41227
  
 
41228
  if (!args) SWIG_fail;
 
41229
  swig_obj[0] = args;
 
41230
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHelpEvent, 0 |  0 );
 
41231
  if (!SWIG_IsOK(res1)) {
 
41232
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpEvent_GetLink" "', expected argument " "1"" of type '" "wxHelpEvent const *""'"); 
 
41233
  }
 
41234
  arg1 = reinterpret_cast< wxHelpEvent * >(argp1);
 
41235
  {
 
41236
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41237
    {
 
41238
      wxString const &_result_ref = ((wxHelpEvent const *)arg1)->GetLink();
 
41239
      result = (wxString *) &_result_ref;
 
41240
    }
 
41241
    wxPyEndAllowThreads(__tstate);
 
41242
    if (PyErr_Occurred()) SWIG_fail;
 
41243
  }
 
41244
  {
 
41245
#if wxUSE_UNICODE
 
41246
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
41247
#else
 
41248
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
41249
#endif
 
41250
  }
 
41251
  return resultobj;
 
41252
fail:
 
41253
  return NULL;
 
41254
}
 
41255
 
 
41256
 
 
41257
SWIGINTERN PyObject *_wrap_HelpEvent_SetLink(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41258
  PyObject *resultobj = 0;
 
41259
  wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
 
41260
  wxString *arg2 = 0 ;
 
41261
  void *argp1 = 0 ;
 
41262
  int res1 = 0 ;
 
41263
  bool temp2 = false ;
 
41264
  PyObject * obj0 = 0 ;
 
41265
  PyObject * obj1 = 0 ;
 
41266
  char *  kwnames[] = {
 
41267
    (char *) "self",(char *) "link", NULL 
 
41268
  };
 
41269
  
 
41270
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpEvent_SetLink",kwnames,&obj0,&obj1)) SWIG_fail;
 
41271
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHelpEvent, 0 |  0 );
 
41272
  if (!SWIG_IsOK(res1)) {
 
41273
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpEvent_SetLink" "', expected argument " "1"" of type '" "wxHelpEvent *""'"); 
 
41274
  }
 
41275
  arg1 = reinterpret_cast< wxHelpEvent * >(argp1);
 
41276
  {
 
41277
    arg2 = wxString_in_helper(obj1);
 
41278
    if (arg2 == NULL) SWIG_fail;
 
41279
    temp2 = true;
 
41280
  }
 
41281
  {
 
41282
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41283
    (arg1)->SetLink((wxString const &)*arg2);
 
41284
    wxPyEndAllowThreads(__tstate);
 
41285
    if (PyErr_Occurred()) SWIG_fail;
 
41286
  }
 
41287
  resultobj = SWIG_Py_Void();
 
41288
  {
 
41289
    if (temp2)
 
41290
    delete arg2;
 
41291
  }
 
41292
  return resultobj;
 
41293
fail:
 
41294
  {
 
41295
    if (temp2)
 
41296
    delete arg2;
 
41297
  }
 
41298
  return NULL;
 
41299
}
 
41300
 
 
41301
 
 
41302
SWIGINTERN PyObject *_wrap_HelpEvent_GetTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41303
  PyObject *resultobj = 0;
 
41304
  wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
 
41305
  wxString *result = 0 ;
 
41306
  void *argp1 = 0 ;
 
41307
  int res1 = 0 ;
 
41308
  PyObject *swig_obj[1] ;
 
41309
  
 
41310
  if (!args) SWIG_fail;
 
41311
  swig_obj[0] = args;
 
41312
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHelpEvent, 0 |  0 );
 
41313
  if (!SWIG_IsOK(res1)) {
 
41314
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpEvent_GetTarget" "', expected argument " "1"" of type '" "wxHelpEvent const *""'"); 
 
41315
  }
 
41316
  arg1 = reinterpret_cast< wxHelpEvent * >(argp1);
 
41317
  {
 
41318
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41319
    {
 
41320
      wxString const &_result_ref = ((wxHelpEvent const *)arg1)->GetTarget();
 
41321
      result = (wxString *) &_result_ref;
 
41322
    }
 
41323
    wxPyEndAllowThreads(__tstate);
 
41324
    if (PyErr_Occurred()) SWIG_fail;
 
41325
  }
 
41326
  {
 
41327
#if wxUSE_UNICODE
 
41328
    resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
 
41329
#else
 
41330
    resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
 
41331
#endif
 
41332
  }
 
41333
  return resultobj;
 
41334
fail:
 
41335
  return NULL;
 
41336
}
 
41337
 
 
41338
 
 
41339
SWIGINTERN PyObject *_wrap_HelpEvent_SetTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41340
  PyObject *resultobj = 0;
 
41341
  wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
 
41342
  wxString *arg2 = 0 ;
 
41343
  void *argp1 = 0 ;
 
41344
  int res1 = 0 ;
 
41345
  bool temp2 = false ;
 
41346
  PyObject * obj0 = 0 ;
 
41347
  PyObject * obj1 = 0 ;
 
41348
  char *  kwnames[] = {
 
41349
    (char *) "self",(char *) "target", NULL 
 
41350
  };
 
41351
  
 
41352
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpEvent_SetTarget",kwnames,&obj0,&obj1)) SWIG_fail;
 
41353
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHelpEvent, 0 |  0 );
 
41354
  if (!SWIG_IsOK(res1)) {
 
41355
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpEvent_SetTarget" "', expected argument " "1"" of type '" "wxHelpEvent *""'"); 
 
41356
  }
 
41357
  arg1 = reinterpret_cast< wxHelpEvent * >(argp1);
 
41358
  {
 
41359
    arg2 = wxString_in_helper(obj1);
 
41360
    if (arg2 == NULL) SWIG_fail;
 
41361
    temp2 = true;
 
41362
  }
 
41363
  {
 
41364
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41365
    (arg1)->SetTarget((wxString const &)*arg2);
 
41366
    wxPyEndAllowThreads(__tstate);
 
41367
    if (PyErr_Occurred()) SWIG_fail;
 
41368
  }
 
41369
  resultobj = SWIG_Py_Void();
 
41370
  {
 
41371
    if (temp2)
 
41372
    delete arg2;
 
41373
  }
 
41374
  return resultobj;
 
41375
fail:
 
41376
  {
 
41377
    if (temp2)
 
41378
    delete arg2;
 
41379
  }
 
41380
  return NULL;
 
41381
}
 
41382
 
 
41383
 
 
41384
SWIGINTERN PyObject *_wrap_HelpEvent_GetOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41385
  PyObject *resultobj = 0;
 
41386
  wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
 
41387
  wxHelpEvent::Origin result;
 
41388
  void *argp1 = 0 ;
 
41389
  int res1 = 0 ;
 
41390
  PyObject *swig_obj[1] ;
 
41391
  
 
41392
  if (!args) SWIG_fail;
 
41393
  swig_obj[0] = args;
 
41394
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHelpEvent, 0 |  0 );
 
41395
  if (!SWIG_IsOK(res1)) {
 
41396
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpEvent_GetOrigin" "', expected argument " "1"" of type '" "wxHelpEvent const *""'"); 
 
41397
  }
 
41398
  arg1 = reinterpret_cast< wxHelpEvent * >(argp1);
 
41399
  {
 
41400
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41401
    result = (wxHelpEvent::Origin)((wxHelpEvent const *)arg1)->GetOrigin();
 
41402
    wxPyEndAllowThreads(__tstate);
 
41403
    if (PyErr_Occurred()) SWIG_fail;
 
41404
  }
 
41405
  resultobj = SWIG_From_int(static_cast< int >(result));
 
41406
  return resultobj;
 
41407
fail:
 
41408
  return NULL;
 
41409
}
 
41410
 
 
41411
 
 
41412
SWIGINTERN PyObject *_wrap_HelpEvent_SetOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41413
  PyObject *resultobj = 0;
 
41414
  wxHelpEvent *arg1 = (wxHelpEvent *) 0 ;
 
41415
  wxHelpEvent::Origin arg2 ;
 
41416
  void *argp1 = 0 ;
 
41417
  int res1 = 0 ;
 
41418
  int val2 ;
 
41419
  int ecode2 = 0 ;
 
41420
  PyObject * obj0 = 0 ;
 
41421
  PyObject * obj1 = 0 ;
 
41422
  char *  kwnames[] = {
 
41423
    (char *) "self",(char *) "origin", NULL 
 
41424
  };
 
41425
  
 
41426
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpEvent_SetOrigin",kwnames,&obj0,&obj1)) SWIG_fail;
 
41427
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHelpEvent, 0 |  0 );
 
41428
  if (!SWIG_IsOK(res1)) {
 
41429
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpEvent_SetOrigin" "', expected argument " "1"" of type '" "wxHelpEvent *""'"); 
 
41430
  }
 
41431
  arg1 = reinterpret_cast< wxHelpEvent * >(argp1);
 
41432
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
41433
  if (!SWIG_IsOK(ecode2)) {
 
41434
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelpEvent_SetOrigin" "', expected argument " "2"" of type '" "wxHelpEvent::Origin""'");
 
41435
  } 
 
41436
  arg2 = static_cast< wxHelpEvent::Origin >(val2);
 
41437
  {
 
41438
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41439
    (arg1)->SetOrigin(arg2);
 
41440
    wxPyEndAllowThreads(__tstate);
 
41441
    if (PyErr_Occurred()) SWIG_fail;
 
41442
  }
 
41443
  resultobj = SWIG_Py_Void();
 
41444
  return resultobj;
 
41445
fail:
 
41446
  return NULL;
 
41447
}
 
41448
 
 
41449
 
 
41450
SWIGINTERN PyObject *HelpEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41451
  PyObject *obj;
 
41452
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
41453
  SWIG_TypeNewClientData(SWIGTYPE_p_wxHelpEvent, SWIG_NewClientData(obj));
 
41454
  return SWIG_Py_Void();
 
41455
}
 
41456
 
 
41457
SWIGINTERN PyObject *HelpEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41458
  return SWIG_Python_InitShadowInstance(args);
 
41459
}
 
41460
 
 
41461
SWIGINTERN PyObject *_wrap_new_ContextHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41462
  PyObject *resultobj = 0;
 
41463
  wxWindow *arg1 = (wxWindow *) NULL ;
 
41464
  bool arg2 = (bool) true ;
 
41465
  wxContextHelp *result = 0 ;
 
41466
  void *argp1 = 0 ;
 
41467
  int res1 = 0 ;
 
41468
  bool val2 ;
 
41469
  int ecode2 = 0 ;
 
41470
  PyObject * obj0 = 0 ;
 
41471
  PyObject * obj1 = 0 ;
 
41472
  char *  kwnames[] = {
 
41473
    (char *) "window",(char *) "doNow", NULL 
 
41474
  };
 
41475
  
 
41476
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ContextHelp",kwnames,&obj0,&obj1)) SWIG_fail;
 
41477
  if (obj0) {
 
41478
    res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
41479
    if (!SWIG_IsOK(res1)) {
 
41480
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContextHelp" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
41481
    }
 
41482
    arg1 = reinterpret_cast< wxWindow * >(argp1);
 
41483
  }
 
41484
  if (obj1) {
 
41485
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
41486
    if (!SWIG_IsOK(ecode2)) {
 
41487
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextHelp" "', expected argument " "2"" of type '" "bool""'");
 
41488
    } 
 
41489
    arg2 = static_cast< bool >(val2);
 
41490
  }
 
41491
  {
 
41492
    if (!wxPyCheckForApp()) SWIG_fail;
 
41493
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41494
    result = (wxContextHelp *)new wxContextHelp(arg1,arg2);
 
41495
    wxPyEndAllowThreads(__tstate);
 
41496
    if (PyErr_Occurred()) SWIG_fail;
 
41497
  }
 
41498
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextHelp, SWIG_POINTER_NEW |  0 );
 
41499
  return resultobj;
 
41500
fail:
 
41501
  return NULL;
 
41502
}
 
41503
 
 
41504
 
 
41505
SWIGINTERN PyObject *_wrap_delete_ContextHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41506
  PyObject *resultobj = 0;
 
41507
  wxContextHelp *arg1 = (wxContextHelp *) 0 ;
 
41508
  void *argp1 = 0 ;
 
41509
  int res1 = 0 ;
 
41510
  PyObject *swig_obj[1] ;
 
41511
  
 
41512
  if (!args) SWIG_fail;
 
41513
  swig_obj[0] = args;
 
41514
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextHelp, SWIG_POINTER_DISOWN |  0 );
 
41515
  if (!SWIG_IsOK(res1)) {
 
41516
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContextHelp" "', expected argument " "1"" of type '" "wxContextHelp *""'"); 
 
41517
  }
 
41518
  arg1 = reinterpret_cast< wxContextHelp * >(argp1);
 
41519
  {
 
41520
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41521
    delete arg1;
 
41522
    
 
41523
    wxPyEndAllowThreads(__tstate);
 
41524
    if (PyErr_Occurred()) SWIG_fail;
 
41525
  }
 
41526
  resultobj = SWIG_Py_Void();
 
41527
  return resultobj;
 
41528
fail:
 
41529
  return NULL;
 
41530
}
 
41531
 
 
41532
 
 
41533
SWIGINTERN PyObject *_wrap_ContextHelp_BeginContextHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41534
  PyObject *resultobj = 0;
 
41535
  wxContextHelp *arg1 = (wxContextHelp *) 0 ;
 
41536
  wxWindow *arg2 = (wxWindow *) NULL ;
 
41537
  bool result;
 
41538
  void *argp1 = 0 ;
 
41539
  int res1 = 0 ;
 
41540
  void *argp2 = 0 ;
 
41541
  int res2 = 0 ;
 
41542
  PyObject * obj0 = 0 ;
 
41543
  PyObject * obj1 = 0 ;
 
41544
  char *  kwnames[] = {
 
41545
    (char *) "self",(char *) "window", NULL 
 
41546
  };
 
41547
  
 
41548
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ContextHelp_BeginContextHelp",kwnames,&obj0,&obj1)) SWIG_fail;
 
41549
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextHelp, 0 |  0 );
 
41550
  if (!SWIG_IsOK(res1)) {
 
41551
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextHelp_BeginContextHelp" "', expected argument " "1"" of type '" "wxContextHelp *""'"); 
 
41552
  }
 
41553
  arg1 = reinterpret_cast< wxContextHelp * >(argp1);
 
41554
  if (obj1) {
 
41555
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
41556
    if (!SWIG_IsOK(res2)) {
 
41557
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ContextHelp_BeginContextHelp" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
41558
    }
 
41559
    arg2 = reinterpret_cast< wxWindow * >(argp2);
 
41560
  }
 
41561
  {
 
41562
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41563
    result = (bool)(arg1)->BeginContextHelp(arg2);
 
41564
    wxPyEndAllowThreads(__tstate);
 
41565
    if (PyErr_Occurred()) SWIG_fail;
 
41566
  }
 
41567
  {
 
41568
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
41569
  }
 
41570
  return resultobj;
 
41571
fail:
 
41572
  return NULL;
 
41573
}
 
41574
 
 
41575
 
 
41576
SWIGINTERN PyObject *_wrap_ContextHelp_EndContextHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41577
  PyObject *resultobj = 0;
 
41578
  wxContextHelp *arg1 = (wxContextHelp *) 0 ;
 
41579
  bool result;
 
41580
  void *argp1 = 0 ;
 
41581
  int res1 = 0 ;
 
41582
  PyObject *swig_obj[1] ;
 
41583
  
 
41584
  if (!args) SWIG_fail;
 
41585
  swig_obj[0] = args;
 
41586
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextHelp, 0 |  0 );
 
41587
  if (!SWIG_IsOK(res1)) {
 
41588
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextHelp_EndContextHelp" "', expected argument " "1"" of type '" "wxContextHelp *""'"); 
 
41589
  }
 
41590
  arg1 = reinterpret_cast< wxContextHelp * >(argp1);
 
41591
  {
 
41592
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41593
    result = (bool)(arg1)->EndContextHelp();
 
41594
    wxPyEndAllowThreads(__tstate);
 
41595
    if (PyErr_Occurred()) SWIG_fail;
 
41596
  }
 
41597
  {
 
41598
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
41599
  }
 
41600
  return resultobj;
 
41601
fail:
 
41602
  return NULL;
 
41603
}
 
41604
 
 
41605
 
 
41606
SWIGINTERN PyObject *ContextHelp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41607
  PyObject *obj;
 
41608
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
41609
  SWIG_TypeNewClientData(SWIGTYPE_p_wxContextHelp, SWIG_NewClientData(obj));
 
41610
  return SWIG_Py_Void();
 
41611
}
 
41612
 
 
41613
SWIGINTERN PyObject *ContextHelp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41614
  return SWIG_Python_InitShadowInstance(args);
 
41615
}
 
41616
 
 
41617
SWIGINTERN PyObject *_wrap_new_ContextHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41618
  PyObject *resultobj = 0;
 
41619
  wxWindow *arg1 = (wxWindow *) 0 ;
 
41620
  int arg2 = (int) wxID_CONTEXT_HELP ;
 
41621
  wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
41622
  wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
41623
  wxSize const &arg4_defvalue = wxDefaultSize ;
 
41624
  wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
41625
  long arg5 = (long) wxBU_AUTODRAW ;
 
41626
  wxContextHelpButton *result = 0 ;
 
41627
  void *argp1 = 0 ;
 
41628
  int res1 = 0 ;
 
41629
  int val2 ;
 
41630
  int ecode2 = 0 ;
 
41631
  wxPoint temp3 ;
 
41632
  wxSize temp4 ;
 
41633
  long val5 ;
 
41634
  int ecode5 = 0 ;
 
41635
  PyObject * obj0 = 0 ;
 
41636
  PyObject * obj1 = 0 ;
 
41637
  PyObject * obj2 = 0 ;
 
41638
  PyObject * obj3 = 0 ;
 
41639
  PyObject * obj4 = 0 ;
 
41640
  char *  kwnames[] = {
 
41641
    (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style", NULL 
 
41642
  };
 
41643
  
 
41644
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:new_ContextHelpButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
41645
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
41646
  if (!SWIG_IsOK(res1)) {
 
41647
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContextHelpButton" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
41648
  }
 
41649
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
41650
  if (obj1) {
 
41651
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
41652
    if (!SWIG_IsOK(ecode2)) {
 
41653
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextHelpButton" "', expected argument " "2"" of type '" "int""'");
 
41654
    } 
 
41655
    arg2 = static_cast< int >(val2);
 
41656
  }
 
41657
  if (obj2) {
 
41658
    {
 
41659
      arg3 = &temp3;
 
41660
      if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
41661
    }
 
41662
  }
 
41663
  if (obj3) {
 
41664
    {
 
41665
      arg4 = &temp4;
 
41666
      if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
41667
    }
 
41668
  }
 
41669
  if (obj4) {
 
41670
    ecode5 = SWIG_AsVal_long(obj4, &val5);
 
41671
    if (!SWIG_IsOK(ecode5)) {
 
41672
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ContextHelpButton" "', expected argument " "5"" of type '" "long""'");
 
41673
    } 
 
41674
    arg5 = static_cast< long >(val5);
 
41675
  }
 
41676
  {
 
41677
    if (!wxPyCheckForApp()) SWIG_fail;
 
41678
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41679
    result = (wxContextHelpButton *)new wxContextHelpButton(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5);
 
41680
    wxPyEndAllowThreads(__tstate);
 
41681
    if (PyErr_Occurred()) SWIG_fail;
 
41682
  }
 
41683
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextHelpButton, SWIG_POINTER_NEW |  0 );
 
41684
  return resultobj;
 
41685
fail:
 
41686
  return NULL;
 
41687
}
 
41688
 
 
41689
 
 
41690
SWIGINTERN PyObject *ContextHelpButton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41691
  PyObject *obj;
 
41692
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
41693
  SWIG_TypeNewClientData(SWIGTYPE_p_wxContextHelpButton, SWIG_NewClientData(obj));
 
41694
  return SWIG_Py_Void();
 
41695
}
 
41696
 
 
41697
SWIGINTERN PyObject *ContextHelpButton_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41698
  return SWIG_Python_InitShadowInstance(args);
 
41699
}
 
41700
 
 
41701
SWIGINTERN PyObject *_wrap_delete_HelpProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41702
  PyObject *resultobj = 0;
 
41703
  wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
 
41704
  void *argp1 = 0 ;
 
41705
  int res1 = 0 ;
 
41706
  PyObject *swig_obj[1] ;
 
41707
  
 
41708
  if (!args) SWIG_fail;
 
41709
  swig_obj[0] = args;
 
41710
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_DISOWN |  0 );
 
41711
  if (!SWIG_IsOK(res1)) {
 
41712
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HelpProvider" "', expected argument " "1"" of type '" "wxHelpProvider *""'"); 
 
41713
  }
 
41714
  arg1 = reinterpret_cast< wxHelpProvider * >(argp1);
 
41715
  {
 
41716
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41717
    delete arg1;
 
41718
    
 
41719
    wxPyEndAllowThreads(__tstate);
 
41720
    if (PyErr_Occurred()) SWIG_fail;
 
41721
  }
 
41722
  resultobj = SWIG_Py_Void();
 
41723
  return resultobj;
 
41724
fail:
 
41725
  return NULL;
 
41726
}
 
41727
 
 
41728
 
 
41729
SWIGINTERN PyObject *_wrap_HelpProvider_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41730
  PyObject *resultobj = 0;
 
41731
  wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
 
41732
  wxHelpProvider *result = 0 ;
 
41733
  int res1 = 0 ;
 
41734
  PyObject * obj0 = 0 ;
 
41735
  char *  kwnames[] = {
 
41736
    (char *) "helpProvider", NULL 
 
41737
  };
 
41738
  
 
41739
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:HelpProvider_Set",kwnames,&obj0)) SWIG_fail;
 
41740
  res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_DISOWN |  0 );
 
41741
  if (!SWIG_IsOK(res1)) {
 
41742
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpProvider_Set" "', expected argument " "1"" of type '" "wxHelpProvider *""'");
 
41743
  }
 
41744
  {
 
41745
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41746
    result = (wxHelpProvider *)wxHelpProvider::Set(arg1);
 
41747
    wxPyEndAllowThreads(__tstate);
 
41748
    if (PyErr_Occurred()) SWIG_fail;
 
41749
  }
 
41750
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxHelpProvider, SWIG_POINTER_OWN |  0 );
 
41751
  return resultobj;
 
41752
fail:
 
41753
  return NULL;
 
41754
}
 
41755
 
 
41756
 
 
41757
SWIGINTERN PyObject *_wrap_HelpProvider_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
41758
  PyObject *resultobj = 0;
 
41759
  wxHelpProvider *result = 0 ;
 
41760
  
 
41761
  if (!SWIG_Python_UnpackTuple(args,"HelpProvider_Get",0,0,0)) SWIG_fail;
 
41762
  {
 
41763
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41764
    result = (wxHelpProvider *)wxHelpProvider::Get();
 
41765
    wxPyEndAllowThreads(__tstate);
 
41766
    if (PyErr_Occurred()) SWIG_fail;
 
41767
  }
 
41768
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxHelpProvider, 0 |  0 );
 
41769
  return resultobj;
 
41770
fail:
 
41771
  return NULL;
 
41772
}
 
41773
 
 
41774
 
 
41775
SWIGINTERN PyObject *_wrap_HelpProvider_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41776
  PyObject *resultobj = 0;
 
41777
  wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
 
41778
  wxWindow *arg2 = (wxWindow *) 0 ;
 
41779
  wxString result;
 
41780
  void *argp1 = 0 ;
 
41781
  int res1 = 0 ;
 
41782
  void *argp2 = 0 ;
 
41783
  int res2 = 0 ;
 
41784
  PyObject * obj0 = 0 ;
 
41785
  PyObject * obj1 = 0 ;
 
41786
  char *  kwnames[] = {
 
41787
    (char *) "self",(char *) "window", NULL 
 
41788
  };
 
41789
  
 
41790
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpProvider_GetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
 
41791
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHelpProvider, 0 |  0 );
 
41792
  if (!SWIG_IsOK(res1)) {
 
41793
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpProvider_GetHelp" "', expected argument " "1"" of type '" "wxHelpProvider *""'"); 
 
41794
  }
 
41795
  arg1 = reinterpret_cast< wxHelpProvider * >(argp1);
 
41796
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
41797
  if (!SWIG_IsOK(res2)) {
 
41798
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelpProvider_GetHelp" "', expected argument " "2"" of type '" "wxWindow const *""'"); 
 
41799
  }
 
41800
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
41801
  {
 
41802
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41803
    result = (arg1)->GetHelp((wxWindow const *)arg2);
 
41804
    wxPyEndAllowThreads(__tstate);
 
41805
    if (PyErr_Occurred()) SWIG_fail;
 
41806
  }
 
41807
  {
 
41808
#if wxUSE_UNICODE
 
41809
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
41810
#else
 
41811
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
41812
#endif
 
41813
  }
 
41814
  return resultobj;
 
41815
fail:
 
41816
  return NULL;
 
41817
}
 
41818
 
 
41819
 
 
41820
SWIGINTERN PyObject *_wrap_HelpProvider_ShowHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41821
  PyObject *resultobj = 0;
 
41822
  wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
 
41823
  wxWindow *arg2 = (wxWindow *) 0 ;
 
41824
  bool result;
 
41825
  void *argp1 = 0 ;
 
41826
  int res1 = 0 ;
 
41827
  void *argp2 = 0 ;
 
41828
  int res2 = 0 ;
 
41829
  PyObject * obj0 = 0 ;
 
41830
  PyObject * obj1 = 0 ;
 
41831
  char *  kwnames[] = {
 
41832
    (char *) "self",(char *) "window", NULL 
 
41833
  };
 
41834
  
 
41835
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpProvider_ShowHelp",kwnames,&obj0,&obj1)) SWIG_fail;
 
41836
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHelpProvider, 0 |  0 );
 
41837
  if (!SWIG_IsOK(res1)) {
 
41838
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpProvider_ShowHelp" "', expected argument " "1"" of type '" "wxHelpProvider *""'"); 
 
41839
  }
 
41840
  arg1 = reinterpret_cast< wxHelpProvider * >(argp1);
 
41841
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
41842
  if (!SWIG_IsOK(res2)) {
 
41843
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelpProvider_ShowHelp" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
41844
  }
 
41845
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
41846
  {
 
41847
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41848
    result = (bool)(arg1)->ShowHelp(arg2);
 
41849
    wxPyEndAllowThreads(__tstate);
 
41850
    if (PyErr_Occurred()) SWIG_fail;
 
41851
  }
 
41852
  {
 
41853
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
41854
  }
 
41855
  return resultobj;
 
41856
fail:
 
41857
  return NULL;
 
41858
}
 
41859
 
 
41860
 
 
41861
SWIGINTERN PyObject *_wrap_HelpProvider_ShowHelpAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41862
  PyObject *resultobj = 0;
 
41863
  wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
 
41864
  wxWindowBase *arg2 = (wxWindowBase *) 0 ;
 
41865
  wxPoint *arg3 = 0 ;
 
41866
  wxHelpEvent::Origin arg4 ;
 
41867
  bool result;
 
41868
  void *argp1 = 0 ;
 
41869
  int res1 = 0 ;
 
41870
  void *argp2 = 0 ;
 
41871
  int res2 = 0 ;
 
41872
  wxPoint temp3 ;
 
41873
  int val4 ;
 
41874
  int ecode4 = 0 ;
 
41875
  PyObject * obj0 = 0 ;
 
41876
  PyObject * obj1 = 0 ;
 
41877
  PyObject * obj2 = 0 ;
 
41878
  PyObject * obj3 = 0 ;
 
41879
  char *  kwnames[] = {
 
41880
    (char *) "self",(char *) "window",(char *) "pt",(char *) "origin", NULL 
 
41881
  };
 
41882
  
 
41883
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:HelpProvider_ShowHelpAtPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
41884
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHelpProvider, 0 |  0 );
 
41885
  if (!SWIG_IsOK(res1)) {
 
41886
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpProvider_ShowHelpAtPoint" "', expected argument " "1"" of type '" "wxHelpProvider *""'"); 
 
41887
  }
 
41888
  arg1 = reinterpret_cast< wxHelpProvider * >(argp1);
 
41889
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindowBase, 0 |  0 );
 
41890
  if (!SWIG_IsOK(res2)) {
 
41891
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelpProvider_ShowHelpAtPoint" "', expected argument " "2"" of type '" "wxWindowBase *""'"); 
 
41892
  }
 
41893
  arg2 = reinterpret_cast< wxWindowBase * >(argp2);
 
41894
  {
 
41895
    arg3 = &temp3;
 
41896
    if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
41897
  }
 
41898
  ecode4 = SWIG_AsVal_int(obj3, &val4);
 
41899
  if (!SWIG_IsOK(ecode4)) {
 
41900
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HelpProvider_ShowHelpAtPoint" "', expected argument " "4"" of type '" "wxHelpEvent::Origin""'");
 
41901
  } 
 
41902
  arg4 = static_cast< wxHelpEvent::Origin >(val4);
 
41903
  {
 
41904
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41905
    result = (bool)(arg1)->ShowHelpAtPoint(arg2,(wxPoint const &)*arg3,arg4);
 
41906
    wxPyEndAllowThreads(__tstate);
 
41907
    if (PyErr_Occurred()) SWIG_fail;
 
41908
  }
 
41909
  {
 
41910
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
41911
  }
 
41912
  return resultobj;
 
41913
fail:
 
41914
  return NULL;
 
41915
}
 
41916
 
 
41917
 
 
41918
SWIGINTERN PyObject *_wrap_HelpProvider_AddHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41919
  PyObject *resultobj = 0;
 
41920
  wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
 
41921
  wxWindow *arg2 = (wxWindow *) 0 ;
 
41922
  wxString *arg3 = 0 ;
 
41923
  void *argp1 = 0 ;
 
41924
  int res1 = 0 ;
 
41925
  void *argp2 = 0 ;
 
41926
  int res2 = 0 ;
 
41927
  bool temp3 = false ;
 
41928
  PyObject * obj0 = 0 ;
 
41929
  PyObject * obj1 = 0 ;
 
41930
  PyObject * obj2 = 0 ;
 
41931
  char *  kwnames[] = {
 
41932
    (char *) "self",(char *) "window",(char *) "text", NULL 
 
41933
  };
 
41934
  
 
41935
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:HelpProvider_AddHelp",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
41936
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHelpProvider, 0 |  0 );
 
41937
  if (!SWIG_IsOK(res1)) {
 
41938
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpProvider_AddHelp" "', expected argument " "1"" of type '" "wxHelpProvider *""'"); 
 
41939
  }
 
41940
  arg1 = reinterpret_cast< wxHelpProvider * >(argp1);
 
41941
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
41942
  if (!SWIG_IsOK(res2)) {
 
41943
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelpProvider_AddHelp" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
41944
  }
 
41945
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
41946
  {
 
41947
    arg3 = wxString_in_helper(obj2);
 
41948
    if (arg3 == NULL) SWIG_fail;
 
41949
    temp3 = true;
 
41950
  }
 
41951
  {
 
41952
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
41953
    (arg1)->AddHelp(arg2,(wxString const &)*arg3);
 
41954
    wxPyEndAllowThreads(__tstate);
 
41955
    if (PyErr_Occurred()) SWIG_fail;
 
41956
  }
 
41957
  resultobj = SWIG_Py_Void();
 
41958
  {
 
41959
    if (temp3)
 
41960
    delete arg3;
 
41961
  }
 
41962
  return resultobj;
 
41963
fail:
 
41964
  {
 
41965
    if (temp3)
 
41966
    delete arg3;
 
41967
  }
 
41968
  return NULL;
 
41969
}
 
41970
 
 
41971
 
 
41972
SWIGINTERN PyObject *_wrap_HelpProvider_AddHelpById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
41973
  PyObject *resultobj = 0;
 
41974
  wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
 
41975
  int arg2 ;
 
41976
  wxString *arg3 = 0 ;
 
41977
  void *argp1 = 0 ;
 
41978
  int res1 = 0 ;
 
41979
  int val2 ;
 
41980
  int ecode2 = 0 ;
 
41981
  bool temp3 = false ;
 
41982
  PyObject * obj0 = 0 ;
 
41983
  PyObject * obj1 = 0 ;
 
41984
  PyObject * obj2 = 0 ;
 
41985
  char *  kwnames[] = {
 
41986
    (char *) "self",(char *) "id",(char *) "text", NULL 
 
41987
  };
 
41988
  
 
41989
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:HelpProvider_AddHelpById",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
41990
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHelpProvider, 0 |  0 );
 
41991
  if (!SWIG_IsOK(res1)) {
 
41992
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpProvider_AddHelpById" "', expected argument " "1"" of type '" "wxHelpProvider *""'"); 
 
41993
  }
 
41994
  arg1 = reinterpret_cast< wxHelpProvider * >(argp1);
 
41995
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
41996
  if (!SWIG_IsOK(ecode2)) {
 
41997
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelpProvider_AddHelpById" "', expected argument " "2"" of type '" "int""'");
 
41998
  } 
 
41999
  arg2 = static_cast< int >(val2);
 
42000
  {
 
42001
    arg3 = wxString_in_helper(obj2);
 
42002
    if (arg3 == NULL) SWIG_fail;
 
42003
    temp3 = true;
 
42004
  }
 
42005
  {
 
42006
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42007
    (arg1)->AddHelp(arg2,(wxString const &)*arg3);
 
42008
    wxPyEndAllowThreads(__tstate);
 
42009
    if (PyErr_Occurred()) SWIG_fail;
 
42010
  }
 
42011
  resultobj = SWIG_Py_Void();
 
42012
  {
 
42013
    if (temp3)
 
42014
    delete arg3;
 
42015
  }
 
42016
  return resultobj;
 
42017
fail:
 
42018
  {
 
42019
    if (temp3)
 
42020
    delete arg3;
 
42021
  }
 
42022
  return NULL;
 
42023
}
 
42024
 
 
42025
 
 
42026
SWIGINTERN PyObject *_wrap_HelpProvider_RemoveHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42027
  PyObject *resultobj = 0;
 
42028
  wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
 
42029
  wxWindow *arg2 = (wxWindow *) 0 ;
 
42030
  void *argp1 = 0 ;
 
42031
  int res1 = 0 ;
 
42032
  void *argp2 = 0 ;
 
42033
  int res2 = 0 ;
 
42034
  PyObject * obj0 = 0 ;
 
42035
  PyObject * obj1 = 0 ;
 
42036
  char *  kwnames[] = {
 
42037
    (char *) "self",(char *) "window", NULL 
 
42038
  };
 
42039
  
 
42040
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HelpProvider_RemoveHelp",kwnames,&obj0,&obj1)) SWIG_fail;
 
42041
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHelpProvider, 0 |  0 );
 
42042
  if (!SWIG_IsOK(res1)) {
 
42043
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpProvider_RemoveHelp" "', expected argument " "1"" of type '" "wxHelpProvider *""'"); 
 
42044
  }
 
42045
  arg1 = reinterpret_cast< wxHelpProvider * >(argp1);
 
42046
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
42047
  if (!SWIG_IsOK(res2)) {
 
42048
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelpProvider_RemoveHelp" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
42049
  }
 
42050
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
42051
  {
 
42052
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42053
    (arg1)->RemoveHelp(arg2);
 
42054
    wxPyEndAllowThreads(__tstate);
 
42055
    if (PyErr_Occurred()) SWIG_fail;
 
42056
  }
 
42057
  resultobj = SWIG_Py_Void();
 
42058
  return resultobj;
 
42059
fail:
 
42060
  return NULL;
 
42061
}
 
42062
 
 
42063
 
 
42064
SWIGINTERN PyObject *_wrap_HelpProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42065
  PyObject *resultobj = 0;
 
42066
  wxHelpProvider *arg1 = (wxHelpProvider *) 0 ;
 
42067
  void *argp1 = 0 ;
 
42068
  int res1 = 0 ;
 
42069
  PyObject *swig_obj[1] ;
 
42070
  
 
42071
  if (!args) SWIG_fail;
 
42072
  swig_obj[0] = args;
 
42073
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHelpProvider, 0 |  0 );
 
42074
  if (!SWIG_IsOK(res1)) {
 
42075
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelpProvider_Destroy" "', expected argument " "1"" of type '" "wxHelpProvider *""'"); 
 
42076
  }
 
42077
  arg1 = reinterpret_cast< wxHelpProvider * >(argp1);
 
42078
  {
 
42079
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42080
    wxHelpProvider_Destroy(arg1);
 
42081
    wxPyEndAllowThreads(__tstate);
 
42082
    if (PyErr_Occurred()) SWIG_fail;
 
42083
  }
 
42084
  resultobj = SWIG_Py_Void();
 
42085
  return resultobj;
 
42086
fail:
 
42087
  return NULL;
 
42088
}
 
42089
 
 
42090
 
 
42091
SWIGINTERN PyObject *HelpProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42092
  PyObject *obj;
 
42093
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
42094
  SWIG_TypeNewClientData(SWIGTYPE_p_wxHelpProvider, SWIG_NewClientData(obj));
 
42095
  return SWIG_Py_Void();
 
42096
}
 
42097
 
 
42098
SWIGINTERN PyObject *_wrap_new_SimpleHelpProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42099
  PyObject *resultobj = 0;
 
42100
  wxSimpleHelpProvider *result = 0 ;
 
42101
  
 
42102
  if (!SWIG_Python_UnpackTuple(args,"new_SimpleHelpProvider",0,0,0)) SWIG_fail;
 
42103
  {
 
42104
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42105
    result = (wxSimpleHelpProvider *)new wxSimpleHelpProvider();
 
42106
    wxPyEndAllowThreads(__tstate);
 
42107
    if (PyErr_Occurred()) SWIG_fail;
 
42108
  }
 
42109
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSimpleHelpProvider, SWIG_POINTER_NEW |  0 );
 
42110
  return resultobj;
 
42111
fail:
 
42112
  return NULL;
 
42113
}
 
42114
 
 
42115
 
 
42116
SWIGINTERN PyObject *SimpleHelpProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42117
  PyObject *obj;
 
42118
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
42119
  SWIG_TypeNewClientData(SWIGTYPE_p_wxSimpleHelpProvider, SWIG_NewClientData(obj));
 
42120
  return SWIG_Py_Void();
 
42121
}
 
42122
 
 
42123
SWIGINTERN PyObject *SimpleHelpProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42124
  return SWIG_Python_InitShadowInstance(args);
 
42125
}
 
42126
 
 
42127
SWIGINTERN PyObject *_wrap_new_DragImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42128
  PyObject *resultobj = 0;
 
42129
  wxBitmap *arg1 = 0 ;
 
42130
  wxCursor const &arg2_defvalue = wxNullCursor ;
 
42131
  wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
 
42132
  wxGenericDragImage *result = 0 ;
 
42133
  void *argp1 = 0 ;
 
42134
  int res1 = 0 ;
 
42135
  void *argp2 = 0 ;
 
42136
  int res2 = 0 ;
 
42137
  PyObject * obj0 = 0 ;
 
42138
  PyObject * obj1 = 0 ;
 
42139
  char *  kwnames[] = {
 
42140
    (char *) "image",(char *) "cursor", NULL 
 
42141
  };
 
42142
  
 
42143
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_DragImage",kwnames,&obj0,&obj1)) SWIG_fail;
 
42144
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap,  0  | 0);
 
42145
  if (!SWIG_IsOK(res1)) {
 
42146
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DragImage" "', expected argument " "1"" of type '" "wxBitmap const &""'"); 
 
42147
  }
 
42148
  if (!argp1) {
 
42149
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DragImage" "', expected argument " "1"" of type '" "wxBitmap const &""'"); 
 
42150
  }
 
42151
  arg1 = reinterpret_cast< wxBitmap * >(argp1);
 
42152
  if (obj1) {
 
42153
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor,  0  | 0);
 
42154
    if (!SWIG_IsOK(res2)) {
 
42155
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DragImage" "', expected argument " "2"" of type '" "wxCursor const &""'"); 
 
42156
    }
 
42157
    if (!argp2) {
 
42158
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DragImage" "', expected argument " "2"" of type '" "wxCursor const &""'"); 
 
42159
    }
 
42160
    arg2 = reinterpret_cast< wxCursor * >(argp2);
 
42161
  }
 
42162
  {
 
42163
    if (!wxPyCheckForApp()) SWIG_fail;
 
42164
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42165
    result = (wxGenericDragImage *)new wxGenericDragImage((wxBitmap const &)*arg1,(wxCursor const &)*arg2);
 
42166
    wxPyEndAllowThreads(__tstate);
 
42167
    if (PyErr_Occurred()) SWIG_fail;
 
42168
  }
 
42169
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_NEW |  0 );
 
42170
  return resultobj;
 
42171
fail:
 
42172
  return NULL;
 
42173
}
 
42174
 
 
42175
 
 
42176
SWIGINTERN PyObject *_wrap_new_DragIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42177
  PyObject *resultobj = 0;
 
42178
  wxIcon *arg1 = 0 ;
 
42179
  wxCursor const &arg2_defvalue = wxNullCursor ;
 
42180
  wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
 
42181
  wxGenericDragImage *result = 0 ;
 
42182
  void *argp1 = 0 ;
 
42183
  int res1 = 0 ;
 
42184
  void *argp2 = 0 ;
 
42185
  int res2 = 0 ;
 
42186
  PyObject * obj0 = 0 ;
 
42187
  PyObject * obj1 = 0 ;
 
42188
  char *  kwnames[] = {
 
42189
    (char *) "image",(char *) "cursor", NULL 
 
42190
  };
 
42191
  
 
42192
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_DragIcon",kwnames,&obj0,&obj1)) SWIG_fail;
 
42193
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon,  0  | 0);
 
42194
  if (!SWIG_IsOK(res1)) {
 
42195
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DragIcon" "', expected argument " "1"" of type '" "wxIcon const &""'"); 
 
42196
  }
 
42197
  if (!argp1) {
 
42198
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DragIcon" "', expected argument " "1"" of type '" "wxIcon const &""'"); 
 
42199
  }
 
42200
  arg1 = reinterpret_cast< wxIcon * >(argp1);
 
42201
  if (obj1) {
 
42202
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor,  0  | 0);
 
42203
    if (!SWIG_IsOK(res2)) {
 
42204
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DragIcon" "', expected argument " "2"" of type '" "wxCursor const &""'"); 
 
42205
    }
 
42206
    if (!argp2) {
 
42207
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DragIcon" "', expected argument " "2"" of type '" "wxCursor const &""'"); 
 
42208
    }
 
42209
    arg2 = reinterpret_cast< wxCursor * >(argp2);
 
42210
  }
 
42211
  {
 
42212
    if (!wxPyCheckForApp()) SWIG_fail;
 
42213
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42214
    result = (wxGenericDragImage *)new wxGenericDragImage((wxIcon const &)*arg1,(wxCursor const &)*arg2);
 
42215
    wxPyEndAllowThreads(__tstate);
 
42216
    if (PyErr_Occurred()) SWIG_fail;
 
42217
  }
 
42218
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_OWN |  0 );
 
42219
  return resultobj;
 
42220
fail:
 
42221
  return NULL;
 
42222
}
 
42223
 
 
42224
 
 
42225
SWIGINTERN PyObject *_wrap_new_DragString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42226
  PyObject *resultobj = 0;
 
42227
  wxString *arg1 = 0 ;
 
42228
  wxCursor const &arg2_defvalue = wxNullCursor ;
 
42229
  wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
 
42230
  wxGenericDragImage *result = 0 ;
 
42231
  bool temp1 = false ;
 
42232
  void *argp2 = 0 ;
 
42233
  int res2 = 0 ;
 
42234
  PyObject * obj0 = 0 ;
 
42235
  PyObject * obj1 = 0 ;
 
42236
  char *  kwnames[] = {
 
42237
    (char *) "str",(char *) "cursor", NULL 
 
42238
  };
 
42239
  
 
42240
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_DragString",kwnames,&obj0,&obj1)) SWIG_fail;
 
42241
  {
 
42242
    arg1 = wxString_in_helper(obj0);
 
42243
    if (arg1 == NULL) SWIG_fail;
 
42244
    temp1 = true;
 
42245
  }
 
42246
  if (obj1) {
 
42247
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor,  0  | 0);
 
42248
    if (!SWIG_IsOK(res2)) {
 
42249
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DragString" "', expected argument " "2"" of type '" "wxCursor const &""'"); 
 
42250
    }
 
42251
    if (!argp2) {
 
42252
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DragString" "', expected argument " "2"" of type '" "wxCursor const &""'"); 
 
42253
    }
 
42254
    arg2 = reinterpret_cast< wxCursor * >(argp2);
 
42255
  }
 
42256
  {
 
42257
    if (!wxPyCheckForApp()) SWIG_fail;
 
42258
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42259
    result = (wxGenericDragImage *)new wxGenericDragImage((wxString const &)*arg1,(wxCursor const &)*arg2);
 
42260
    wxPyEndAllowThreads(__tstate);
 
42261
    if (PyErr_Occurred()) SWIG_fail;
 
42262
  }
 
42263
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_OWN |  0 );
 
42264
  {
 
42265
    if (temp1)
 
42266
    delete arg1;
 
42267
  }
 
42268
  return resultobj;
 
42269
fail:
 
42270
  {
 
42271
    if (temp1)
 
42272
    delete arg1;
 
42273
  }
 
42274
  return NULL;
 
42275
}
 
42276
 
 
42277
 
 
42278
SWIGINTERN PyObject *_wrap_new_DragTreeItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42279
  PyObject *resultobj = 0;
 
42280
  wxPyTreeCtrl *arg1 = 0 ;
 
42281
  wxTreeItemId *arg2 = 0 ;
 
42282
  wxGenericDragImage *result = 0 ;
 
42283
  void *argp1 = 0 ;
 
42284
  int res1 = 0 ;
 
42285
  void *argp2 = 0 ;
 
42286
  int res2 = 0 ;
 
42287
  PyObject * obj0 = 0 ;
 
42288
  PyObject * obj1 = 0 ;
 
42289
  char *  kwnames[] = {
 
42290
    (char *) "treeCtrl",(char *) "id", NULL 
 
42291
  };
 
42292
  
 
42293
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_DragTreeItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
42294
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPyTreeCtrl,  0  | 0);
 
42295
  if (!SWIG_IsOK(res1)) {
 
42296
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DragTreeItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl const &""'"); 
 
42297
  }
 
42298
  if (!argp1) {
 
42299
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DragTreeItem" "', expected argument " "1"" of type '" "wxPyTreeCtrl const &""'"); 
 
42300
  }
 
42301
  arg1 = reinterpret_cast< wxPyTreeCtrl * >(argp1);
 
42302
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTreeItemId,  0 );
 
42303
  if (!SWIG_IsOK(res2)) {
 
42304
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DragTreeItem" "', expected argument " "2"" of type '" "wxTreeItemId &""'"); 
 
42305
  }
 
42306
  if (!argp2) {
 
42307
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DragTreeItem" "', expected argument " "2"" of type '" "wxTreeItemId &""'"); 
 
42308
  }
 
42309
  arg2 = reinterpret_cast< wxTreeItemId * >(argp2);
 
42310
  {
 
42311
    if (!wxPyCheckForApp()) SWIG_fail;
 
42312
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42313
    result = (wxGenericDragImage *)new wxGenericDragImage((wxPyTreeCtrl const &)*arg1,*arg2);
 
42314
    wxPyEndAllowThreads(__tstate);
 
42315
    if (PyErr_Occurred()) SWIG_fail;
 
42316
  }
 
42317
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_OWN |  0 );
 
42318
  return resultobj;
 
42319
fail:
 
42320
  return NULL;
 
42321
}
 
42322
 
 
42323
 
 
42324
SWIGINTERN PyObject *_wrap_new_DragListItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42325
  PyObject *resultobj = 0;
 
42326
  wxPyListCtrl *arg1 = 0 ;
 
42327
  long arg2 ;
 
42328
  wxGenericDragImage *result = 0 ;
 
42329
  void *argp1 = 0 ;
 
42330
  int res1 = 0 ;
 
42331
  long val2 ;
 
42332
  int ecode2 = 0 ;
 
42333
  PyObject * obj0 = 0 ;
 
42334
  PyObject * obj1 = 0 ;
 
42335
  char *  kwnames[] = {
 
42336
    (char *) "listCtrl",(char *) "id", NULL 
 
42337
  };
 
42338
  
 
42339
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_DragListItem",kwnames,&obj0,&obj1)) SWIG_fail;
 
42340
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPyListCtrl,  0  | 0);
 
42341
  if (!SWIG_IsOK(res1)) {
 
42342
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DragListItem" "', expected argument " "1"" of type '" "wxPyListCtrl const &""'"); 
 
42343
  }
 
42344
  if (!argp1) {
 
42345
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DragListItem" "', expected argument " "1"" of type '" "wxPyListCtrl const &""'"); 
 
42346
  }
 
42347
  arg1 = reinterpret_cast< wxPyListCtrl * >(argp1);
 
42348
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
42349
  if (!SWIG_IsOK(ecode2)) {
 
42350
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DragListItem" "', expected argument " "2"" of type '" "long""'");
 
42351
  } 
 
42352
  arg2 = static_cast< long >(val2);
 
42353
  {
 
42354
    if (!wxPyCheckForApp()) SWIG_fail;
 
42355
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42356
    result = (wxGenericDragImage *)new wxGenericDragImage((wxPyListCtrl const &)*arg1,arg2);
 
42357
    wxPyEndAllowThreads(__tstate);
 
42358
    if (PyErr_Occurred()) SWIG_fail;
 
42359
  }
 
42360
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_OWN |  0 );
 
42361
  return resultobj;
 
42362
fail:
 
42363
  return NULL;
 
42364
}
 
42365
 
 
42366
 
 
42367
SWIGINTERN PyObject *_wrap_delete_DragImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42368
  PyObject *resultobj = 0;
 
42369
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42370
  void *argp1 = 0 ;
 
42371
  int res1 = 0 ;
 
42372
  PyObject *swig_obj[1] ;
 
42373
  
 
42374
  if (!args) SWIG_fail;
 
42375
  swig_obj[0] = args;
 
42376
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDragImage, SWIG_POINTER_DISOWN |  0 );
 
42377
  if (!SWIG_IsOK(res1)) {
 
42378
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DragImage" "', expected argument " "1"" of type '" "wxGenericDragImage *""'"); 
 
42379
  }
 
42380
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42381
  {
 
42382
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42383
    delete arg1;
 
42384
    
 
42385
    wxPyEndAllowThreads(__tstate);
 
42386
    if (PyErr_Occurred()) SWIG_fail;
 
42387
  }
 
42388
  resultobj = SWIG_Py_Void();
 
42389
  return resultobj;
 
42390
fail:
 
42391
  return NULL;
 
42392
}
 
42393
 
 
42394
 
 
42395
SWIGINTERN PyObject *_wrap_DragImage_SetBackingBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42396
  PyObject *resultobj = 0;
 
42397
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42398
  wxBitmap *arg2 = (wxBitmap *) 0 ;
 
42399
  void *argp1 = 0 ;
 
42400
  int res1 = 0 ;
 
42401
  void *argp2 = 0 ;
 
42402
  int res2 = 0 ;
 
42403
  PyObject * obj0 = 0 ;
 
42404
  PyObject * obj1 = 0 ;
 
42405
  char *  kwnames[] = {
 
42406
    (char *) "self",(char *) "bitmap", NULL 
 
42407
  };
 
42408
  
 
42409
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DragImage_SetBackingBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
 
42410
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42411
  if (!SWIG_IsOK(res1)) {
 
42412
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_SetBackingBitmap" "', expected argument " "1"" of type '" "wxGenericDragImage *""'"); 
 
42413
  }
 
42414
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42415
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 |  0 );
 
42416
  if (!SWIG_IsOK(res2)) {
 
42417
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DragImage_SetBackingBitmap" "', expected argument " "2"" of type '" "wxBitmap *""'"); 
 
42418
  }
 
42419
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
42420
  {
 
42421
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42422
    (arg1)->SetBackingBitmap(arg2);
 
42423
    wxPyEndAllowThreads(__tstate);
 
42424
    if (PyErr_Occurred()) SWIG_fail;
 
42425
  }
 
42426
  resultobj = SWIG_Py_Void();
 
42427
  return resultobj;
 
42428
fail:
 
42429
  return NULL;
 
42430
}
 
42431
 
 
42432
 
 
42433
SWIGINTERN PyObject *_wrap_DragImage_BeginDrag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42434
  PyObject *resultobj = 0;
 
42435
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42436
  wxPoint *arg2 = 0 ;
 
42437
  wxWindow *arg3 = (wxWindow *) 0 ;
 
42438
  bool arg4 = (bool) false ;
 
42439
  wxRect *arg5 = (wxRect *) NULL ;
 
42440
  bool result;
 
42441
  void *argp1 = 0 ;
 
42442
  int res1 = 0 ;
 
42443
  wxPoint temp2 ;
 
42444
  void *argp3 = 0 ;
 
42445
  int res3 = 0 ;
 
42446
  bool val4 ;
 
42447
  int ecode4 = 0 ;
 
42448
  wxRect temp5 ;
 
42449
  PyObject * obj0 = 0 ;
 
42450
  PyObject * obj1 = 0 ;
 
42451
  PyObject * obj2 = 0 ;
 
42452
  PyObject * obj3 = 0 ;
 
42453
  PyObject * obj4 = 0 ;
 
42454
  char *  kwnames[] = {
 
42455
    (char *) "self",(char *) "hotspot",(char *) "window",(char *) "fullScreen",(char *) "rect", NULL 
 
42456
  };
 
42457
  
 
42458
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DragImage_BeginDrag",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
42459
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42460
  if (!SWIG_IsOK(res1)) {
 
42461
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_BeginDrag" "', expected argument " "1"" of type '" "wxGenericDragImage *""'"); 
 
42462
  }
 
42463
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42464
  {
 
42465
    arg2 = &temp2;
 
42466
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
42467
  }
 
42468
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 |  0 );
 
42469
  if (!SWIG_IsOK(res3)) {
 
42470
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DragImage_BeginDrag" "', expected argument " "3"" of type '" "wxWindow *""'"); 
 
42471
  }
 
42472
  arg3 = reinterpret_cast< wxWindow * >(argp3);
 
42473
  if (obj3) {
 
42474
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
 
42475
    if (!SWIG_IsOK(ecode4)) {
 
42476
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DragImage_BeginDrag" "', expected argument " "4"" of type '" "bool""'");
 
42477
    } 
 
42478
    arg4 = static_cast< bool >(val4);
 
42479
  }
 
42480
  if (obj4) {
 
42481
    {
 
42482
      arg5 = &temp5;
 
42483
      if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
 
42484
    }
 
42485
  }
 
42486
  {
 
42487
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42488
    result = (bool)(arg1)->BeginDrag((wxPoint const &)*arg2,arg3,arg4,arg5);
 
42489
    wxPyEndAllowThreads(__tstate);
 
42490
    if (PyErr_Occurred()) SWIG_fail;
 
42491
  }
 
42492
  {
 
42493
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
42494
  }
 
42495
  return resultobj;
 
42496
fail:
 
42497
  return NULL;
 
42498
}
 
42499
 
 
42500
 
 
42501
SWIGINTERN PyObject *_wrap_DragImage_BeginDragBounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42502
  PyObject *resultobj = 0;
 
42503
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42504
  wxPoint *arg2 = 0 ;
 
42505
  wxWindow *arg3 = (wxWindow *) 0 ;
 
42506
  wxWindow *arg4 = (wxWindow *) 0 ;
 
42507
  bool result;
 
42508
  void *argp1 = 0 ;
 
42509
  int res1 = 0 ;
 
42510
  wxPoint temp2 ;
 
42511
  void *argp3 = 0 ;
 
42512
  int res3 = 0 ;
 
42513
  void *argp4 = 0 ;
 
42514
  int res4 = 0 ;
 
42515
  PyObject * obj0 = 0 ;
 
42516
  PyObject * obj1 = 0 ;
 
42517
  PyObject * obj2 = 0 ;
 
42518
  PyObject * obj3 = 0 ;
 
42519
  char *  kwnames[] = {
 
42520
    (char *) "self",(char *) "hotspot",(char *) "window",(char *) "boundingWindow", NULL 
 
42521
  };
 
42522
  
 
42523
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DragImage_BeginDragBounded",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
42524
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42525
  if (!SWIG_IsOK(res1)) {
 
42526
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_BeginDragBounded" "', expected argument " "1"" of type '" "wxGenericDragImage *""'"); 
 
42527
  }
 
42528
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42529
  {
 
42530
    arg2 = &temp2;
 
42531
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
42532
  }
 
42533
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 |  0 );
 
42534
  if (!SWIG_IsOK(res3)) {
 
42535
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DragImage_BeginDragBounded" "', expected argument " "3"" of type '" "wxWindow *""'"); 
 
42536
  }
 
42537
  arg3 = reinterpret_cast< wxWindow * >(argp3);
 
42538
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 |  0 );
 
42539
  if (!SWIG_IsOK(res4)) {
 
42540
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DragImage_BeginDragBounded" "', expected argument " "4"" of type '" "wxWindow *""'"); 
 
42541
  }
 
42542
  arg4 = reinterpret_cast< wxWindow * >(argp4);
 
42543
  {
 
42544
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42545
    result = (bool)(arg1)->BeginDrag((wxPoint const &)*arg2,arg3,arg4);
 
42546
    wxPyEndAllowThreads(__tstate);
 
42547
    if (PyErr_Occurred()) SWIG_fail;
 
42548
  }
 
42549
  {
 
42550
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
42551
  }
 
42552
  return resultobj;
 
42553
fail:
 
42554
  return NULL;
 
42555
}
 
42556
 
 
42557
 
 
42558
SWIGINTERN PyObject *_wrap_DragImage_EndDrag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42559
  PyObject *resultobj = 0;
 
42560
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42561
  bool result;
 
42562
  void *argp1 = 0 ;
 
42563
  int res1 = 0 ;
 
42564
  PyObject *swig_obj[1] ;
 
42565
  
 
42566
  if (!args) SWIG_fail;
 
42567
  swig_obj[0] = args;
 
42568
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42569
  if (!SWIG_IsOK(res1)) {
 
42570
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_EndDrag" "', expected argument " "1"" of type '" "wxGenericDragImage *""'"); 
 
42571
  }
 
42572
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42573
  {
 
42574
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42575
    result = (bool)(arg1)->EndDrag();
 
42576
    wxPyEndAllowThreads(__tstate);
 
42577
    if (PyErr_Occurred()) SWIG_fail;
 
42578
  }
 
42579
  {
 
42580
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
42581
  }
 
42582
  return resultobj;
 
42583
fail:
 
42584
  return NULL;
 
42585
}
 
42586
 
 
42587
 
 
42588
SWIGINTERN PyObject *_wrap_DragImage_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42589
  PyObject *resultobj = 0;
 
42590
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42591
  wxPoint *arg2 = 0 ;
 
42592
  bool result;
 
42593
  void *argp1 = 0 ;
 
42594
  int res1 = 0 ;
 
42595
  wxPoint temp2 ;
 
42596
  PyObject * obj0 = 0 ;
 
42597
  PyObject * obj1 = 0 ;
 
42598
  char *  kwnames[] = {
 
42599
    (char *) "self",(char *) "pt", NULL 
 
42600
  };
 
42601
  
 
42602
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DragImage_Move",kwnames,&obj0,&obj1)) SWIG_fail;
 
42603
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42604
  if (!SWIG_IsOK(res1)) {
 
42605
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_Move" "', expected argument " "1"" of type '" "wxGenericDragImage *""'"); 
 
42606
  }
 
42607
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42608
  {
 
42609
    arg2 = &temp2;
 
42610
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
42611
  }
 
42612
  {
 
42613
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42614
    result = (bool)(arg1)->Move((wxPoint const &)*arg2);
 
42615
    wxPyEndAllowThreads(__tstate);
 
42616
    if (PyErr_Occurred()) SWIG_fail;
 
42617
  }
 
42618
  {
 
42619
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
42620
  }
 
42621
  return resultobj;
 
42622
fail:
 
42623
  return NULL;
 
42624
}
 
42625
 
 
42626
 
 
42627
SWIGINTERN PyObject *_wrap_DragImage_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42628
  PyObject *resultobj = 0;
 
42629
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42630
  bool result;
 
42631
  void *argp1 = 0 ;
 
42632
  int res1 = 0 ;
 
42633
  PyObject *swig_obj[1] ;
 
42634
  
 
42635
  if (!args) SWIG_fail;
 
42636
  swig_obj[0] = args;
 
42637
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42638
  if (!SWIG_IsOK(res1)) {
 
42639
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_Show" "', expected argument " "1"" of type '" "wxGenericDragImage *""'"); 
 
42640
  }
 
42641
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42642
  {
 
42643
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42644
    result = (bool)(arg1)->Show();
 
42645
    wxPyEndAllowThreads(__tstate);
 
42646
    if (PyErr_Occurred()) SWIG_fail;
 
42647
  }
 
42648
  {
 
42649
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
42650
  }
 
42651
  return resultobj;
 
42652
fail:
 
42653
  return NULL;
 
42654
}
 
42655
 
 
42656
 
 
42657
SWIGINTERN PyObject *_wrap_DragImage_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42658
  PyObject *resultobj = 0;
 
42659
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42660
  bool result;
 
42661
  void *argp1 = 0 ;
 
42662
  int res1 = 0 ;
 
42663
  PyObject *swig_obj[1] ;
 
42664
  
 
42665
  if (!args) SWIG_fail;
 
42666
  swig_obj[0] = args;
 
42667
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42668
  if (!SWIG_IsOK(res1)) {
 
42669
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_Hide" "', expected argument " "1"" of type '" "wxGenericDragImage *""'"); 
 
42670
  }
 
42671
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42672
  {
 
42673
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42674
    result = (bool)(arg1)->Hide();
 
42675
    wxPyEndAllowThreads(__tstate);
 
42676
    if (PyErr_Occurred()) SWIG_fail;
 
42677
  }
 
42678
  {
 
42679
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
42680
  }
 
42681
  return resultobj;
 
42682
fail:
 
42683
  return NULL;
 
42684
}
 
42685
 
 
42686
 
 
42687
SWIGINTERN PyObject *_wrap_DragImage_GetImageRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42688
  PyObject *resultobj = 0;
 
42689
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42690
  wxPoint *arg2 = 0 ;
 
42691
  wxRect result;
 
42692
  void *argp1 = 0 ;
 
42693
  int res1 = 0 ;
 
42694
  wxPoint temp2 ;
 
42695
  PyObject * obj0 = 0 ;
 
42696
  PyObject * obj1 = 0 ;
 
42697
  char *  kwnames[] = {
 
42698
    (char *) "self",(char *) "pos", NULL 
 
42699
  };
 
42700
  
 
42701
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DragImage_GetImageRect",kwnames,&obj0,&obj1)) SWIG_fail;
 
42702
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42703
  if (!SWIG_IsOK(res1)) {
 
42704
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_GetImageRect" "', expected argument " "1"" of type '" "wxGenericDragImage const *""'"); 
 
42705
  }
 
42706
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42707
  {
 
42708
    arg2 = &temp2;
 
42709
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
42710
  }
 
42711
  {
 
42712
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42713
    result = ((wxGenericDragImage const *)arg1)->GetImageRect((wxPoint const &)*arg2);
 
42714
    wxPyEndAllowThreads(__tstate);
 
42715
    if (PyErr_Occurred()) SWIG_fail;
 
42716
  }
 
42717
  resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN |  0 );
 
42718
  return resultobj;
 
42719
fail:
 
42720
  return NULL;
 
42721
}
 
42722
 
 
42723
 
 
42724
SWIGINTERN PyObject *_wrap_DragImage_DoDrawImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42725
  PyObject *resultobj = 0;
 
42726
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42727
  wxDC *arg2 = 0 ;
 
42728
  wxPoint *arg3 = 0 ;
 
42729
  bool result;
 
42730
  void *argp1 = 0 ;
 
42731
  int res1 = 0 ;
 
42732
  void *argp2 = 0 ;
 
42733
  int res2 = 0 ;
 
42734
  wxPoint temp3 ;
 
42735
  PyObject * obj0 = 0 ;
 
42736
  PyObject * obj1 = 0 ;
 
42737
  PyObject * obj2 = 0 ;
 
42738
  char *  kwnames[] = {
 
42739
    (char *) "self",(char *) "dc",(char *) "pos", NULL 
 
42740
  };
 
42741
  
 
42742
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DragImage_DoDrawImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
42743
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42744
  if (!SWIG_IsOK(res1)) {
 
42745
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_DoDrawImage" "', expected argument " "1"" of type '" "wxGenericDragImage const *""'"); 
 
42746
  }
 
42747
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42748
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC,  0 );
 
42749
  if (!SWIG_IsOK(res2)) {
 
42750
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DragImage_DoDrawImage" "', expected argument " "2"" of type '" "wxDC &""'"); 
 
42751
  }
 
42752
  if (!argp2) {
 
42753
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DragImage_DoDrawImage" "', expected argument " "2"" of type '" "wxDC &""'"); 
 
42754
  }
 
42755
  arg2 = reinterpret_cast< wxDC * >(argp2);
 
42756
  {
 
42757
    arg3 = &temp3;
 
42758
    if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
42759
  }
 
42760
  {
 
42761
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42762
    result = (bool)((wxGenericDragImage const *)arg1)->DoDrawImage(*arg2,(wxPoint const &)*arg3);
 
42763
    wxPyEndAllowThreads(__tstate);
 
42764
    if (PyErr_Occurred()) SWIG_fail;
 
42765
  }
 
42766
  {
 
42767
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
42768
  }
 
42769
  return resultobj;
 
42770
fail:
 
42771
  return NULL;
 
42772
}
 
42773
 
 
42774
 
 
42775
SWIGINTERN PyObject *_wrap_DragImage_UpdateBackingFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42776
  PyObject *resultobj = 0;
 
42777
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42778
  wxDC *arg2 = 0 ;
 
42779
  wxMemoryDC *arg3 = 0 ;
 
42780
  wxRect *arg4 = 0 ;
 
42781
  wxRect *arg5 = 0 ;
 
42782
  bool result;
 
42783
  void *argp1 = 0 ;
 
42784
  int res1 = 0 ;
 
42785
  void *argp2 = 0 ;
 
42786
  int res2 = 0 ;
 
42787
  void *argp3 = 0 ;
 
42788
  int res3 = 0 ;
 
42789
  wxRect temp4 ;
 
42790
  wxRect temp5 ;
 
42791
  PyObject * obj0 = 0 ;
 
42792
  PyObject * obj1 = 0 ;
 
42793
  PyObject * obj2 = 0 ;
 
42794
  PyObject * obj3 = 0 ;
 
42795
  PyObject * obj4 = 0 ;
 
42796
  char *  kwnames[] = {
 
42797
    (char *) "self",(char *) "windowDC",(char *) "destDC",(char *) "sourceRect",(char *) "destRect", NULL 
 
42798
  };
 
42799
  
 
42800
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DragImage_UpdateBackingFromWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
42801
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42802
  if (!SWIG_IsOK(res1)) {
 
42803
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_UpdateBackingFromWindow" "', expected argument " "1"" of type '" "wxGenericDragImage const *""'"); 
 
42804
  }
 
42805
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42806
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC,  0 );
 
42807
  if (!SWIG_IsOK(res2)) {
 
42808
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DragImage_UpdateBackingFromWindow" "', expected argument " "2"" of type '" "wxDC &""'"); 
 
42809
  }
 
42810
  if (!argp2) {
 
42811
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DragImage_UpdateBackingFromWindow" "', expected argument " "2"" of type '" "wxDC &""'"); 
 
42812
  }
 
42813
  arg2 = reinterpret_cast< wxDC * >(argp2);
 
42814
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxMemoryDC,  0 );
 
42815
  if (!SWIG_IsOK(res3)) {
 
42816
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DragImage_UpdateBackingFromWindow" "', expected argument " "3"" of type '" "wxMemoryDC &""'"); 
 
42817
  }
 
42818
  if (!argp3) {
 
42819
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DragImage_UpdateBackingFromWindow" "', expected argument " "3"" of type '" "wxMemoryDC &""'"); 
 
42820
  }
 
42821
  arg3 = reinterpret_cast< wxMemoryDC * >(argp3);
 
42822
  {
 
42823
    arg4 = &temp4;
 
42824
    if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
 
42825
  }
 
42826
  {
 
42827
    arg5 = &temp5;
 
42828
    if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
 
42829
  }
 
42830
  {
 
42831
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42832
    result = (bool)((wxGenericDragImage const *)arg1)->UpdateBackingFromWindow(*arg2,*arg3,(wxRect const &)*arg4,(wxRect const &)*arg5);
 
42833
    wxPyEndAllowThreads(__tstate);
 
42834
    if (PyErr_Occurred()) SWIG_fail;
 
42835
  }
 
42836
  {
 
42837
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
42838
  }
 
42839
  return resultobj;
 
42840
fail:
 
42841
  return NULL;
 
42842
}
 
42843
 
 
42844
 
 
42845
SWIGINTERN PyObject *_wrap_DragImage_RedrawImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42846
  PyObject *resultobj = 0;
 
42847
  wxGenericDragImage *arg1 = (wxGenericDragImage *) 0 ;
 
42848
  wxPoint *arg2 = 0 ;
 
42849
  wxPoint *arg3 = 0 ;
 
42850
  bool arg4 ;
 
42851
  bool arg5 ;
 
42852
  bool result;
 
42853
  void *argp1 = 0 ;
 
42854
  int res1 = 0 ;
 
42855
  wxPoint temp2 ;
 
42856
  wxPoint temp3 ;
 
42857
  bool val4 ;
 
42858
  int ecode4 = 0 ;
 
42859
  bool val5 ;
 
42860
  int ecode5 = 0 ;
 
42861
  PyObject * obj0 = 0 ;
 
42862
  PyObject * obj1 = 0 ;
 
42863
  PyObject * obj2 = 0 ;
 
42864
  PyObject * obj3 = 0 ;
 
42865
  PyObject * obj4 = 0 ;
 
42866
  char *  kwnames[] = {
 
42867
    (char *) "self",(char *) "oldPos",(char *) "newPos",(char *) "eraseOld",(char *) "drawNew", NULL 
 
42868
  };
 
42869
  
 
42870
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DragImage_RedrawImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
 
42871
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGenericDragImage, 0 |  0 );
 
42872
  if (!SWIG_IsOK(res1)) {
 
42873
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DragImage_RedrawImage" "', expected argument " "1"" of type '" "wxGenericDragImage *""'"); 
 
42874
  }
 
42875
  arg1 = reinterpret_cast< wxGenericDragImage * >(argp1);
 
42876
  {
 
42877
    arg2 = &temp2;
 
42878
    if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
 
42879
  }
 
42880
  {
 
42881
    arg3 = &temp3;
 
42882
    if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
42883
  }
 
42884
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
 
42885
  if (!SWIG_IsOK(ecode4)) {
 
42886
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DragImage_RedrawImage" "', expected argument " "4"" of type '" "bool""'");
 
42887
  } 
 
42888
  arg4 = static_cast< bool >(val4);
 
42889
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
 
42890
  if (!SWIG_IsOK(ecode5)) {
 
42891
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DragImage_RedrawImage" "', expected argument " "5"" of type '" "bool""'");
 
42892
  } 
 
42893
  arg5 = static_cast< bool >(val5);
 
42894
  {
 
42895
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42896
    result = (bool)(arg1)->RedrawImage((wxPoint const &)*arg2,(wxPoint const &)*arg3,arg4,arg5);
 
42897
    wxPyEndAllowThreads(__tstate);
 
42898
    if (PyErr_Occurred()) SWIG_fail;
 
42899
  }
 
42900
  {
 
42901
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
42902
  }
 
42903
  return resultobj;
 
42904
fail:
 
42905
  return NULL;
 
42906
}
 
42907
 
 
42908
 
 
42909
SWIGINTERN PyObject *DragImage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42910
  PyObject *obj;
 
42911
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
42912
  SWIG_TypeNewClientData(SWIGTYPE_p_wxGenericDragImage, SWIG_NewClientData(obj));
 
42913
  return SWIG_Py_Void();
 
42914
}
 
42915
 
 
42916
SWIGINTERN PyObject *DragImage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42917
  return SWIG_Python_InitShadowInstance(args);
 
42918
}
 
42919
 
 
42920
SWIGINTERN int DatePickerCtrlNameStr_set(PyObject *) {
 
42921
  SWIG_Error(SWIG_AttributeError,"Variable DatePickerCtrlNameStr is read-only.");
 
42922
  return 1;
 
42923
}
 
42924
 
 
42925
 
 
42926
SWIGINTERN PyObject *DatePickerCtrlNameStr_get(void) {
 
42927
  PyObject *pyobj = 0;
 
42928
  
 
42929
  {
 
42930
#if wxUSE_UNICODE
 
42931
    pyobj = PyUnicode_FromWideChar((&wxPyDatePickerCtrlNameStr)->c_str(), (&wxPyDatePickerCtrlNameStr)->Len());
 
42932
#else
 
42933
    pyobj = PyString_FromStringAndSize((&wxPyDatePickerCtrlNameStr)->c_str(), (&wxPyDatePickerCtrlNameStr)->Len());
 
42934
#endif
 
42935
  }
 
42936
  return pyobj;
 
42937
}
 
42938
 
 
42939
 
 
42940
SWIGINTERN PyObject *_wrap_DatePickerCtrlBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
42941
  PyObject *resultobj = 0;
 
42942
  wxDatePickerCtrlBase *arg1 = (wxDatePickerCtrlBase *) 0 ;
 
42943
  wxDateTime *arg2 = 0 ;
 
42944
  void *argp1 = 0 ;
 
42945
  int res1 = 0 ;
 
42946
  void *argp2 = 0 ;
 
42947
  int res2 = 0 ;
 
42948
  PyObject * obj0 = 0 ;
 
42949
  PyObject * obj1 = 0 ;
 
42950
  char *  kwnames[] = {
 
42951
    (char *) "self",(char *) "dt", NULL 
 
42952
  };
 
42953
  
 
42954
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DatePickerCtrlBase_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
 
42955
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDatePickerCtrlBase, 0 |  0 );
 
42956
  if (!SWIG_IsOK(res1)) {
 
42957
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatePickerCtrlBase_SetValue" "', expected argument " "1"" of type '" "wxDatePickerCtrlBase *""'"); 
 
42958
  }
 
42959
  arg1 = reinterpret_cast< wxDatePickerCtrlBase * >(argp1);
 
42960
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime,  0  | 0);
 
42961
  if (!SWIG_IsOK(res2)) {
 
42962
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DatePickerCtrlBase_SetValue" "', expected argument " "2"" of type '" "wxDateTime const &""'"); 
 
42963
  }
 
42964
  if (!argp2) {
 
42965
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DatePickerCtrlBase_SetValue" "', expected argument " "2"" of type '" "wxDateTime const &""'"); 
 
42966
  }
 
42967
  arg2 = reinterpret_cast< wxDateTime * >(argp2);
 
42968
  {
 
42969
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42970
    (arg1)->SetValue((wxDateTime const &)*arg2);
 
42971
    wxPyEndAllowThreads(__tstate);
 
42972
    if (PyErr_Occurred()) SWIG_fail;
 
42973
  }
 
42974
  resultobj = SWIG_Py_Void();
 
42975
  return resultobj;
 
42976
fail:
 
42977
  return NULL;
 
42978
}
 
42979
 
 
42980
 
 
42981
SWIGINTERN PyObject *_wrap_DatePickerCtrlBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
42982
  PyObject *resultobj = 0;
 
42983
  wxDatePickerCtrlBase *arg1 = (wxDatePickerCtrlBase *) 0 ;
 
42984
  wxDateTime result;
 
42985
  void *argp1 = 0 ;
 
42986
  int res1 = 0 ;
 
42987
  PyObject *swig_obj[1] ;
 
42988
  
 
42989
  if (!args) SWIG_fail;
 
42990
  swig_obj[0] = args;
 
42991
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDatePickerCtrlBase, 0 |  0 );
 
42992
  if (!SWIG_IsOK(res1)) {
 
42993
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatePickerCtrlBase_GetValue" "', expected argument " "1"" of type '" "wxDatePickerCtrlBase const *""'"); 
 
42994
  }
 
42995
  arg1 = reinterpret_cast< wxDatePickerCtrlBase * >(argp1);
 
42996
  {
 
42997
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
42998
    result = ((wxDatePickerCtrlBase const *)arg1)->GetValue();
 
42999
    wxPyEndAllowThreads(__tstate);
 
43000
    if (PyErr_Occurred()) SWIG_fail;
 
43001
  }
 
43002
  resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN |  0 );
 
43003
  return resultobj;
 
43004
fail:
 
43005
  return NULL;
 
43006
}
 
43007
 
 
43008
 
 
43009
SWIGINTERN PyObject *_wrap_DatePickerCtrlBase_SetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
43010
  PyObject *resultobj = 0;
 
43011
  wxDatePickerCtrlBase *arg1 = (wxDatePickerCtrlBase *) 0 ;
 
43012
  wxDateTime *arg2 = 0 ;
 
43013
  wxDateTime *arg3 = 0 ;
 
43014
  void *argp1 = 0 ;
 
43015
  int res1 = 0 ;
 
43016
  void *argp2 = 0 ;
 
43017
  int res2 = 0 ;
 
43018
  void *argp3 = 0 ;
 
43019
  int res3 = 0 ;
 
43020
  PyObject * obj0 = 0 ;
 
43021
  PyObject * obj1 = 0 ;
 
43022
  PyObject * obj2 = 0 ;
 
43023
  char *  kwnames[] = {
 
43024
    (char *) "self",(char *) "dt1",(char *) "dt2", NULL 
 
43025
  };
 
43026
  
 
43027
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DatePickerCtrlBase_SetRange",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
43028
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDatePickerCtrlBase, 0 |  0 );
 
43029
  if (!SWIG_IsOK(res1)) {
 
43030
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatePickerCtrlBase_SetRange" "', expected argument " "1"" of type '" "wxDatePickerCtrlBase *""'"); 
 
43031
  }
 
43032
  arg1 = reinterpret_cast< wxDatePickerCtrlBase * >(argp1);
 
43033
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime,  0  | 0);
 
43034
  if (!SWIG_IsOK(res2)) {
 
43035
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DatePickerCtrlBase_SetRange" "', expected argument " "2"" of type '" "wxDateTime const &""'"); 
 
43036
  }
 
43037
  if (!argp2) {
 
43038
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DatePickerCtrlBase_SetRange" "', expected argument " "2"" of type '" "wxDateTime const &""'"); 
 
43039
  }
 
43040
  arg2 = reinterpret_cast< wxDateTime * >(argp2);
 
43041
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime,  0  | 0);
 
43042
  if (!SWIG_IsOK(res3)) {
 
43043
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DatePickerCtrlBase_SetRange" "', expected argument " "3"" of type '" "wxDateTime const &""'"); 
 
43044
  }
 
43045
  if (!argp3) {
 
43046
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DatePickerCtrlBase_SetRange" "', expected argument " "3"" of type '" "wxDateTime const &""'"); 
 
43047
  }
 
43048
  arg3 = reinterpret_cast< wxDateTime * >(argp3);
 
43049
  {
 
43050
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43051
    (arg1)->SetRange((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
 
43052
    wxPyEndAllowThreads(__tstate);
 
43053
    if (PyErr_Occurred()) SWIG_fail;
 
43054
  }
 
43055
  resultobj = SWIG_Py_Void();
 
43056
  return resultobj;
 
43057
fail:
 
43058
  return NULL;
 
43059
}
 
43060
 
 
43061
 
 
43062
SWIGINTERN PyObject *_wrap_DatePickerCtrlBase_GetLowerLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
43063
  PyObject *resultobj = 0;
 
43064
  wxDatePickerCtrlBase *arg1 = (wxDatePickerCtrlBase *) 0 ;
 
43065
  wxDateTime result;
 
43066
  void *argp1 = 0 ;
 
43067
  int res1 = 0 ;
 
43068
  PyObject *swig_obj[1] ;
 
43069
  
 
43070
  if (!args) SWIG_fail;
 
43071
  swig_obj[0] = args;
 
43072
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDatePickerCtrlBase, 0 |  0 );
 
43073
  if (!SWIG_IsOK(res1)) {
 
43074
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatePickerCtrlBase_GetLowerLimit" "', expected argument " "1"" of type '" "wxDatePickerCtrlBase *""'"); 
 
43075
  }
 
43076
  arg1 = reinterpret_cast< wxDatePickerCtrlBase * >(argp1);
 
43077
  {
 
43078
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43079
    result = wxDatePickerCtrlBase_GetLowerLimit(arg1);
 
43080
    wxPyEndAllowThreads(__tstate);
 
43081
    if (PyErr_Occurred()) SWIG_fail;
 
43082
  }
 
43083
  resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN |  0 );
 
43084
  return resultobj;
 
43085
fail:
 
43086
  return NULL;
 
43087
}
 
43088
 
 
43089
 
 
43090
SWIGINTERN PyObject *_wrap_DatePickerCtrlBase_GetUpperLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
43091
  PyObject *resultobj = 0;
 
43092
  wxDatePickerCtrlBase *arg1 = (wxDatePickerCtrlBase *) 0 ;
 
43093
  wxDateTime result;
 
43094
  void *argp1 = 0 ;
 
43095
  int res1 = 0 ;
 
43096
  PyObject *swig_obj[1] ;
 
43097
  
 
43098
  if (!args) SWIG_fail;
 
43099
  swig_obj[0] = args;
 
43100
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDatePickerCtrlBase, 0 |  0 );
 
43101
  if (!SWIG_IsOK(res1)) {
 
43102
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatePickerCtrlBase_GetUpperLimit" "', expected argument " "1"" of type '" "wxDatePickerCtrlBase *""'"); 
 
43103
  }
 
43104
  arg1 = reinterpret_cast< wxDatePickerCtrlBase * >(argp1);
 
43105
  {
 
43106
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43107
    result = wxDatePickerCtrlBase_GetUpperLimit(arg1);
 
43108
    wxPyEndAllowThreads(__tstate);
 
43109
    if (PyErr_Occurred()) SWIG_fail;
 
43110
  }
 
43111
  resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN |  0 );
 
43112
  return resultobj;
 
43113
fail:
 
43114
  return NULL;
 
43115
}
 
43116
 
 
43117
 
 
43118
SWIGINTERN PyObject *DatePickerCtrlBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
43119
  PyObject *obj;
 
43120
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
43121
  SWIG_TypeNewClientData(SWIGTYPE_p_wxDatePickerCtrlBase, SWIG_NewClientData(obj));
 
43122
  return SWIG_Py_Void();
 
43123
}
 
43124
 
 
43125
SWIGINTERN PyObject *_wrap_new_DatePickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
43126
  PyObject *resultobj = 0;
 
43127
  wxWindow *arg1 = (wxWindow *) 0 ;
 
43128
  int arg2 = (int) -1 ;
 
43129
  wxDateTime const &arg3_defvalue = wxDefaultDateTime ;
 
43130
  wxDateTime *arg3 = (wxDateTime *) &arg3_defvalue ;
 
43131
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
43132
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
43133
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
43134
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
43135
  long arg6 = (long) wxDP_DEFAULT|wxDP_SHOWCENTURY ;
 
43136
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
43137
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
43138
  wxString const &arg8_defvalue = wxPyDatePickerCtrlNameStr ;
 
43139
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
43140
  wxDatePickerCtrl *result = 0 ;
 
43141
  void *argp1 = 0 ;
 
43142
  int res1 = 0 ;
 
43143
  int val2 ;
 
43144
  int ecode2 = 0 ;
 
43145
  void *argp3 = 0 ;
 
43146
  int res3 = 0 ;
 
43147
  wxPoint temp4 ;
 
43148
  wxSize temp5 ;
 
43149
  long val6 ;
 
43150
  int ecode6 = 0 ;
 
43151
  void *argp7 = 0 ;
 
43152
  int res7 = 0 ;
 
43153
  bool temp8 = false ;
 
43154
  PyObject * obj0 = 0 ;
 
43155
  PyObject * obj1 = 0 ;
 
43156
  PyObject * obj2 = 0 ;
 
43157
  PyObject * obj3 = 0 ;
 
43158
  PyObject * obj4 = 0 ;
 
43159
  PyObject * obj5 = 0 ;
 
43160
  PyObject * obj6 = 0 ;
 
43161
  PyObject * obj7 = 0 ;
 
43162
  char *  kwnames[] = {
 
43163
    (char *) "parent",(char *) "id",(char *) "dt",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
43164
  };
 
43165
  
 
43166
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_DatePickerCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
43167
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
43168
  if (!SWIG_IsOK(res1)) {
 
43169
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DatePickerCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
43170
  }
 
43171
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
43172
  if (obj1) {
 
43173
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
43174
    if (!SWIG_IsOK(ecode2)) {
 
43175
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DatePickerCtrl" "', expected argument " "2"" of type '" "int""'");
 
43176
    } 
 
43177
    arg2 = static_cast< int >(val2);
 
43178
  }
 
43179
  if (obj2) {
 
43180
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime,  0  | 0);
 
43181
    if (!SWIG_IsOK(res3)) {
 
43182
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatePickerCtrl" "', expected argument " "3"" of type '" "wxDateTime const &""'"); 
 
43183
    }
 
43184
    if (!argp3) {
 
43185
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatePickerCtrl" "', expected argument " "3"" of type '" "wxDateTime const &""'"); 
 
43186
    }
 
43187
    arg3 = reinterpret_cast< wxDateTime * >(argp3);
 
43188
  }
 
43189
  if (obj3) {
 
43190
    {
 
43191
      arg4 = &temp4;
 
43192
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
43193
    }
 
43194
  }
 
43195
  if (obj4) {
 
43196
    {
 
43197
      arg5 = &temp5;
 
43198
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
43199
    }
 
43200
  }
 
43201
  if (obj5) {
 
43202
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
43203
    if (!SWIG_IsOK(ecode6)) {
 
43204
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DatePickerCtrl" "', expected argument " "6"" of type '" "long""'");
 
43205
    } 
 
43206
    arg6 = static_cast< long >(val6);
 
43207
  }
 
43208
  if (obj6) {
 
43209
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
43210
    if (!SWIG_IsOK(res7)) {
 
43211
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DatePickerCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
43212
    }
 
43213
    if (!argp7) {
 
43214
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatePickerCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
43215
    }
 
43216
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
43217
  }
 
43218
  if (obj7) {
 
43219
    {
 
43220
      arg8 = wxString_in_helper(obj7);
 
43221
      if (arg8 == NULL) SWIG_fail;
 
43222
      temp8 = true;
 
43223
    }
 
43224
  }
 
43225
  {
 
43226
    if (!wxPyCheckForApp()) SWIG_fail;
 
43227
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43228
    result = (wxDatePickerCtrl *)new wxDatePickerCtrl(arg1,arg2,(wxDateTime const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
43229
    wxPyEndAllowThreads(__tstate);
 
43230
    if (PyErr_Occurred()) SWIG_fail;
 
43231
  }
 
43232
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDatePickerCtrl, SWIG_POINTER_NEW |  0 );
 
43233
  {
 
43234
    if (temp8)
 
43235
    delete arg8;
 
43236
  }
 
43237
  return resultobj;
 
43238
fail:
 
43239
  {
 
43240
    if (temp8)
 
43241
    delete arg8;
 
43242
  }
 
43243
  return NULL;
 
43244
}
 
43245
 
 
43246
 
 
43247
SWIGINTERN PyObject *_wrap_new_PreDatePickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
43248
  PyObject *resultobj = 0;
 
43249
  wxDatePickerCtrl *result = 0 ;
 
43250
  
 
43251
  if (!SWIG_Python_UnpackTuple(args,"new_PreDatePickerCtrl",0,0,0)) SWIG_fail;
 
43252
  {
 
43253
    if (!wxPyCheckForApp()) SWIG_fail;
 
43254
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43255
    result = (wxDatePickerCtrl *)new wxDatePickerCtrl();
 
43256
    wxPyEndAllowThreads(__tstate);
 
43257
    if (PyErr_Occurred()) SWIG_fail;
 
43258
  }
 
43259
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDatePickerCtrl, SWIG_POINTER_OWN |  0 );
 
43260
  return resultobj;
 
43261
fail:
 
43262
  return NULL;
 
43263
}
 
43264
 
 
43265
 
 
43266
SWIGINTERN PyObject *_wrap_DatePickerCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
43267
  PyObject *resultobj = 0;
 
43268
  wxDatePickerCtrl *arg1 = (wxDatePickerCtrl *) 0 ;
 
43269
  wxWindow *arg2 = (wxWindow *) 0 ;
 
43270
  int arg3 = (int) -1 ;
 
43271
  wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
 
43272
  wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
 
43273
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
43274
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
43275
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
43276
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
43277
  long arg7 = (long) wxDP_DEFAULT|wxDP_SHOWCENTURY ;
 
43278
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
43279
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
43280
  wxString const &arg9_defvalue = wxPyDatePickerCtrlNameStr ;
 
43281
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
43282
  bool result;
 
43283
  void *argp1 = 0 ;
 
43284
  int res1 = 0 ;
 
43285
  void *argp2 = 0 ;
 
43286
  int res2 = 0 ;
 
43287
  int val3 ;
 
43288
  int ecode3 = 0 ;
 
43289
  void *argp4 = 0 ;
 
43290
  int res4 = 0 ;
 
43291
  wxPoint temp5 ;
 
43292
  wxSize temp6 ;
 
43293
  long val7 ;
 
43294
  int ecode7 = 0 ;
 
43295
  void *argp8 = 0 ;
 
43296
  int res8 = 0 ;
 
43297
  bool temp9 = false ;
 
43298
  PyObject * obj0 = 0 ;
 
43299
  PyObject * obj1 = 0 ;
 
43300
  PyObject * obj2 = 0 ;
 
43301
  PyObject * obj3 = 0 ;
 
43302
  PyObject * obj4 = 0 ;
 
43303
  PyObject * obj5 = 0 ;
 
43304
  PyObject * obj6 = 0 ;
 
43305
  PyObject * obj7 = 0 ;
 
43306
  PyObject * obj8 = 0 ;
 
43307
  char *  kwnames[] = {
 
43308
    (char *) "self",(char *) "parent",(char *) "id",(char *) "dt",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
43309
  };
 
43310
  
 
43311
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:DatePickerCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
43312
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDatePickerCtrl, 0 |  0 );
 
43313
  if (!SWIG_IsOK(res1)) {
 
43314
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatePickerCtrl_Create" "', expected argument " "1"" of type '" "wxDatePickerCtrl *""'"); 
 
43315
  }
 
43316
  arg1 = reinterpret_cast< wxDatePickerCtrl * >(argp1);
 
43317
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
43318
  if (!SWIG_IsOK(res2)) {
 
43319
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DatePickerCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
43320
  }
 
43321
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
43322
  if (obj2) {
 
43323
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
43324
    if (!SWIG_IsOK(ecode3)) {
 
43325
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DatePickerCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
43326
    } 
 
43327
    arg3 = static_cast< int >(val3);
 
43328
  }
 
43329
  if (obj3) {
 
43330
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime,  0  | 0);
 
43331
    if (!SWIG_IsOK(res4)) {
 
43332
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DatePickerCtrl_Create" "', expected argument " "4"" of type '" "wxDateTime const &""'"); 
 
43333
    }
 
43334
    if (!argp4) {
 
43335
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DatePickerCtrl_Create" "', expected argument " "4"" of type '" "wxDateTime const &""'"); 
 
43336
    }
 
43337
    arg4 = reinterpret_cast< wxDateTime * >(argp4);
 
43338
  }
 
43339
  if (obj4) {
 
43340
    {
 
43341
      arg5 = &temp5;
 
43342
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
43343
    }
 
43344
  }
 
43345
  if (obj5) {
 
43346
    {
 
43347
      arg6 = &temp6;
 
43348
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
43349
    }
 
43350
  }
 
43351
  if (obj6) {
 
43352
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
43353
    if (!SWIG_IsOK(ecode7)) {
 
43354
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DatePickerCtrl_Create" "', expected argument " "7"" of type '" "long""'");
 
43355
    } 
 
43356
    arg7 = static_cast< long >(val7);
 
43357
  }
 
43358
  if (obj7) {
 
43359
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
43360
    if (!SWIG_IsOK(res8)) {
 
43361
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "DatePickerCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
43362
    }
 
43363
    if (!argp8) {
 
43364
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DatePickerCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
43365
    }
 
43366
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
43367
  }
 
43368
  if (obj8) {
 
43369
    {
 
43370
      arg9 = wxString_in_helper(obj8);
 
43371
      if (arg9 == NULL) SWIG_fail;
 
43372
      temp9 = true;
 
43373
    }
 
43374
  }
 
43375
  {
 
43376
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43377
    result = (bool)(arg1)->Create(arg2,arg3,(wxDateTime const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
43378
    wxPyEndAllowThreads(__tstate);
 
43379
    if (PyErr_Occurred()) SWIG_fail;
 
43380
  }
 
43381
  {
 
43382
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
43383
  }
 
43384
  {
 
43385
    if (temp9)
 
43386
    delete arg9;
 
43387
  }
 
43388
  return resultobj;
 
43389
fail:
 
43390
  {
 
43391
    if (temp9)
 
43392
    delete arg9;
 
43393
  }
 
43394
  return NULL;
 
43395
}
 
43396
 
 
43397
 
 
43398
SWIGINTERN PyObject *DatePickerCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
43399
  PyObject *obj;
 
43400
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
43401
  SWIG_TypeNewClientData(SWIGTYPE_p_wxDatePickerCtrl, SWIG_NewClientData(obj));
 
43402
  return SWIG_Py_Void();
 
43403
}
 
43404
 
 
43405
SWIGINTERN PyObject *DatePickerCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
43406
  return SWIG_Python_InitShadowInstance(args);
 
43407
}
 
43408
 
 
43409
SWIGINTERN PyObject *_wrap_new_GenericDatePickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
43410
  PyObject *resultobj = 0;
 
43411
  wxWindow *arg1 = (wxWindow *) 0 ;
 
43412
  int arg2 = (int) -1 ;
 
43413
  wxDateTime const &arg3_defvalue = wxDefaultDateTime ;
 
43414
  wxDateTime *arg3 = (wxDateTime *) &arg3_defvalue ;
 
43415
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
43416
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
43417
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
43418
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
43419
  long arg6 = (long) wxDP_DEFAULT|wxDP_SHOWCENTURY ;
 
43420
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
43421
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
43422
  wxString const &arg8_defvalue = wxPyDatePickerCtrlNameStr ;
 
43423
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
43424
  wxDatePickerCtrlGeneric *result = 0 ;
 
43425
  void *argp1 = 0 ;
 
43426
  int res1 = 0 ;
 
43427
  int val2 ;
 
43428
  int ecode2 = 0 ;
 
43429
  void *argp3 = 0 ;
 
43430
  int res3 = 0 ;
 
43431
  wxPoint temp4 ;
 
43432
  wxSize temp5 ;
 
43433
  long val6 ;
 
43434
  int ecode6 = 0 ;
 
43435
  void *argp7 = 0 ;
 
43436
  int res7 = 0 ;
 
43437
  bool temp8 = false ;
 
43438
  PyObject * obj0 = 0 ;
 
43439
  PyObject * obj1 = 0 ;
 
43440
  PyObject * obj2 = 0 ;
 
43441
  PyObject * obj3 = 0 ;
 
43442
  PyObject * obj4 = 0 ;
 
43443
  PyObject * obj5 = 0 ;
 
43444
  PyObject * obj6 = 0 ;
 
43445
  PyObject * obj7 = 0 ;
 
43446
  char *  kwnames[] = {
 
43447
    (char *) "parent",(char *) "id",(char *) "dt",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
43448
  };
 
43449
  
 
43450
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_GenericDatePickerCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
43451
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
43452
  if (!SWIG_IsOK(res1)) {
 
43453
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GenericDatePickerCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
43454
  }
 
43455
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
43456
  if (obj1) {
 
43457
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
43458
    if (!SWIG_IsOK(ecode2)) {
 
43459
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GenericDatePickerCtrl" "', expected argument " "2"" of type '" "int""'");
 
43460
    } 
 
43461
    arg2 = static_cast< int >(val2);
 
43462
  }
 
43463
  if (obj2) {
 
43464
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime,  0  | 0);
 
43465
    if (!SWIG_IsOK(res3)) {
 
43466
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GenericDatePickerCtrl" "', expected argument " "3"" of type '" "wxDateTime const &""'"); 
 
43467
    }
 
43468
    if (!argp3) {
 
43469
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenericDatePickerCtrl" "', expected argument " "3"" of type '" "wxDateTime const &""'"); 
 
43470
    }
 
43471
    arg3 = reinterpret_cast< wxDateTime * >(argp3);
 
43472
  }
 
43473
  if (obj3) {
 
43474
    {
 
43475
      arg4 = &temp4;
 
43476
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
43477
    }
 
43478
  }
 
43479
  if (obj4) {
 
43480
    {
 
43481
      arg5 = &temp5;
 
43482
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
43483
    }
 
43484
  }
 
43485
  if (obj5) {
 
43486
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
43487
    if (!SWIG_IsOK(ecode6)) {
 
43488
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GenericDatePickerCtrl" "', expected argument " "6"" of type '" "long""'");
 
43489
    } 
 
43490
    arg6 = static_cast< long >(val6);
 
43491
  }
 
43492
  if (obj6) {
 
43493
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
43494
    if (!SWIG_IsOK(res7)) {
 
43495
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_GenericDatePickerCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
43496
    }
 
43497
    if (!argp7) {
 
43498
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GenericDatePickerCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
43499
    }
 
43500
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
43501
  }
 
43502
  if (obj7) {
 
43503
    {
 
43504
      arg8 = wxString_in_helper(obj7);
 
43505
      if (arg8 == NULL) SWIG_fail;
 
43506
      temp8 = true;
 
43507
    }
 
43508
  }
 
43509
  {
 
43510
    if (!wxPyCheckForApp()) SWIG_fail;
 
43511
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43512
    result = (wxDatePickerCtrlGeneric *)new wxDatePickerCtrlGeneric(arg1,arg2,(wxDateTime const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
43513
    wxPyEndAllowThreads(__tstate);
 
43514
    if (PyErr_Occurred()) SWIG_fail;
 
43515
  }
 
43516
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDatePickerCtrlGeneric, SWIG_POINTER_NEW |  0 );
 
43517
  {
 
43518
    if (temp8)
 
43519
    delete arg8;
 
43520
  }
 
43521
  return resultobj;
 
43522
fail:
 
43523
  {
 
43524
    if (temp8)
 
43525
    delete arg8;
 
43526
  }
 
43527
  return NULL;
 
43528
}
 
43529
 
 
43530
 
 
43531
SWIGINTERN PyObject *_wrap_new_PreGenericDatePickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
43532
  PyObject *resultobj = 0;
 
43533
  wxDatePickerCtrlGeneric *result = 0 ;
 
43534
  
 
43535
  if (!SWIG_Python_UnpackTuple(args,"new_PreGenericDatePickerCtrl",0,0,0)) SWIG_fail;
 
43536
  {
 
43537
    if (!wxPyCheckForApp()) SWIG_fail;
 
43538
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43539
    result = (wxDatePickerCtrlGeneric *)new wxDatePickerCtrlGeneric();
 
43540
    wxPyEndAllowThreads(__tstate);
 
43541
    if (PyErr_Occurred()) SWIG_fail;
 
43542
  }
 
43543
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDatePickerCtrlGeneric, SWIG_POINTER_OWN |  0 );
 
43544
  return resultobj;
 
43545
fail:
 
43546
  return NULL;
 
43547
}
 
43548
 
 
43549
 
 
43550
SWIGINTERN PyObject *_wrap_GenericDatePickerCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
43551
  PyObject *resultobj = 0;
 
43552
  wxDatePickerCtrlGeneric *arg1 = (wxDatePickerCtrlGeneric *) 0 ;
 
43553
  wxWindow *arg2 = (wxWindow *) 0 ;
 
43554
  int arg3 = (int) -1 ;
 
43555
  wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
 
43556
  wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
 
43557
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
43558
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
43559
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
43560
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
43561
  long arg7 = (long) wxDP_DEFAULT|wxDP_SHOWCENTURY ;
 
43562
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
43563
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
43564
  wxString const &arg9_defvalue = wxPyDatePickerCtrlNameStr ;
 
43565
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
43566
  bool result;
 
43567
  void *argp1 = 0 ;
 
43568
  int res1 = 0 ;
 
43569
  void *argp2 = 0 ;
 
43570
  int res2 = 0 ;
 
43571
  int val3 ;
 
43572
  int ecode3 = 0 ;
 
43573
  void *argp4 = 0 ;
 
43574
  int res4 = 0 ;
 
43575
  wxPoint temp5 ;
 
43576
  wxSize temp6 ;
 
43577
  long val7 ;
 
43578
  int ecode7 = 0 ;
 
43579
  void *argp8 = 0 ;
 
43580
  int res8 = 0 ;
 
43581
  bool temp9 = false ;
 
43582
  PyObject * obj0 = 0 ;
 
43583
  PyObject * obj1 = 0 ;
 
43584
  PyObject * obj2 = 0 ;
 
43585
  PyObject * obj3 = 0 ;
 
43586
  PyObject * obj4 = 0 ;
 
43587
  PyObject * obj5 = 0 ;
 
43588
  PyObject * obj6 = 0 ;
 
43589
  PyObject * obj7 = 0 ;
 
43590
  PyObject * obj8 = 0 ;
 
43591
  char *  kwnames[] = {
 
43592
    (char *) "self",(char *) "parent",(char *) "id",(char *) "dt",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
43593
  };
 
43594
  
 
43595
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:GenericDatePickerCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
43596
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDatePickerCtrlGeneric, 0 |  0 );
 
43597
  if (!SWIG_IsOK(res1)) {
 
43598
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenericDatePickerCtrl_Create" "', expected argument " "1"" of type '" "wxDatePickerCtrlGeneric *""'"); 
 
43599
  }
 
43600
  arg1 = reinterpret_cast< wxDatePickerCtrlGeneric * >(argp1);
 
43601
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
43602
  if (!SWIG_IsOK(res2)) {
 
43603
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenericDatePickerCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
43604
  }
 
43605
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
43606
  if (obj2) {
 
43607
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
43608
    if (!SWIG_IsOK(ecode3)) {
 
43609
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenericDatePickerCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
43610
    } 
 
43611
    arg3 = static_cast< int >(val3);
 
43612
  }
 
43613
  if (obj3) {
 
43614
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime,  0  | 0);
 
43615
    if (!SWIG_IsOK(res4)) {
 
43616
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GenericDatePickerCtrl_Create" "', expected argument " "4"" of type '" "wxDateTime const &""'"); 
 
43617
    }
 
43618
    if (!argp4) {
 
43619
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericDatePickerCtrl_Create" "', expected argument " "4"" of type '" "wxDateTime const &""'"); 
 
43620
    }
 
43621
    arg4 = reinterpret_cast< wxDateTime * >(argp4);
 
43622
  }
 
43623
  if (obj4) {
 
43624
    {
 
43625
      arg5 = &temp5;
 
43626
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
43627
    }
 
43628
  }
 
43629
  if (obj5) {
 
43630
    {
 
43631
      arg6 = &temp6;
 
43632
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
43633
    }
 
43634
  }
 
43635
  if (obj6) {
 
43636
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
43637
    if (!SWIG_IsOK(ecode7)) {
 
43638
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GenericDatePickerCtrl_Create" "', expected argument " "7"" of type '" "long""'");
 
43639
    } 
 
43640
    arg7 = static_cast< long >(val7);
 
43641
  }
 
43642
  if (obj7) {
 
43643
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
43644
    if (!SWIG_IsOK(res8)) {
 
43645
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "GenericDatePickerCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
43646
    }
 
43647
    if (!argp8) {
 
43648
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenericDatePickerCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
43649
    }
 
43650
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
43651
  }
 
43652
  if (obj8) {
 
43653
    {
 
43654
      arg9 = wxString_in_helper(obj8);
 
43655
      if (arg9 == NULL) SWIG_fail;
 
43656
      temp9 = true;
 
43657
    }
 
43658
  }
 
43659
  {
 
43660
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43661
    result = (bool)(arg1)->Create(arg2,arg3,(wxDateTime const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
43662
    wxPyEndAllowThreads(__tstate);
 
43663
    if (PyErr_Occurred()) SWIG_fail;
 
43664
  }
 
43665
  {
 
43666
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
43667
  }
 
43668
  {
 
43669
    if (temp9)
 
43670
    delete arg9;
 
43671
  }
 
43672
  return resultobj;
 
43673
fail:
 
43674
  {
 
43675
    if (temp9)
 
43676
    delete arg9;
 
43677
  }
 
43678
  return NULL;
 
43679
}
 
43680
 
 
43681
 
 
43682
SWIGINTERN PyObject *GenericDatePickerCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
43683
  PyObject *obj;
 
43684
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
43685
  SWIG_TypeNewClientData(SWIGTYPE_p_wxDatePickerCtrlGeneric, SWIG_NewClientData(obj));
 
43686
  return SWIG_Py_Void();
 
43687
}
 
43688
 
 
43689
SWIGINTERN PyObject *GenericDatePickerCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
43690
  return SWIG_Python_InitShadowInstance(args);
 
43691
}
 
43692
 
 
43693
SWIGINTERN int HyperlinkCtrlNameStr_set(PyObject *) {
 
43694
  SWIG_Error(SWIG_AttributeError,"Variable HyperlinkCtrlNameStr is read-only.");
 
43695
  return 1;
 
43696
}
 
43697
 
 
43698
 
 
43699
SWIGINTERN PyObject *HyperlinkCtrlNameStr_get(void) {
 
43700
  PyObject *pyobj = 0;
 
43701
  
 
43702
  {
 
43703
#if wxUSE_UNICODE
 
43704
    pyobj = PyUnicode_FromWideChar((&wxPyHyperlinkCtrlNameStr)->c_str(), (&wxPyHyperlinkCtrlNameStr)->Len());
 
43705
#else
 
43706
    pyobj = PyString_FromStringAndSize((&wxPyHyperlinkCtrlNameStr)->c_str(), (&wxPyHyperlinkCtrlNameStr)->Len());
 
43707
#endif
 
43708
  }
 
43709
  return pyobj;
 
43710
}
 
43711
 
 
43712
 
 
43713
SWIGINTERN PyObject *_wrap_new_HyperlinkCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
43714
  PyObject *resultobj = 0;
 
43715
  wxWindow *arg1 = (wxWindow *) 0 ;
 
43716
  int arg2 = (int) -1 ;
 
43717
  wxString const &arg3_defvalue = wxEmptyString ;
 
43718
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
43719
  wxString const &arg4_defvalue = wxEmptyString ;
 
43720
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
43721
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
43722
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
43723
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
43724
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
43725
  long arg7 = (long) wxHL_DEFAULT_STYLE ;
 
43726
  wxString const &arg8_defvalue = wxPyHyperlinkCtrlNameStr ;
 
43727
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
43728
  wxHyperlinkCtrl *result = 0 ;
 
43729
  void *argp1 = 0 ;
 
43730
  int res1 = 0 ;
 
43731
  int val2 ;
 
43732
  int ecode2 = 0 ;
 
43733
  bool temp3 = false ;
 
43734
  bool temp4 = false ;
 
43735
  wxPoint temp5 ;
 
43736
  wxSize temp6 ;
 
43737
  long val7 ;
 
43738
  int ecode7 = 0 ;
 
43739
  bool temp8 = false ;
 
43740
  PyObject * obj0 = 0 ;
 
43741
  PyObject * obj1 = 0 ;
 
43742
  PyObject * obj2 = 0 ;
 
43743
  PyObject * obj3 = 0 ;
 
43744
  PyObject * obj4 = 0 ;
 
43745
  PyObject * obj5 = 0 ;
 
43746
  PyObject * obj6 = 0 ;
 
43747
  PyObject * obj7 = 0 ;
 
43748
  char *  kwnames[] = {
 
43749
    (char *) "parent",(char *) "id",(char *) "label",(char *) "url",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
43750
  };
 
43751
  
 
43752
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_HyperlinkCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
43753
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
43754
  if (!SWIG_IsOK(res1)) {
 
43755
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HyperlinkCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
43756
  }
 
43757
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
43758
  if (obj1) {
 
43759
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
43760
    if (!SWIG_IsOK(ecode2)) {
 
43761
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HyperlinkCtrl" "', expected argument " "2"" of type '" "int""'");
 
43762
    } 
 
43763
    arg2 = static_cast< int >(val2);
 
43764
  }
 
43765
  if (obj2) {
 
43766
    {
 
43767
      arg3 = wxString_in_helper(obj2);
 
43768
      if (arg3 == NULL) SWIG_fail;
 
43769
      temp3 = true;
 
43770
    }
 
43771
  }
 
43772
  if (obj3) {
 
43773
    {
 
43774
      arg4 = wxString_in_helper(obj3);
 
43775
      if (arg4 == NULL) SWIG_fail;
 
43776
      temp4 = true;
 
43777
    }
 
43778
  }
 
43779
  if (obj4) {
 
43780
    {
 
43781
      arg5 = &temp5;
 
43782
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
43783
    }
 
43784
  }
 
43785
  if (obj5) {
 
43786
    {
 
43787
      arg6 = &temp6;
 
43788
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
43789
    }
 
43790
  }
 
43791
  if (obj6) {
 
43792
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
43793
    if (!SWIG_IsOK(ecode7)) {
 
43794
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HyperlinkCtrl" "', expected argument " "7"" of type '" "long""'");
 
43795
    } 
 
43796
    arg7 = static_cast< long >(val7);
 
43797
  }
 
43798
  if (obj7) {
 
43799
    {
 
43800
      arg8 = wxString_in_helper(obj7);
 
43801
      if (arg8 == NULL) SWIG_fail;
 
43802
      temp8 = true;
 
43803
    }
 
43804
  }
 
43805
  {
 
43806
    if (!wxPyCheckForApp()) SWIG_fail;
 
43807
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43808
    result = (wxHyperlinkCtrl *)new wxHyperlinkCtrl(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);
 
43809
    wxPyEndAllowThreads(__tstate);
 
43810
    if (PyErr_Occurred()) SWIG_fail;
 
43811
  }
 
43812
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxHyperlinkCtrl, SWIG_POINTER_NEW |  0 );
 
43813
  {
 
43814
    if (temp3)
 
43815
    delete arg3;
 
43816
  }
 
43817
  {
 
43818
    if (temp4)
 
43819
    delete arg4;
 
43820
  }
 
43821
  {
 
43822
    if (temp8)
 
43823
    delete arg8;
 
43824
  }
 
43825
  return resultobj;
 
43826
fail:
 
43827
  {
 
43828
    if (temp3)
 
43829
    delete arg3;
 
43830
  }
 
43831
  {
 
43832
    if (temp4)
 
43833
    delete arg4;
 
43834
  }
 
43835
  {
 
43836
    if (temp8)
 
43837
    delete arg8;
 
43838
  }
 
43839
  return NULL;
 
43840
}
 
43841
 
 
43842
 
 
43843
SWIGINTERN PyObject *_wrap_new_PreHyperlinkCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
43844
  PyObject *resultobj = 0;
 
43845
  wxHyperlinkCtrl *result = 0 ;
 
43846
  
 
43847
  if (!SWIG_Python_UnpackTuple(args,"new_PreHyperlinkCtrl",0,0,0)) SWIG_fail;
 
43848
  {
 
43849
    if (!wxPyCheckForApp()) SWIG_fail;
 
43850
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43851
    result = (wxHyperlinkCtrl *)new wxHyperlinkCtrl();
 
43852
    wxPyEndAllowThreads(__tstate);
 
43853
    if (PyErr_Occurred()) SWIG_fail;
 
43854
  }
 
43855
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxHyperlinkCtrl, SWIG_POINTER_OWN |  0 );
 
43856
  return resultobj;
 
43857
fail:
 
43858
  return NULL;
 
43859
}
 
43860
 
 
43861
 
 
43862
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
43863
  PyObject *resultobj = 0;
 
43864
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
43865
  wxWindow *arg2 = (wxWindow *) 0 ;
 
43866
  int arg3 = (int) -1 ;
 
43867
  wxString const &arg4_defvalue = wxEmptyString ;
 
43868
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
43869
  wxString const &arg5_defvalue = wxEmptyString ;
 
43870
  wxString *arg5 = (wxString *) &arg5_defvalue ;
 
43871
  wxPoint const &arg6_defvalue = wxDefaultPosition ;
 
43872
  wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
 
43873
  wxSize const &arg7_defvalue = wxDefaultSize ;
 
43874
  wxSize *arg7 = (wxSize *) &arg7_defvalue ;
 
43875
  long arg8 = (long) wxHL_DEFAULT_STYLE ;
 
43876
  wxString const &arg9_defvalue = wxPyHyperlinkCtrlNameStr ;
 
43877
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
43878
  bool result;
 
43879
  void *argp1 = 0 ;
 
43880
  int res1 = 0 ;
 
43881
  void *argp2 = 0 ;
 
43882
  int res2 = 0 ;
 
43883
  int val3 ;
 
43884
  int ecode3 = 0 ;
 
43885
  bool temp4 = false ;
 
43886
  bool temp5 = false ;
 
43887
  wxPoint temp6 ;
 
43888
  wxSize temp7 ;
 
43889
  long val8 ;
 
43890
  int ecode8 = 0 ;
 
43891
  bool temp9 = false ;
 
43892
  PyObject * obj0 = 0 ;
 
43893
  PyObject * obj1 = 0 ;
 
43894
  PyObject * obj2 = 0 ;
 
43895
  PyObject * obj3 = 0 ;
 
43896
  PyObject * obj4 = 0 ;
 
43897
  PyObject * obj5 = 0 ;
 
43898
  PyObject * obj6 = 0 ;
 
43899
  PyObject * obj7 = 0 ;
 
43900
  PyObject * obj8 = 0 ;
 
43901
  char *  kwnames[] = {
 
43902
    (char *) "self",(char *) "parent",(char *) "id",(char *) "label",(char *) "url",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL 
 
43903
  };
 
43904
  
 
43905
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:HyperlinkCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
43906
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
43907
  if (!SWIG_IsOK(res1)) {
 
43908
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_Create" "', expected argument " "1"" of type '" "wxHyperlinkCtrl *""'"); 
 
43909
  }
 
43910
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
43911
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
43912
  if (!SWIG_IsOK(res2)) {
 
43913
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperlinkCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
43914
  }
 
43915
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
43916
  if (obj2) {
 
43917
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
43918
    if (!SWIG_IsOK(ecode3)) {
 
43919
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HyperlinkCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
43920
    } 
 
43921
    arg3 = static_cast< int >(val3);
 
43922
  }
 
43923
  if (obj3) {
 
43924
    {
 
43925
      arg4 = wxString_in_helper(obj3);
 
43926
      if (arg4 == NULL) SWIG_fail;
 
43927
      temp4 = true;
 
43928
    }
 
43929
  }
 
43930
  if (obj4) {
 
43931
    {
 
43932
      arg5 = wxString_in_helper(obj4);
 
43933
      if (arg5 == NULL) SWIG_fail;
 
43934
      temp5 = true;
 
43935
    }
 
43936
  }
 
43937
  if (obj5) {
 
43938
    {
 
43939
      arg6 = &temp6;
 
43940
      if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
 
43941
    }
 
43942
  }
 
43943
  if (obj6) {
 
43944
    {
 
43945
      arg7 = &temp7;
 
43946
      if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
 
43947
    }
 
43948
  }
 
43949
  if (obj7) {
 
43950
    ecode8 = SWIG_AsVal_long(obj7, &val8);
 
43951
    if (!SWIG_IsOK(ecode8)) {
 
43952
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "HyperlinkCtrl_Create" "', expected argument " "8"" of type '" "long""'");
 
43953
    } 
 
43954
    arg8 = static_cast< long >(val8);
 
43955
  }
 
43956
  if (obj8) {
 
43957
    {
 
43958
      arg9 = wxString_in_helper(obj8);
 
43959
      if (arg9 == NULL) SWIG_fail;
 
43960
      temp9 = true;
 
43961
    }
 
43962
  }
 
43963
  {
 
43964
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
43965
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8,(wxString const &)*arg9);
 
43966
    wxPyEndAllowThreads(__tstate);
 
43967
    if (PyErr_Occurred()) SWIG_fail;
 
43968
  }
 
43969
  {
 
43970
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
43971
  }
 
43972
  {
 
43973
    if (temp4)
 
43974
    delete arg4;
 
43975
  }
 
43976
  {
 
43977
    if (temp5)
 
43978
    delete arg5;
 
43979
  }
 
43980
  {
 
43981
    if (temp9)
 
43982
    delete arg9;
 
43983
  }
 
43984
  return resultobj;
 
43985
fail:
 
43986
  {
 
43987
    if (temp4)
 
43988
    delete arg4;
 
43989
  }
 
43990
  {
 
43991
    if (temp5)
 
43992
    delete arg5;
 
43993
  }
 
43994
  {
 
43995
    if (temp9)
 
43996
    delete arg9;
 
43997
  }
 
43998
  return NULL;
 
43999
}
 
44000
 
 
44001
 
 
44002
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_GetHoverColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44003
  PyObject *resultobj = 0;
 
44004
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
44005
  wxColour result;
 
44006
  void *argp1 = 0 ;
 
44007
  int res1 = 0 ;
 
44008
  PyObject *swig_obj[1] ;
 
44009
  
 
44010
  if (!args) SWIG_fail;
 
44011
  swig_obj[0] = args;
 
44012
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
44013
  if (!SWIG_IsOK(res1)) {
 
44014
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_GetHoverColour" "', expected argument " "1"" of type '" "wxHyperlinkCtrl const *""'"); 
 
44015
  }
 
44016
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
44017
  {
 
44018
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44019
    result = ((wxHyperlinkCtrl const *)arg1)->GetHoverColour();
 
44020
    wxPyEndAllowThreads(__tstate);
 
44021
    if (PyErr_Occurred()) SWIG_fail;
 
44022
  }
 
44023
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
44024
  return resultobj;
 
44025
fail:
 
44026
  return NULL;
 
44027
}
 
44028
 
 
44029
 
 
44030
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_SetHoverColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44031
  PyObject *resultobj = 0;
 
44032
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
44033
  wxColour *arg2 = 0 ;
 
44034
  void *argp1 = 0 ;
 
44035
  int res1 = 0 ;
 
44036
  wxColour temp2 ;
 
44037
  PyObject * obj0 = 0 ;
 
44038
  PyObject * obj1 = 0 ;
 
44039
  char *  kwnames[] = {
 
44040
    (char *) "self",(char *) "colour", NULL 
 
44041
  };
 
44042
  
 
44043
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HyperlinkCtrl_SetHoverColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
44044
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
44045
  if (!SWIG_IsOK(res1)) {
 
44046
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_SetHoverColour" "', expected argument " "1"" of type '" "wxHyperlinkCtrl *""'"); 
 
44047
  }
 
44048
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
44049
  {
 
44050
    arg2 = &temp2;
 
44051
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
44052
  }
 
44053
  {
 
44054
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44055
    (arg1)->SetHoverColour((wxColour const &)*arg2);
 
44056
    wxPyEndAllowThreads(__tstate);
 
44057
    if (PyErr_Occurred()) SWIG_fail;
 
44058
  }
 
44059
  resultobj = SWIG_Py_Void();
 
44060
  return resultobj;
 
44061
fail:
 
44062
  return NULL;
 
44063
}
 
44064
 
 
44065
 
 
44066
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_GetNormalColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44067
  PyObject *resultobj = 0;
 
44068
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
44069
  wxColour result;
 
44070
  void *argp1 = 0 ;
 
44071
  int res1 = 0 ;
 
44072
  PyObject *swig_obj[1] ;
 
44073
  
 
44074
  if (!args) SWIG_fail;
 
44075
  swig_obj[0] = args;
 
44076
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
44077
  if (!SWIG_IsOK(res1)) {
 
44078
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_GetNormalColour" "', expected argument " "1"" of type '" "wxHyperlinkCtrl const *""'"); 
 
44079
  }
 
44080
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
44081
  {
 
44082
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44083
    result = ((wxHyperlinkCtrl const *)arg1)->GetNormalColour();
 
44084
    wxPyEndAllowThreads(__tstate);
 
44085
    if (PyErr_Occurred()) SWIG_fail;
 
44086
  }
 
44087
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
44088
  return resultobj;
 
44089
fail:
 
44090
  return NULL;
 
44091
}
 
44092
 
 
44093
 
 
44094
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_SetNormalColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44095
  PyObject *resultobj = 0;
 
44096
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
44097
  wxColour *arg2 = 0 ;
 
44098
  void *argp1 = 0 ;
 
44099
  int res1 = 0 ;
 
44100
  wxColour temp2 ;
 
44101
  PyObject * obj0 = 0 ;
 
44102
  PyObject * obj1 = 0 ;
 
44103
  char *  kwnames[] = {
 
44104
    (char *) "self",(char *) "colour", NULL 
 
44105
  };
 
44106
  
 
44107
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HyperlinkCtrl_SetNormalColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
44108
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
44109
  if (!SWIG_IsOK(res1)) {
 
44110
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_SetNormalColour" "', expected argument " "1"" of type '" "wxHyperlinkCtrl *""'"); 
 
44111
  }
 
44112
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
44113
  {
 
44114
    arg2 = &temp2;
 
44115
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
44116
  }
 
44117
  {
 
44118
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44119
    (arg1)->SetNormalColour((wxColour const &)*arg2);
 
44120
    wxPyEndAllowThreads(__tstate);
 
44121
    if (PyErr_Occurred()) SWIG_fail;
 
44122
  }
 
44123
  resultobj = SWIG_Py_Void();
 
44124
  return resultobj;
 
44125
fail:
 
44126
  return NULL;
 
44127
}
 
44128
 
 
44129
 
 
44130
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_GetVisitedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44131
  PyObject *resultobj = 0;
 
44132
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
44133
  wxColour result;
 
44134
  void *argp1 = 0 ;
 
44135
  int res1 = 0 ;
 
44136
  PyObject *swig_obj[1] ;
 
44137
  
 
44138
  if (!args) SWIG_fail;
 
44139
  swig_obj[0] = args;
 
44140
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
44141
  if (!SWIG_IsOK(res1)) {
 
44142
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_GetVisitedColour" "', expected argument " "1"" of type '" "wxHyperlinkCtrl const *""'"); 
 
44143
  }
 
44144
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
44145
  {
 
44146
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44147
    result = ((wxHyperlinkCtrl const *)arg1)->GetVisitedColour();
 
44148
    wxPyEndAllowThreads(__tstate);
 
44149
    if (PyErr_Occurred()) SWIG_fail;
 
44150
  }
 
44151
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
44152
  return resultobj;
 
44153
fail:
 
44154
  return NULL;
 
44155
}
 
44156
 
 
44157
 
 
44158
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_SetVisitedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44159
  PyObject *resultobj = 0;
 
44160
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
44161
  wxColour *arg2 = 0 ;
 
44162
  void *argp1 = 0 ;
 
44163
  int res1 = 0 ;
 
44164
  wxColour temp2 ;
 
44165
  PyObject * obj0 = 0 ;
 
44166
  PyObject * obj1 = 0 ;
 
44167
  char *  kwnames[] = {
 
44168
    (char *) "self",(char *) "colour", NULL 
 
44169
  };
 
44170
  
 
44171
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HyperlinkCtrl_SetVisitedColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
44172
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
44173
  if (!SWIG_IsOK(res1)) {
 
44174
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_SetVisitedColour" "', expected argument " "1"" of type '" "wxHyperlinkCtrl *""'"); 
 
44175
  }
 
44176
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
44177
  {
 
44178
    arg2 = &temp2;
 
44179
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
44180
  }
 
44181
  {
 
44182
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44183
    (arg1)->SetVisitedColour((wxColour const &)*arg2);
 
44184
    wxPyEndAllowThreads(__tstate);
 
44185
    if (PyErr_Occurred()) SWIG_fail;
 
44186
  }
 
44187
  resultobj = SWIG_Py_Void();
 
44188
  return resultobj;
 
44189
fail:
 
44190
  return NULL;
 
44191
}
 
44192
 
 
44193
 
 
44194
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44195
  PyObject *resultobj = 0;
 
44196
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
44197
  wxString result;
 
44198
  void *argp1 = 0 ;
 
44199
  int res1 = 0 ;
 
44200
  PyObject *swig_obj[1] ;
 
44201
  
 
44202
  if (!args) SWIG_fail;
 
44203
  swig_obj[0] = args;
 
44204
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
44205
  if (!SWIG_IsOK(res1)) {
 
44206
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_GetURL" "', expected argument " "1"" of type '" "wxHyperlinkCtrl const *""'"); 
 
44207
  }
 
44208
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
44209
  {
 
44210
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44211
    result = ((wxHyperlinkCtrl const *)arg1)->GetURL();
 
44212
    wxPyEndAllowThreads(__tstate);
 
44213
    if (PyErr_Occurred()) SWIG_fail;
 
44214
  }
 
44215
  {
 
44216
#if wxUSE_UNICODE
 
44217
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
44218
#else
 
44219
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
44220
#endif
 
44221
  }
 
44222
  return resultobj;
 
44223
fail:
 
44224
  return NULL;
 
44225
}
 
44226
 
 
44227
 
 
44228
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44229
  PyObject *resultobj = 0;
 
44230
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
44231
  wxString *arg2 = 0 ;
 
44232
  void *argp1 = 0 ;
 
44233
  int res1 = 0 ;
 
44234
  bool temp2 = false ;
 
44235
  PyObject * obj0 = 0 ;
 
44236
  PyObject * obj1 = 0 ;
 
44237
  char *  kwnames[] = {
 
44238
    (char *) "self",(char *) "url", NULL 
 
44239
  };
 
44240
  
 
44241
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HyperlinkCtrl_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
 
44242
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
44243
  if (!SWIG_IsOK(res1)) {
 
44244
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_SetURL" "', expected argument " "1"" of type '" "wxHyperlinkCtrl *""'"); 
 
44245
  }
 
44246
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
44247
  {
 
44248
    arg2 = wxString_in_helper(obj1);
 
44249
    if (arg2 == NULL) SWIG_fail;
 
44250
    temp2 = true;
 
44251
  }
 
44252
  {
 
44253
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44254
    (arg1)->SetURL((wxString const &)*arg2);
 
44255
    wxPyEndAllowThreads(__tstate);
 
44256
    if (PyErr_Occurred()) SWIG_fail;
 
44257
  }
 
44258
  resultobj = SWIG_Py_Void();
 
44259
  {
 
44260
    if (temp2)
 
44261
    delete arg2;
 
44262
  }
 
44263
  return resultobj;
 
44264
fail:
 
44265
  {
 
44266
    if (temp2)
 
44267
    delete arg2;
 
44268
  }
 
44269
  return NULL;
 
44270
}
 
44271
 
 
44272
 
 
44273
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_SetVisited(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44274
  PyObject *resultobj = 0;
 
44275
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
44276
  bool arg2 = (bool) true ;
 
44277
  void *argp1 = 0 ;
 
44278
  int res1 = 0 ;
 
44279
  bool val2 ;
 
44280
  int ecode2 = 0 ;
 
44281
  PyObject * obj0 = 0 ;
 
44282
  PyObject * obj1 = 0 ;
 
44283
  char *  kwnames[] = {
 
44284
    (char *) "self",(char *) "visited", NULL 
 
44285
  };
 
44286
  
 
44287
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:HyperlinkCtrl_SetVisited",kwnames,&obj0,&obj1)) SWIG_fail;
 
44288
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
44289
  if (!SWIG_IsOK(res1)) {
 
44290
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_SetVisited" "', expected argument " "1"" of type '" "wxHyperlinkCtrl *""'"); 
 
44291
  }
 
44292
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
44293
  if (obj1) {
 
44294
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
44295
    if (!SWIG_IsOK(ecode2)) {
 
44296
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HyperlinkCtrl_SetVisited" "', expected argument " "2"" of type '" "bool""'");
 
44297
    } 
 
44298
    arg2 = static_cast< bool >(val2);
 
44299
  }
 
44300
  {
 
44301
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44302
    (arg1)->SetVisited(arg2);
 
44303
    wxPyEndAllowThreads(__tstate);
 
44304
    if (PyErr_Occurred()) SWIG_fail;
 
44305
  }
 
44306
  resultobj = SWIG_Py_Void();
 
44307
  return resultobj;
 
44308
fail:
 
44309
  return NULL;
 
44310
}
 
44311
 
 
44312
 
 
44313
SWIGINTERN PyObject *_wrap_HyperlinkCtrl_GetVisited(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44314
  PyObject *resultobj = 0;
 
44315
  wxHyperlinkCtrl *arg1 = (wxHyperlinkCtrl *) 0 ;
 
44316
  bool result;
 
44317
  void *argp1 = 0 ;
 
44318
  int res1 = 0 ;
 
44319
  PyObject *swig_obj[1] ;
 
44320
  
 
44321
  if (!args) SWIG_fail;
 
44322
  swig_obj[0] = args;
 
44323
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHyperlinkCtrl, 0 |  0 );
 
44324
  if (!SWIG_IsOK(res1)) {
 
44325
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkCtrl_GetVisited" "', expected argument " "1"" of type '" "wxHyperlinkCtrl const *""'"); 
 
44326
  }
 
44327
  arg1 = reinterpret_cast< wxHyperlinkCtrl * >(argp1);
 
44328
  {
 
44329
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44330
    result = (bool)((wxHyperlinkCtrl const *)arg1)->GetVisited();
 
44331
    wxPyEndAllowThreads(__tstate);
 
44332
    if (PyErr_Occurred()) SWIG_fail;
 
44333
  }
 
44334
  {
 
44335
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
44336
  }
 
44337
  return resultobj;
 
44338
fail:
 
44339
  return NULL;
 
44340
}
 
44341
 
 
44342
 
 
44343
SWIGINTERN PyObject *HyperlinkCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44344
  PyObject *obj;
 
44345
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
44346
  SWIG_TypeNewClientData(SWIGTYPE_p_wxHyperlinkCtrl, SWIG_NewClientData(obj));
 
44347
  return SWIG_Py_Void();
 
44348
}
 
44349
 
 
44350
SWIGINTERN PyObject *HyperlinkCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44351
  return SWIG_Python_InitShadowInstance(args);
 
44352
}
 
44353
 
 
44354
SWIGINTERN PyObject *_wrap_new_HyperlinkEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44355
  PyObject *resultobj = 0;
 
44356
  wxObject *arg1 = (wxObject *) 0 ;
 
44357
  int arg2 ;
 
44358
  wxString *arg3 = 0 ;
 
44359
  wxHyperlinkEvent *result = 0 ;
 
44360
  void *argp1 = 0 ;
 
44361
  int res1 = 0 ;
 
44362
  int val2 ;
 
44363
  int ecode2 = 0 ;
 
44364
  bool temp3 = false ;
 
44365
  PyObject * obj0 = 0 ;
 
44366
  PyObject * obj1 = 0 ;
 
44367
  PyObject * obj2 = 0 ;
 
44368
  char *  kwnames[] = {
 
44369
    (char *) "generator",(char *) "id",(char *) "url", NULL 
 
44370
  };
 
44371
  
 
44372
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_HyperlinkEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
44373
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 |  0 );
 
44374
  if (!SWIG_IsOK(res1)) {
 
44375
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HyperlinkEvent" "', expected argument " "1"" of type '" "wxObject *""'"); 
 
44376
  }
 
44377
  arg1 = reinterpret_cast< wxObject * >(argp1);
 
44378
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
44379
  if (!SWIG_IsOK(ecode2)) {
 
44380
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HyperlinkEvent" "', expected argument " "2"" of type '" "int""'");
 
44381
  } 
 
44382
  arg2 = static_cast< int >(val2);
 
44383
  {
 
44384
    arg3 = wxString_in_helper(obj2);
 
44385
    if (arg3 == NULL) SWIG_fail;
 
44386
    temp3 = true;
 
44387
  }
 
44388
  {
 
44389
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44390
    result = (wxHyperlinkEvent *)new wxHyperlinkEvent(arg1,arg2,(wxString const &)*arg3);
 
44391
    wxPyEndAllowThreads(__tstate);
 
44392
    if (PyErr_Occurred()) SWIG_fail;
 
44393
  }
 
44394
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxHyperlinkEvent, SWIG_POINTER_NEW |  0 );
 
44395
  {
 
44396
    if (temp3)
 
44397
    delete arg3;
 
44398
  }
 
44399
  return resultobj;
 
44400
fail:
 
44401
  {
 
44402
    if (temp3)
 
44403
    delete arg3;
 
44404
  }
 
44405
  return NULL;
 
44406
}
 
44407
 
 
44408
 
 
44409
SWIGINTERN PyObject *_wrap_HyperlinkEvent_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44410
  PyObject *resultobj = 0;
 
44411
  wxHyperlinkEvent *arg1 = (wxHyperlinkEvent *) 0 ;
 
44412
  wxString result;
 
44413
  void *argp1 = 0 ;
 
44414
  int res1 = 0 ;
 
44415
  PyObject *swig_obj[1] ;
 
44416
  
 
44417
  if (!args) SWIG_fail;
 
44418
  swig_obj[0] = args;
 
44419
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxHyperlinkEvent, 0 |  0 );
 
44420
  if (!SWIG_IsOK(res1)) {
 
44421
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkEvent_GetURL" "', expected argument " "1"" of type '" "wxHyperlinkEvent const *""'"); 
 
44422
  }
 
44423
  arg1 = reinterpret_cast< wxHyperlinkEvent * >(argp1);
 
44424
  {
 
44425
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44426
    result = ((wxHyperlinkEvent const *)arg1)->GetURL();
 
44427
    wxPyEndAllowThreads(__tstate);
 
44428
    if (PyErr_Occurred()) SWIG_fail;
 
44429
  }
 
44430
  {
 
44431
#if wxUSE_UNICODE
 
44432
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
44433
#else
 
44434
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
44435
#endif
 
44436
  }
 
44437
  return resultobj;
 
44438
fail:
 
44439
  return NULL;
 
44440
}
 
44441
 
 
44442
 
 
44443
SWIGINTERN PyObject *_wrap_HyperlinkEvent_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44444
  PyObject *resultobj = 0;
 
44445
  wxHyperlinkEvent *arg1 = (wxHyperlinkEvent *) 0 ;
 
44446
  wxString *arg2 = 0 ;
 
44447
  void *argp1 = 0 ;
 
44448
  int res1 = 0 ;
 
44449
  bool temp2 = false ;
 
44450
  PyObject * obj0 = 0 ;
 
44451
  PyObject * obj1 = 0 ;
 
44452
  char *  kwnames[] = {
 
44453
    (char *) "self",(char *) "url", NULL 
 
44454
  };
 
44455
  
 
44456
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:HyperlinkEvent_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
 
44457
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxHyperlinkEvent, 0 |  0 );
 
44458
  if (!SWIG_IsOK(res1)) {
 
44459
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperlinkEvent_SetURL" "', expected argument " "1"" of type '" "wxHyperlinkEvent *""'"); 
 
44460
  }
 
44461
  arg1 = reinterpret_cast< wxHyperlinkEvent * >(argp1);
 
44462
  {
 
44463
    arg2 = wxString_in_helper(obj1);
 
44464
    if (arg2 == NULL) SWIG_fail;
 
44465
    temp2 = true;
 
44466
  }
 
44467
  {
 
44468
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44469
    (arg1)->SetURL((wxString const &)*arg2);
 
44470
    wxPyEndAllowThreads(__tstate);
 
44471
    if (PyErr_Occurred()) SWIG_fail;
 
44472
  }
 
44473
  resultobj = SWIG_Py_Void();
 
44474
  {
 
44475
    if (temp2)
 
44476
    delete arg2;
 
44477
  }
 
44478
  return resultobj;
 
44479
fail:
 
44480
  {
 
44481
    if (temp2)
 
44482
    delete arg2;
 
44483
  }
 
44484
  return NULL;
 
44485
}
 
44486
 
 
44487
 
 
44488
SWIGINTERN PyObject *HyperlinkEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44489
  PyObject *obj;
 
44490
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
44491
  SWIG_TypeNewClientData(SWIGTYPE_p_wxHyperlinkEvent, SWIG_NewClientData(obj));
 
44492
  return SWIG_Py_Void();
 
44493
}
 
44494
 
 
44495
SWIGINTERN PyObject *HyperlinkEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44496
  return SWIG_Python_InitShadowInstance(args);
 
44497
}
 
44498
 
 
44499
SWIGINTERN PyObject *_wrap_PickerBase_CreateBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44500
  PyObject *resultobj = 0;
 
44501
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44502
  wxWindow *arg2 = (wxWindow *) 0 ;
 
44503
  int arg3 ;
 
44504
  wxString const &arg4_defvalue = wxEmptyString ;
 
44505
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
44506
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
44507
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
44508
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
44509
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
44510
  long arg7 = (long) 0 ;
 
44511
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
44512
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
44513
  wxString const &arg9_defvalue = wxButtonNameStr ;
 
44514
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
44515
  bool result;
 
44516
  void *argp1 = 0 ;
 
44517
  int res1 = 0 ;
 
44518
  void *argp2 = 0 ;
 
44519
  int res2 = 0 ;
 
44520
  int val3 ;
 
44521
  int ecode3 = 0 ;
 
44522
  bool temp4 = false ;
 
44523
  wxPoint temp5 ;
 
44524
  wxSize temp6 ;
 
44525
  long val7 ;
 
44526
  int ecode7 = 0 ;
 
44527
  void *argp8 = 0 ;
 
44528
  int res8 = 0 ;
 
44529
  bool temp9 = false ;
 
44530
  PyObject * obj0 = 0 ;
 
44531
  PyObject * obj1 = 0 ;
 
44532
  PyObject * obj2 = 0 ;
 
44533
  PyObject * obj3 = 0 ;
 
44534
  PyObject * obj4 = 0 ;
 
44535
  PyObject * obj5 = 0 ;
 
44536
  PyObject * obj6 = 0 ;
 
44537
  PyObject * obj7 = 0 ;
 
44538
  PyObject * obj8 = 0 ;
 
44539
  char *  kwnames[] = {
 
44540
    (char *) "self",(char *) "parent",(char *) "id",(char *) "text",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
44541
  };
 
44542
  
 
44543
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:PickerBase_CreateBase",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
44544
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44545
  if (!SWIG_IsOK(res1)) {
 
44546
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_CreateBase" "', expected argument " "1"" of type '" "wxPickerBase *""'"); 
 
44547
  }
 
44548
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44549
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
44550
  if (!SWIG_IsOK(res2)) {
 
44551
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PickerBase_CreateBase" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
44552
  }
 
44553
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
44554
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
44555
  if (!SWIG_IsOK(ecode3)) {
 
44556
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PickerBase_CreateBase" "', expected argument " "3"" of type '" "int""'");
 
44557
  } 
 
44558
  arg3 = static_cast< int >(val3);
 
44559
  if (obj3) {
 
44560
    {
 
44561
      arg4 = wxString_in_helper(obj3);
 
44562
      if (arg4 == NULL) SWIG_fail;
 
44563
      temp4 = true;
 
44564
    }
 
44565
  }
 
44566
  if (obj4) {
 
44567
    {
 
44568
      arg5 = &temp5;
 
44569
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
44570
    }
 
44571
  }
 
44572
  if (obj5) {
 
44573
    {
 
44574
      arg6 = &temp6;
 
44575
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
44576
    }
 
44577
  }
 
44578
  if (obj6) {
 
44579
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
44580
    if (!SWIG_IsOK(ecode7)) {
 
44581
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PickerBase_CreateBase" "', expected argument " "7"" of type '" "long""'");
 
44582
    } 
 
44583
    arg7 = static_cast< long >(val7);
 
44584
  }
 
44585
  if (obj7) {
 
44586
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
44587
    if (!SWIG_IsOK(res8)) {
 
44588
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "PickerBase_CreateBase" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
44589
    }
 
44590
    if (!argp8) {
 
44591
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PickerBase_CreateBase" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
44592
    }
 
44593
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
44594
  }
 
44595
  if (obj8) {
 
44596
    {
 
44597
      arg9 = wxString_in_helper(obj8);
 
44598
      if (arg9 == NULL) SWIG_fail;
 
44599
      temp9 = true;
 
44600
    }
 
44601
  }
 
44602
  {
 
44603
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44604
    result = (bool)(arg1)->CreateBase(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
44605
    wxPyEndAllowThreads(__tstate);
 
44606
    if (PyErr_Occurred()) SWIG_fail;
 
44607
  }
 
44608
  {
 
44609
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
44610
  }
 
44611
  {
 
44612
    if (temp4)
 
44613
    delete arg4;
 
44614
  }
 
44615
  {
 
44616
    if (temp9)
 
44617
    delete arg9;
 
44618
  }
 
44619
  return resultobj;
 
44620
fail:
 
44621
  {
 
44622
    if (temp4)
 
44623
    delete arg4;
 
44624
  }
 
44625
  {
 
44626
    if (temp9)
 
44627
    delete arg9;
 
44628
  }
 
44629
  return NULL;
 
44630
}
 
44631
 
 
44632
 
 
44633
SWIGINTERN PyObject *_wrap_PickerBase_SetInternalMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44634
  PyObject *resultobj = 0;
 
44635
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44636
  int arg2 ;
 
44637
  void *argp1 = 0 ;
 
44638
  int res1 = 0 ;
 
44639
  int val2 ;
 
44640
  int ecode2 = 0 ;
 
44641
  PyObject * obj0 = 0 ;
 
44642
  PyObject * obj1 = 0 ;
 
44643
  char *  kwnames[] = {
 
44644
    (char *) "self",(char *) "newmargin", NULL 
 
44645
  };
 
44646
  
 
44647
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PickerBase_SetInternalMargin",kwnames,&obj0,&obj1)) SWIG_fail;
 
44648
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44649
  if (!SWIG_IsOK(res1)) {
 
44650
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_SetInternalMargin" "', expected argument " "1"" of type '" "wxPickerBase *""'"); 
 
44651
  }
 
44652
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44653
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
44654
  if (!SWIG_IsOK(ecode2)) {
 
44655
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PickerBase_SetInternalMargin" "', expected argument " "2"" of type '" "int""'");
 
44656
  } 
 
44657
  arg2 = static_cast< int >(val2);
 
44658
  {
 
44659
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44660
    (arg1)->SetInternalMargin(arg2);
 
44661
    wxPyEndAllowThreads(__tstate);
 
44662
    if (PyErr_Occurred()) SWIG_fail;
 
44663
  }
 
44664
  resultobj = SWIG_Py_Void();
 
44665
  return resultobj;
 
44666
fail:
 
44667
  return NULL;
 
44668
}
 
44669
 
 
44670
 
 
44671
SWIGINTERN PyObject *_wrap_PickerBase_GetInternalMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44672
  PyObject *resultobj = 0;
 
44673
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44674
  int result;
 
44675
  void *argp1 = 0 ;
 
44676
  int res1 = 0 ;
 
44677
  PyObject *swig_obj[1] ;
 
44678
  
 
44679
  if (!args) SWIG_fail;
 
44680
  swig_obj[0] = args;
 
44681
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44682
  if (!SWIG_IsOK(res1)) {
 
44683
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_GetInternalMargin" "', expected argument " "1"" of type '" "wxPickerBase const *""'"); 
 
44684
  }
 
44685
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44686
  {
 
44687
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44688
    result = (int)((wxPickerBase const *)arg1)->GetInternalMargin();
 
44689
    wxPyEndAllowThreads(__tstate);
 
44690
    if (PyErr_Occurred()) SWIG_fail;
 
44691
  }
 
44692
  resultobj = SWIG_From_int(static_cast< int >(result));
 
44693
  return resultobj;
 
44694
fail:
 
44695
  return NULL;
 
44696
}
 
44697
 
 
44698
 
 
44699
SWIGINTERN PyObject *_wrap_PickerBase_SetTextCtrlProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44700
  PyObject *resultobj = 0;
 
44701
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44702
  int arg2 ;
 
44703
  void *argp1 = 0 ;
 
44704
  int res1 = 0 ;
 
44705
  int val2 ;
 
44706
  int ecode2 = 0 ;
 
44707
  PyObject * obj0 = 0 ;
 
44708
  PyObject * obj1 = 0 ;
 
44709
  char *  kwnames[] = {
 
44710
    (char *) "self",(char *) "prop", NULL 
 
44711
  };
 
44712
  
 
44713
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PickerBase_SetTextCtrlProportion",kwnames,&obj0,&obj1)) SWIG_fail;
 
44714
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44715
  if (!SWIG_IsOK(res1)) {
 
44716
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_SetTextCtrlProportion" "', expected argument " "1"" of type '" "wxPickerBase *""'"); 
 
44717
  }
 
44718
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44719
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
44720
  if (!SWIG_IsOK(ecode2)) {
 
44721
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PickerBase_SetTextCtrlProportion" "', expected argument " "2"" of type '" "int""'");
 
44722
  } 
 
44723
  arg2 = static_cast< int >(val2);
 
44724
  {
 
44725
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44726
    (arg1)->SetTextCtrlProportion(arg2);
 
44727
    wxPyEndAllowThreads(__tstate);
 
44728
    if (PyErr_Occurred()) SWIG_fail;
 
44729
  }
 
44730
  resultobj = SWIG_Py_Void();
 
44731
  return resultobj;
 
44732
fail:
 
44733
  return NULL;
 
44734
}
 
44735
 
 
44736
 
 
44737
SWIGINTERN PyObject *_wrap_PickerBase_GetTextCtrlProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44738
  PyObject *resultobj = 0;
 
44739
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44740
  int result;
 
44741
  void *argp1 = 0 ;
 
44742
  int res1 = 0 ;
 
44743
  PyObject *swig_obj[1] ;
 
44744
  
 
44745
  if (!args) SWIG_fail;
 
44746
  swig_obj[0] = args;
 
44747
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44748
  if (!SWIG_IsOK(res1)) {
 
44749
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_GetTextCtrlProportion" "', expected argument " "1"" of type '" "wxPickerBase const *""'"); 
 
44750
  }
 
44751
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44752
  {
 
44753
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44754
    result = (int)((wxPickerBase const *)arg1)->GetTextCtrlProportion();
 
44755
    wxPyEndAllowThreads(__tstate);
 
44756
    if (PyErr_Occurred()) SWIG_fail;
 
44757
  }
 
44758
  resultobj = SWIG_From_int(static_cast< int >(result));
 
44759
  return resultobj;
 
44760
fail:
 
44761
  return NULL;
 
44762
}
 
44763
 
 
44764
 
 
44765
SWIGINTERN PyObject *_wrap_PickerBase_SetPickerCtrlProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44766
  PyObject *resultobj = 0;
 
44767
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44768
  int arg2 ;
 
44769
  void *argp1 = 0 ;
 
44770
  int res1 = 0 ;
 
44771
  int val2 ;
 
44772
  int ecode2 = 0 ;
 
44773
  PyObject * obj0 = 0 ;
 
44774
  PyObject * obj1 = 0 ;
 
44775
  char *  kwnames[] = {
 
44776
    (char *) "self",(char *) "prop", NULL 
 
44777
  };
 
44778
  
 
44779
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PickerBase_SetPickerCtrlProportion",kwnames,&obj0,&obj1)) SWIG_fail;
 
44780
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44781
  if (!SWIG_IsOK(res1)) {
 
44782
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_SetPickerCtrlProportion" "', expected argument " "1"" of type '" "wxPickerBase *""'"); 
 
44783
  }
 
44784
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44785
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
44786
  if (!SWIG_IsOK(ecode2)) {
 
44787
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PickerBase_SetPickerCtrlProportion" "', expected argument " "2"" of type '" "int""'");
 
44788
  } 
 
44789
  arg2 = static_cast< int >(val2);
 
44790
  {
 
44791
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44792
    (arg1)->SetPickerCtrlProportion(arg2);
 
44793
    wxPyEndAllowThreads(__tstate);
 
44794
    if (PyErr_Occurred()) SWIG_fail;
 
44795
  }
 
44796
  resultobj = SWIG_Py_Void();
 
44797
  return resultobj;
 
44798
fail:
 
44799
  return NULL;
 
44800
}
 
44801
 
 
44802
 
 
44803
SWIGINTERN PyObject *_wrap_PickerBase_GetPickerCtrlProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44804
  PyObject *resultobj = 0;
 
44805
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44806
  int result;
 
44807
  void *argp1 = 0 ;
 
44808
  int res1 = 0 ;
 
44809
  PyObject *swig_obj[1] ;
 
44810
  
 
44811
  if (!args) SWIG_fail;
 
44812
  swig_obj[0] = args;
 
44813
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44814
  if (!SWIG_IsOK(res1)) {
 
44815
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_GetPickerCtrlProportion" "', expected argument " "1"" of type '" "wxPickerBase const *""'"); 
 
44816
  }
 
44817
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44818
  {
 
44819
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44820
    result = (int)((wxPickerBase const *)arg1)->GetPickerCtrlProportion();
 
44821
    wxPyEndAllowThreads(__tstate);
 
44822
    if (PyErr_Occurred()) SWIG_fail;
 
44823
  }
 
44824
  resultobj = SWIG_From_int(static_cast< int >(result));
 
44825
  return resultobj;
 
44826
fail:
 
44827
  return NULL;
 
44828
}
 
44829
 
 
44830
 
 
44831
SWIGINTERN PyObject *_wrap_PickerBase_IsTextCtrlGrowable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44832
  PyObject *resultobj = 0;
 
44833
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44834
  bool result;
 
44835
  void *argp1 = 0 ;
 
44836
  int res1 = 0 ;
 
44837
  PyObject *swig_obj[1] ;
 
44838
  
 
44839
  if (!args) SWIG_fail;
 
44840
  swig_obj[0] = args;
 
44841
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44842
  if (!SWIG_IsOK(res1)) {
 
44843
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_IsTextCtrlGrowable" "', expected argument " "1"" of type '" "wxPickerBase const *""'"); 
 
44844
  }
 
44845
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44846
  {
 
44847
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44848
    result = (bool)((wxPickerBase const *)arg1)->IsTextCtrlGrowable();
 
44849
    wxPyEndAllowThreads(__tstate);
 
44850
    if (PyErr_Occurred()) SWIG_fail;
 
44851
  }
 
44852
  {
 
44853
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
44854
  }
 
44855
  return resultobj;
 
44856
fail:
 
44857
  return NULL;
 
44858
}
 
44859
 
 
44860
 
 
44861
SWIGINTERN PyObject *_wrap_PickerBase_SetTextCtrlGrowable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44862
  PyObject *resultobj = 0;
 
44863
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44864
  bool arg2 = (bool) true ;
 
44865
  void *argp1 = 0 ;
 
44866
  int res1 = 0 ;
 
44867
  bool val2 ;
 
44868
  int ecode2 = 0 ;
 
44869
  PyObject * obj0 = 0 ;
 
44870
  PyObject * obj1 = 0 ;
 
44871
  char *  kwnames[] = {
 
44872
    (char *) "self",(char *) "grow", NULL 
 
44873
  };
 
44874
  
 
44875
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PickerBase_SetTextCtrlGrowable",kwnames,&obj0,&obj1)) SWIG_fail;
 
44876
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44877
  if (!SWIG_IsOK(res1)) {
 
44878
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_SetTextCtrlGrowable" "', expected argument " "1"" of type '" "wxPickerBase *""'"); 
 
44879
  }
 
44880
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44881
  if (obj1) {
 
44882
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
44883
    if (!SWIG_IsOK(ecode2)) {
 
44884
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PickerBase_SetTextCtrlGrowable" "', expected argument " "2"" of type '" "bool""'");
 
44885
    } 
 
44886
    arg2 = static_cast< bool >(val2);
 
44887
  }
 
44888
  {
 
44889
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44890
    (arg1)->SetTextCtrlGrowable(arg2);
 
44891
    wxPyEndAllowThreads(__tstate);
 
44892
    if (PyErr_Occurred()) SWIG_fail;
 
44893
  }
 
44894
  resultobj = SWIG_Py_Void();
 
44895
  return resultobj;
 
44896
fail:
 
44897
  return NULL;
 
44898
}
 
44899
 
 
44900
 
 
44901
SWIGINTERN PyObject *_wrap_PickerBase_IsPickerCtrlGrowable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44902
  PyObject *resultobj = 0;
 
44903
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44904
  bool result;
 
44905
  void *argp1 = 0 ;
 
44906
  int res1 = 0 ;
 
44907
  PyObject *swig_obj[1] ;
 
44908
  
 
44909
  if (!args) SWIG_fail;
 
44910
  swig_obj[0] = args;
 
44911
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44912
  if (!SWIG_IsOK(res1)) {
 
44913
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_IsPickerCtrlGrowable" "', expected argument " "1"" of type '" "wxPickerBase const *""'"); 
 
44914
  }
 
44915
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44916
  {
 
44917
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44918
    result = (bool)((wxPickerBase const *)arg1)->IsPickerCtrlGrowable();
 
44919
    wxPyEndAllowThreads(__tstate);
 
44920
    if (PyErr_Occurred()) SWIG_fail;
 
44921
  }
 
44922
  {
 
44923
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
44924
  }
 
44925
  return resultobj;
 
44926
fail:
 
44927
  return NULL;
 
44928
}
 
44929
 
 
44930
 
 
44931
SWIGINTERN PyObject *_wrap_PickerBase_SetPickerCtrlGrowable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
44932
  PyObject *resultobj = 0;
 
44933
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44934
  bool arg2 = (bool) true ;
 
44935
  void *argp1 = 0 ;
 
44936
  int res1 = 0 ;
 
44937
  bool val2 ;
 
44938
  int ecode2 = 0 ;
 
44939
  PyObject * obj0 = 0 ;
 
44940
  PyObject * obj1 = 0 ;
 
44941
  char *  kwnames[] = {
 
44942
    (char *) "self",(char *) "grow", NULL 
 
44943
  };
 
44944
  
 
44945
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PickerBase_SetPickerCtrlGrowable",kwnames,&obj0,&obj1)) SWIG_fail;
 
44946
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44947
  if (!SWIG_IsOK(res1)) {
 
44948
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_SetPickerCtrlGrowable" "', expected argument " "1"" of type '" "wxPickerBase *""'"); 
 
44949
  }
 
44950
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44951
  if (obj1) {
 
44952
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
44953
    if (!SWIG_IsOK(ecode2)) {
 
44954
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PickerBase_SetPickerCtrlGrowable" "', expected argument " "2"" of type '" "bool""'");
 
44955
    } 
 
44956
    arg2 = static_cast< bool >(val2);
 
44957
  }
 
44958
  {
 
44959
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44960
    (arg1)->SetPickerCtrlGrowable(arg2);
 
44961
    wxPyEndAllowThreads(__tstate);
 
44962
    if (PyErr_Occurred()) SWIG_fail;
 
44963
  }
 
44964
  resultobj = SWIG_Py_Void();
 
44965
  return resultobj;
 
44966
fail:
 
44967
  return NULL;
 
44968
}
 
44969
 
 
44970
 
 
44971
SWIGINTERN PyObject *_wrap_PickerBase_HasTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
44972
  PyObject *resultobj = 0;
 
44973
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
44974
  bool result;
 
44975
  void *argp1 = 0 ;
 
44976
  int res1 = 0 ;
 
44977
  PyObject *swig_obj[1] ;
 
44978
  
 
44979
  if (!args) SWIG_fail;
 
44980
  swig_obj[0] = args;
 
44981
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
44982
  if (!SWIG_IsOK(res1)) {
 
44983
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_HasTextCtrl" "', expected argument " "1"" of type '" "wxPickerBase const *""'"); 
 
44984
  }
 
44985
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
44986
  {
 
44987
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
44988
    result = (bool)((wxPickerBase const *)arg1)->HasTextCtrl();
 
44989
    wxPyEndAllowThreads(__tstate);
 
44990
    if (PyErr_Occurred()) SWIG_fail;
 
44991
  }
 
44992
  {
 
44993
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
44994
  }
 
44995
  return resultobj;
 
44996
fail:
 
44997
  return NULL;
 
44998
}
 
44999
 
 
45000
 
 
45001
SWIGINTERN PyObject *_wrap_PickerBase_GetTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45002
  PyObject *resultobj = 0;
 
45003
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
45004
  wxTextCtrl *result = 0 ;
 
45005
  void *argp1 = 0 ;
 
45006
  int res1 = 0 ;
 
45007
  PyObject *swig_obj[1] ;
 
45008
  
 
45009
  if (!args) SWIG_fail;
 
45010
  swig_obj[0] = args;
 
45011
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
45012
  if (!SWIG_IsOK(res1)) {
 
45013
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_GetTextCtrl" "', expected argument " "1"" of type '" "wxPickerBase *""'"); 
 
45014
  }
 
45015
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
45016
  {
 
45017
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45018
    result = (wxTextCtrl *)(arg1)->GetTextCtrl();
 
45019
    wxPyEndAllowThreads(__tstate);
 
45020
    if (PyErr_Occurred()) SWIG_fail;
 
45021
  }
 
45022
  {
 
45023
    resultobj = wxPyMake_wxObject(result, 0); 
 
45024
  }
 
45025
  return resultobj;
 
45026
fail:
 
45027
  return NULL;
 
45028
}
 
45029
 
 
45030
 
 
45031
SWIGINTERN PyObject *_wrap_PickerBase_GetPickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45032
  PyObject *resultobj = 0;
 
45033
  wxPickerBase *arg1 = (wxPickerBase *) 0 ;
 
45034
  wxControl *result = 0 ;
 
45035
  void *argp1 = 0 ;
 
45036
  int res1 = 0 ;
 
45037
  PyObject *swig_obj[1] ;
 
45038
  
 
45039
  if (!args) SWIG_fail;
 
45040
  swig_obj[0] = args;
 
45041
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPickerBase, 0 |  0 );
 
45042
  if (!SWIG_IsOK(res1)) {
 
45043
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PickerBase_GetPickerCtrl" "', expected argument " "1"" of type '" "wxPickerBase *""'"); 
 
45044
  }
 
45045
  arg1 = reinterpret_cast< wxPickerBase * >(argp1);
 
45046
  {
 
45047
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45048
    result = (wxControl *)(arg1)->GetPickerCtrl();
 
45049
    wxPyEndAllowThreads(__tstate);
 
45050
    if (PyErr_Occurred()) SWIG_fail;
 
45051
  }
 
45052
  {
 
45053
    resultobj = wxPyMake_wxObject(result, 0); 
 
45054
  }
 
45055
  return resultobj;
 
45056
fail:
 
45057
  return NULL;
 
45058
}
 
45059
 
 
45060
 
 
45061
SWIGINTERN PyObject *PickerBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45062
  PyObject *obj;
 
45063
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
45064
  SWIG_TypeNewClientData(SWIGTYPE_p_wxPickerBase, SWIG_NewClientData(obj));
 
45065
  return SWIG_Py_Void();
 
45066
}
 
45067
 
 
45068
SWIGINTERN PyObject *_wrap_new_PyPickerBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45069
  PyObject *resultobj = 0;
 
45070
  wxWindow *arg1 = (wxWindow *) 0 ;
 
45071
  int arg2 = (int) -1 ;
 
45072
  wxString const &arg3_defvalue = wxEmptyString ;
 
45073
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
45074
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
45075
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
45076
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
45077
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
45078
  long arg6 = (long) 0 ;
 
45079
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
45080
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
45081
  wxString const &arg8_defvalue = wxButtonNameStr ;
 
45082
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
45083
  wxPyPickerBase *result = 0 ;
 
45084
  void *argp1 = 0 ;
 
45085
  int res1 = 0 ;
 
45086
  int val2 ;
 
45087
  int ecode2 = 0 ;
 
45088
  bool temp3 = false ;
 
45089
  wxPoint temp4 ;
 
45090
  wxSize temp5 ;
 
45091
  long val6 ;
 
45092
  int ecode6 = 0 ;
 
45093
  void *argp7 = 0 ;
 
45094
  int res7 = 0 ;
 
45095
  bool temp8 = false ;
 
45096
  PyObject * obj0 = 0 ;
 
45097
  PyObject * obj1 = 0 ;
 
45098
  PyObject * obj2 = 0 ;
 
45099
  PyObject * obj3 = 0 ;
 
45100
  PyObject * obj4 = 0 ;
 
45101
  PyObject * obj5 = 0 ;
 
45102
  PyObject * obj6 = 0 ;
 
45103
  PyObject * obj7 = 0 ;
 
45104
  char *  kwnames[] = {
 
45105
    (char *) "parent",(char *) "id",(char *) "text",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
45106
  };
 
45107
  
 
45108
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_PyPickerBase",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
45109
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
45110
  if (!SWIG_IsOK(res1)) {
 
45111
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyPickerBase" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
45112
  }
 
45113
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
45114
  if (obj1) {
 
45115
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
45116
    if (!SWIG_IsOK(ecode2)) {
 
45117
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyPickerBase" "', expected argument " "2"" of type '" "int""'");
 
45118
    } 
 
45119
    arg2 = static_cast< int >(val2);
 
45120
  }
 
45121
  if (obj2) {
 
45122
    {
 
45123
      arg3 = wxString_in_helper(obj2);
 
45124
      if (arg3 == NULL) SWIG_fail;
 
45125
      temp3 = true;
 
45126
    }
 
45127
  }
 
45128
  if (obj3) {
 
45129
    {
 
45130
      arg4 = &temp4;
 
45131
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
45132
    }
 
45133
  }
 
45134
  if (obj4) {
 
45135
    {
 
45136
      arg5 = &temp5;
 
45137
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
45138
    }
 
45139
  }
 
45140
  if (obj5) {
 
45141
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
45142
    if (!SWIG_IsOK(ecode6)) {
 
45143
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PyPickerBase" "', expected argument " "6"" of type '" "long""'");
 
45144
    } 
 
45145
    arg6 = static_cast< long >(val6);
 
45146
  }
 
45147
  if (obj6) {
 
45148
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
45149
    if (!SWIG_IsOK(res7)) {
 
45150
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PyPickerBase" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
45151
    }
 
45152
    if (!argp7) {
 
45153
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyPickerBase" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
45154
    }
 
45155
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
45156
  }
 
45157
  if (obj7) {
 
45158
    {
 
45159
      arg8 = wxString_in_helper(obj7);
 
45160
      if (arg8 == NULL) SWIG_fail;
 
45161
      temp8 = true;
 
45162
    }
 
45163
  }
 
45164
  {
 
45165
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45166
    result = (wxPyPickerBase *)new wxPyPickerBase(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
45167
    wxPyEndAllowThreads(__tstate);
 
45168
    if (PyErr_Occurred()) SWIG_fail;
 
45169
  }
 
45170
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyPickerBase, SWIG_POINTER_NEW |  0 );
 
45171
  {
 
45172
    if (temp3)
 
45173
    delete arg3;
 
45174
  }
 
45175
  {
 
45176
    if (temp8)
 
45177
    delete arg8;
 
45178
  }
 
45179
  return resultobj;
 
45180
fail:
 
45181
  {
 
45182
    if (temp3)
 
45183
    delete arg3;
 
45184
  }
 
45185
  {
 
45186
    if (temp8)
 
45187
    delete arg8;
 
45188
  }
 
45189
  return NULL;
 
45190
}
 
45191
 
 
45192
 
 
45193
SWIGINTERN PyObject *_wrap_new_PrePyPickerBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45194
  PyObject *resultobj = 0;
 
45195
  wxPyPickerBase *result = 0 ;
 
45196
  
 
45197
  if (!SWIG_Python_UnpackTuple(args,"new_PrePyPickerBase",0,0,0)) SWIG_fail;
 
45198
  {
 
45199
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45200
    result = (wxPyPickerBase *)new wxPyPickerBase();
 
45201
    wxPyEndAllowThreads(__tstate);
 
45202
    if (PyErr_Occurred()) SWIG_fail;
 
45203
  }
 
45204
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyPickerBase, SWIG_POINTER_OWN |  0 );
 
45205
  return resultobj;
 
45206
fail:
 
45207
  return NULL;
 
45208
}
 
45209
 
 
45210
 
 
45211
SWIGINTERN PyObject *_wrap_PyPickerBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45212
  PyObject *resultobj = 0;
 
45213
  wxPyPickerBase *arg1 = (wxPyPickerBase *) 0 ;
 
45214
  PyObject *arg2 = (PyObject *) 0 ;
 
45215
  PyObject *arg3 = (PyObject *) 0 ;
 
45216
  void *argp1 = 0 ;
 
45217
  int res1 = 0 ;
 
45218
  PyObject * obj0 = 0 ;
 
45219
  PyObject * obj1 = 0 ;
 
45220
  PyObject * obj2 = 0 ;
 
45221
  char *  kwnames[] = {
 
45222
    (char *) "self",(char *) "self",(char *) "_class", NULL 
 
45223
  };
 
45224
  
 
45225
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyPickerBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
45226
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPickerBase, 0 |  0 );
 
45227
  if (!SWIG_IsOK(res1)) {
 
45228
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyPickerBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyPickerBase *""'"); 
 
45229
  }
 
45230
  arg1 = reinterpret_cast< wxPyPickerBase * >(argp1);
 
45231
  arg2 = obj1;
 
45232
  arg3 = obj2;
 
45233
  {
 
45234
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45235
    (arg1)->_setCallbackInfo(arg2,arg3);
 
45236
    wxPyEndAllowThreads(__tstate);
 
45237
    if (PyErr_Occurred()) SWIG_fail;
 
45238
  }
 
45239
  resultobj = SWIG_Py_Void();
 
45240
  return resultobj;
 
45241
fail:
 
45242
  return NULL;
 
45243
}
 
45244
 
 
45245
 
 
45246
SWIGINTERN PyObject *_wrap_PyPickerBase_UpdatePickerFromTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45247
  PyObject *resultobj = 0;
 
45248
  wxPyPickerBase *arg1 = (wxPyPickerBase *) 0 ;
 
45249
  void *argp1 = 0 ;
 
45250
  int res1 = 0 ;
 
45251
  PyObject *swig_obj[1] ;
 
45252
  
 
45253
  if (!args) SWIG_fail;
 
45254
  swig_obj[0] = args;
 
45255
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyPickerBase, 0 |  0 );
 
45256
  if (!SWIG_IsOK(res1)) {
 
45257
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyPickerBase_UpdatePickerFromTextCtrl" "', expected argument " "1"" of type '" "wxPyPickerBase *""'"); 
 
45258
  }
 
45259
  arg1 = reinterpret_cast< wxPyPickerBase * >(argp1);
 
45260
  {
 
45261
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45262
    (arg1)->UpdatePickerFromTextCtrl();
 
45263
    wxPyEndAllowThreads(__tstate);
 
45264
    if (PyErr_Occurred()) SWIG_fail;
 
45265
  }
 
45266
  resultobj = SWIG_Py_Void();
 
45267
  return resultobj;
 
45268
fail:
 
45269
  return NULL;
 
45270
}
 
45271
 
 
45272
 
 
45273
SWIGINTERN PyObject *_wrap_PyPickerBase_UpdateTextCtrlFromPicker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45274
  PyObject *resultobj = 0;
 
45275
  wxPyPickerBase *arg1 = (wxPyPickerBase *) 0 ;
 
45276
  void *argp1 = 0 ;
 
45277
  int res1 = 0 ;
 
45278
  PyObject *swig_obj[1] ;
 
45279
  
 
45280
  if (!args) SWIG_fail;
 
45281
  swig_obj[0] = args;
 
45282
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyPickerBase, 0 |  0 );
 
45283
  if (!SWIG_IsOK(res1)) {
 
45284
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyPickerBase_UpdateTextCtrlFromPicker" "', expected argument " "1"" of type '" "wxPyPickerBase *""'"); 
 
45285
  }
 
45286
  arg1 = reinterpret_cast< wxPyPickerBase * >(argp1);
 
45287
  {
 
45288
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45289
    (arg1)->UpdateTextCtrlFromPicker();
 
45290
    wxPyEndAllowThreads(__tstate);
 
45291
    if (PyErr_Occurred()) SWIG_fail;
 
45292
  }
 
45293
  resultobj = SWIG_Py_Void();
 
45294
  return resultobj;
 
45295
fail:
 
45296
  return NULL;
 
45297
}
 
45298
 
 
45299
 
 
45300
SWIGINTERN PyObject *_wrap_PyPickerBase_GetTextCtrlStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45301
  PyObject *resultobj = 0;
 
45302
  wxPyPickerBase *arg1 = (wxPyPickerBase *) 0 ;
 
45303
  long arg2 ;
 
45304
  long result;
 
45305
  void *argp1 = 0 ;
 
45306
  int res1 = 0 ;
 
45307
  long val2 ;
 
45308
  int ecode2 = 0 ;
 
45309
  PyObject * obj0 = 0 ;
 
45310
  PyObject * obj1 = 0 ;
 
45311
  char *  kwnames[] = {
 
45312
    (char *) "self",(char *) "style", NULL 
 
45313
  };
 
45314
  
 
45315
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPickerBase_GetTextCtrlStyle",kwnames,&obj0,&obj1)) SWIG_fail;
 
45316
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPickerBase, 0 |  0 );
 
45317
  if (!SWIG_IsOK(res1)) {
 
45318
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyPickerBase_GetTextCtrlStyle" "', expected argument " "1"" of type '" "wxPyPickerBase const *""'"); 
 
45319
  }
 
45320
  arg1 = reinterpret_cast< wxPyPickerBase * >(argp1);
 
45321
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
45322
  if (!SWIG_IsOK(ecode2)) {
 
45323
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyPickerBase_GetTextCtrlStyle" "', expected argument " "2"" of type '" "long""'");
 
45324
  } 
 
45325
  arg2 = static_cast< long >(val2);
 
45326
  {
 
45327
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45328
    result = (long)((wxPyPickerBase const *)arg1)->GetTextCtrlStyle(arg2);
 
45329
    wxPyEndAllowThreads(__tstate);
 
45330
    if (PyErr_Occurred()) SWIG_fail;
 
45331
  }
 
45332
  resultobj = SWIG_From_long(static_cast< long >(result));
 
45333
  return resultobj;
 
45334
fail:
 
45335
  return NULL;
 
45336
}
 
45337
 
 
45338
 
 
45339
SWIGINTERN PyObject *_wrap_PyPickerBase_GetPickerStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45340
  PyObject *resultobj = 0;
 
45341
  wxPyPickerBase *arg1 = (wxPyPickerBase *) 0 ;
 
45342
  long arg2 ;
 
45343
  long result;
 
45344
  void *argp1 = 0 ;
 
45345
  int res1 = 0 ;
 
45346
  long val2 ;
 
45347
  int ecode2 = 0 ;
 
45348
  PyObject * obj0 = 0 ;
 
45349
  PyObject * obj1 = 0 ;
 
45350
  char *  kwnames[] = {
 
45351
    (char *) "self",(char *) "style", NULL 
 
45352
  };
 
45353
  
 
45354
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPickerBase_GetPickerStyle",kwnames,&obj0,&obj1)) SWIG_fail;
 
45355
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPickerBase, 0 |  0 );
 
45356
  if (!SWIG_IsOK(res1)) {
 
45357
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyPickerBase_GetPickerStyle" "', expected argument " "1"" of type '" "wxPyPickerBase const *""'"); 
 
45358
  }
 
45359
  arg1 = reinterpret_cast< wxPyPickerBase * >(argp1);
 
45360
  ecode2 = SWIG_AsVal_long(obj1, &val2);
 
45361
  if (!SWIG_IsOK(ecode2)) {
 
45362
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyPickerBase_GetPickerStyle" "', expected argument " "2"" of type '" "long""'");
 
45363
  } 
 
45364
  arg2 = static_cast< long >(val2);
 
45365
  {
 
45366
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45367
    result = (long)((wxPyPickerBase const *)arg1)->GetPickerStyle(arg2);
 
45368
    wxPyEndAllowThreads(__tstate);
 
45369
    if (PyErr_Occurred()) SWIG_fail;
 
45370
  }
 
45371
  resultobj = SWIG_From_long(static_cast< long >(result));
 
45372
  return resultobj;
 
45373
fail:
 
45374
  return NULL;
 
45375
}
 
45376
 
 
45377
 
 
45378
SWIGINTERN PyObject *_wrap_PyPickerBase_SetTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45379
  PyObject *resultobj = 0;
 
45380
  wxPyPickerBase *arg1 = (wxPyPickerBase *) 0 ;
 
45381
  wxTextCtrl *arg2 = (wxTextCtrl *) 0 ;
 
45382
  void *argp1 = 0 ;
 
45383
  int res1 = 0 ;
 
45384
  void *argp2 = 0 ;
 
45385
  int res2 = 0 ;
 
45386
  PyObject * obj0 = 0 ;
 
45387
  PyObject * obj1 = 0 ;
 
45388
  char *  kwnames[] = {
 
45389
    (char *) "self",(char *) "text", NULL 
 
45390
  };
 
45391
  
 
45392
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPickerBase_SetTextCtrl",kwnames,&obj0,&obj1)) SWIG_fail;
 
45393
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPickerBase, 0 |  0 );
 
45394
  if (!SWIG_IsOK(res1)) {
 
45395
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyPickerBase_SetTextCtrl" "', expected argument " "1"" of type '" "wxPyPickerBase *""'"); 
 
45396
  }
 
45397
  arg1 = reinterpret_cast< wxPyPickerBase * >(argp1);
 
45398
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTextCtrl, 0 |  0 );
 
45399
  if (!SWIG_IsOK(res2)) {
 
45400
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyPickerBase_SetTextCtrl" "', expected argument " "2"" of type '" "wxTextCtrl *""'"); 
 
45401
  }
 
45402
  arg2 = reinterpret_cast< wxTextCtrl * >(argp2);
 
45403
  {
 
45404
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45405
    (arg1)->SetTextCtrl(arg2);
 
45406
    wxPyEndAllowThreads(__tstate);
 
45407
    if (PyErr_Occurred()) SWIG_fail;
 
45408
  }
 
45409
  resultobj = SWIG_Py_Void();
 
45410
  return resultobj;
 
45411
fail:
 
45412
  return NULL;
 
45413
}
 
45414
 
 
45415
 
 
45416
SWIGINTERN PyObject *_wrap_PyPickerBase_SetPickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45417
  PyObject *resultobj = 0;
 
45418
  wxPyPickerBase *arg1 = (wxPyPickerBase *) 0 ;
 
45419
  wxControl *arg2 = (wxControl *) 0 ;
 
45420
  void *argp1 = 0 ;
 
45421
  int res1 = 0 ;
 
45422
  void *argp2 = 0 ;
 
45423
  int res2 = 0 ;
 
45424
  PyObject * obj0 = 0 ;
 
45425
  PyObject * obj1 = 0 ;
 
45426
  char *  kwnames[] = {
 
45427
    (char *) "self",(char *) "picker", NULL 
 
45428
  };
 
45429
  
 
45430
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyPickerBase_SetPickerCtrl",kwnames,&obj0,&obj1)) SWIG_fail;
 
45431
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPickerBase, 0 |  0 );
 
45432
  if (!SWIG_IsOK(res1)) {
 
45433
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyPickerBase_SetPickerCtrl" "', expected argument " "1"" of type '" "wxPyPickerBase *""'"); 
 
45434
  }
 
45435
  arg1 = reinterpret_cast< wxPyPickerBase * >(argp1);
 
45436
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 |  0 );
 
45437
  if (!SWIG_IsOK(res2)) {
 
45438
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyPickerBase_SetPickerCtrl" "', expected argument " "2"" of type '" "wxControl *""'"); 
 
45439
  }
 
45440
  arg2 = reinterpret_cast< wxControl * >(argp2);
 
45441
  {
 
45442
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45443
    (arg1)->SetPickerCtrl(arg2);
 
45444
    wxPyEndAllowThreads(__tstate);
 
45445
    if (PyErr_Occurred()) SWIG_fail;
 
45446
  }
 
45447
  resultobj = SWIG_Py_Void();
 
45448
  return resultobj;
 
45449
fail:
 
45450
  return NULL;
 
45451
}
 
45452
 
 
45453
 
 
45454
SWIGINTERN PyObject *_wrap_PyPickerBase_PostCreation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45455
  PyObject *resultobj = 0;
 
45456
  wxPyPickerBase *arg1 = (wxPyPickerBase *) 0 ;
 
45457
  void *argp1 = 0 ;
 
45458
  int res1 = 0 ;
 
45459
  PyObject *swig_obj[1] ;
 
45460
  
 
45461
  if (!args) SWIG_fail;
 
45462
  swig_obj[0] = args;
 
45463
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyPickerBase, 0 |  0 );
 
45464
  if (!SWIG_IsOK(res1)) {
 
45465
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyPickerBase_PostCreation" "', expected argument " "1"" of type '" "wxPyPickerBase *""'"); 
 
45466
  }
 
45467
  arg1 = reinterpret_cast< wxPyPickerBase * >(argp1);
 
45468
  {
 
45469
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45470
    (arg1)->PostCreation();
 
45471
    wxPyEndAllowThreads(__tstate);
 
45472
    if (PyErr_Occurred()) SWIG_fail;
 
45473
  }
 
45474
  resultobj = SWIG_Py_Void();
 
45475
  return resultobj;
 
45476
fail:
 
45477
  return NULL;
 
45478
}
 
45479
 
 
45480
 
 
45481
SWIGINTERN PyObject *PyPickerBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45482
  PyObject *obj;
 
45483
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
45484
  SWIG_TypeNewClientData(SWIGTYPE_p_wxPyPickerBase, SWIG_NewClientData(obj));
 
45485
  return SWIG_Py_Void();
 
45486
}
 
45487
 
 
45488
SWIGINTERN PyObject *PyPickerBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45489
  return SWIG_Python_InitShadowInstance(args);
 
45490
}
 
45491
 
 
45492
SWIGINTERN int ColourPickerCtrlNameStr_set(PyObject *) {
 
45493
  SWIG_Error(SWIG_AttributeError,"Variable ColourPickerCtrlNameStr is read-only.");
 
45494
  return 1;
 
45495
}
 
45496
 
 
45497
 
 
45498
SWIGINTERN PyObject *ColourPickerCtrlNameStr_get(void) {
 
45499
  PyObject *pyobj = 0;
 
45500
  
 
45501
  {
 
45502
#if wxUSE_UNICODE
 
45503
    pyobj = PyUnicode_FromWideChar((&wxPyColourPickerCtrlNameStr)->c_str(), (&wxPyColourPickerCtrlNameStr)->Len());
 
45504
#else
 
45505
    pyobj = PyString_FromStringAndSize((&wxPyColourPickerCtrlNameStr)->c_str(), (&wxPyColourPickerCtrlNameStr)->Len());
 
45506
#endif
 
45507
  }
 
45508
  return pyobj;
 
45509
}
 
45510
 
 
45511
 
 
45512
SWIGINTERN PyObject *_wrap_new_ColourPickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45513
  PyObject *resultobj = 0;
 
45514
  wxWindow *arg1 = (wxWindow *) 0 ;
 
45515
  int arg2 = (int) -1 ;
 
45516
  wxColour const &arg3_defvalue = *wxBLACK ;
 
45517
  wxColour *arg3 = (wxColour *) &arg3_defvalue ;
 
45518
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
45519
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
45520
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
45521
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
45522
  long arg6 = (long) wxCLRP_DEFAULT_STYLE ;
 
45523
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
45524
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
45525
  wxString const &arg8_defvalue = wxPyColourPickerCtrlNameStr ;
 
45526
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
45527
  wxColourPickerCtrl *result = 0 ;
 
45528
  void *argp1 = 0 ;
 
45529
  int res1 = 0 ;
 
45530
  int val2 ;
 
45531
  int ecode2 = 0 ;
 
45532
  wxColour temp3 ;
 
45533
  wxPoint temp4 ;
 
45534
  wxSize temp5 ;
 
45535
  long val6 ;
 
45536
  int ecode6 = 0 ;
 
45537
  void *argp7 = 0 ;
 
45538
  int res7 = 0 ;
 
45539
  bool temp8 = false ;
 
45540
  PyObject * obj0 = 0 ;
 
45541
  PyObject * obj1 = 0 ;
 
45542
  PyObject * obj2 = 0 ;
 
45543
  PyObject * obj3 = 0 ;
 
45544
  PyObject * obj4 = 0 ;
 
45545
  PyObject * obj5 = 0 ;
 
45546
  PyObject * obj6 = 0 ;
 
45547
  PyObject * obj7 = 0 ;
 
45548
  char *  kwnames[] = {
 
45549
    (char *) "parent",(char *) "id",(char *) "col",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
45550
  };
 
45551
  
 
45552
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_ColourPickerCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
45553
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
45554
  if (!SWIG_IsOK(res1)) {
 
45555
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColourPickerCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
45556
  }
 
45557
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
45558
  if (obj1) {
 
45559
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
45560
    if (!SWIG_IsOK(ecode2)) {
 
45561
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColourPickerCtrl" "', expected argument " "2"" of type '" "int""'");
 
45562
    } 
 
45563
    arg2 = static_cast< int >(val2);
 
45564
  }
 
45565
  if (obj2) {
 
45566
    {
 
45567
      arg3 = &temp3;
 
45568
      if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
 
45569
    }
 
45570
  }
 
45571
  if (obj3) {
 
45572
    {
 
45573
      arg4 = &temp4;
 
45574
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
45575
    }
 
45576
  }
 
45577
  if (obj4) {
 
45578
    {
 
45579
      arg5 = &temp5;
 
45580
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
45581
    }
 
45582
  }
 
45583
  if (obj5) {
 
45584
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
45585
    if (!SWIG_IsOK(ecode6)) {
 
45586
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ColourPickerCtrl" "', expected argument " "6"" of type '" "long""'");
 
45587
    } 
 
45588
    arg6 = static_cast< long >(val6);
 
45589
  }
 
45590
  if (obj6) {
 
45591
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
45592
    if (!SWIG_IsOK(res7)) {
 
45593
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ColourPickerCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
45594
    }
 
45595
    if (!argp7) {
 
45596
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColourPickerCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
45597
    }
 
45598
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
45599
  }
 
45600
  if (obj7) {
 
45601
    {
 
45602
      arg8 = wxString_in_helper(obj7);
 
45603
      if (arg8 == NULL) SWIG_fail;
 
45604
      temp8 = true;
 
45605
    }
 
45606
  }
 
45607
  {
 
45608
    if (!wxPyCheckForApp()) SWIG_fail;
 
45609
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45610
    result = (wxColourPickerCtrl *)new wxColourPickerCtrl(arg1,arg2,(wxColour const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
45611
    wxPyEndAllowThreads(__tstate);
 
45612
    if (PyErr_Occurred()) SWIG_fail;
 
45613
  }
 
45614
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourPickerCtrl, SWIG_POINTER_NEW |  0 );
 
45615
  {
 
45616
    if (temp8)
 
45617
    delete arg8;
 
45618
  }
 
45619
  return resultobj;
 
45620
fail:
 
45621
  {
 
45622
    if (temp8)
 
45623
    delete arg8;
 
45624
  }
 
45625
  return NULL;
 
45626
}
 
45627
 
 
45628
 
 
45629
SWIGINTERN PyObject *_wrap_new_PreColourPickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45630
  PyObject *resultobj = 0;
 
45631
  wxColourPickerCtrl *result = 0 ;
 
45632
  
 
45633
  if (!SWIG_Python_UnpackTuple(args,"new_PreColourPickerCtrl",0,0,0)) SWIG_fail;
 
45634
  {
 
45635
    if (!wxPyCheckForApp()) SWIG_fail;
 
45636
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45637
    result = (wxColourPickerCtrl *)new wxColourPickerCtrl();
 
45638
    wxPyEndAllowThreads(__tstate);
 
45639
    if (PyErr_Occurred()) SWIG_fail;
 
45640
  }
 
45641
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourPickerCtrl, SWIG_POINTER_OWN |  0 );
 
45642
  return resultobj;
 
45643
fail:
 
45644
  return NULL;
 
45645
}
 
45646
 
 
45647
 
 
45648
SWIGINTERN PyObject *_wrap_ColourPickerCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45649
  PyObject *resultobj = 0;
 
45650
  wxColourPickerCtrl *arg1 = (wxColourPickerCtrl *) 0 ;
 
45651
  wxWindow *arg2 = (wxWindow *) 0 ;
 
45652
  int arg3 ;
 
45653
  wxColour const &arg4_defvalue = *wxBLACK ;
 
45654
  wxColour *arg4 = (wxColour *) &arg4_defvalue ;
 
45655
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
45656
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
45657
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
45658
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
45659
  long arg7 = (long) wxCLRP_DEFAULT_STYLE ;
 
45660
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
45661
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
45662
  wxString const &arg9_defvalue = wxPyColourPickerCtrlNameStr ;
 
45663
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
45664
  bool result;
 
45665
  void *argp1 = 0 ;
 
45666
  int res1 = 0 ;
 
45667
  void *argp2 = 0 ;
 
45668
  int res2 = 0 ;
 
45669
  int val3 ;
 
45670
  int ecode3 = 0 ;
 
45671
  wxColour temp4 ;
 
45672
  wxPoint temp5 ;
 
45673
  wxSize temp6 ;
 
45674
  long val7 ;
 
45675
  int ecode7 = 0 ;
 
45676
  void *argp8 = 0 ;
 
45677
  int res8 = 0 ;
 
45678
  bool temp9 = false ;
 
45679
  PyObject * obj0 = 0 ;
 
45680
  PyObject * obj1 = 0 ;
 
45681
  PyObject * obj2 = 0 ;
 
45682
  PyObject * obj3 = 0 ;
 
45683
  PyObject * obj4 = 0 ;
 
45684
  PyObject * obj5 = 0 ;
 
45685
  PyObject * obj6 = 0 ;
 
45686
  PyObject * obj7 = 0 ;
 
45687
  PyObject * obj8 = 0 ;
 
45688
  char *  kwnames[] = {
 
45689
    (char *) "self",(char *) "parent",(char *) "id",(char *) "col",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
45690
  };
 
45691
  
 
45692
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:ColourPickerCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
45693
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourPickerCtrl, 0 |  0 );
 
45694
  if (!SWIG_IsOK(res1)) {
 
45695
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourPickerCtrl_Create" "', expected argument " "1"" of type '" "wxColourPickerCtrl *""'"); 
 
45696
  }
 
45697
  arg1 = reinterpret_cast< wxColourPickerCtrl * >(argp1);
 
45698
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
45699
  if (!SWIG_IsOK(res2)) {
 
45700
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourPickerCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
45701
  }
 
45702
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
45703
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
45704
  if (!SWIG_IsOK(ecode3)) {
 
45705
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ColourPickerCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
45706
  } 
 
45707
  arg3 = static_cast< int >(val3);
 
45708
  if (obj3) {
 
45709
    {
 
45710
      arg4 = &temp4;
 
45711
      if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
 
45712
    }
 
45713
  }
 
45714
  if (obj4) {
 
45715
    {
 
45716
      arg5 = &temp5;
 
45717
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
45718
    }
 
45719
  }
 
45720
  if (obj5) {
 
45721
    {
 
45722
      arg6 = &temp6;
 
45723
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
45724
    }
 
45725
  }
 
45726
  if (obj6) {
 
45727
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
45728
    if (!SWIG_IsOK(ecode7)) {
 
45729
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ColourPickerCtrl_Create" "', expected argument " "7"" of type '" "long""'");
 
45730
    } 
 
45731
    arg7 = static_cast< long >(val7);
 
45732
  }
 
45733
  if (obj7) {
 
45734
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
45735
    if (!SWIG_IsOK(res8)) {
 
45736
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ColourPickerCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
45737
    }
 
45738
    if (!argp8) {
 
45739
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourPickerCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
45740
    }
 
45741
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
45742
  }
 
45743
  if (obj8) {
 
45744
    {
 
45745
      arg9 = wxString_in_helper(obj8);
 
45746
      if (arg9 == NULL) SWIG_fail;
 
45747
      temp9 = true;
 
45748
    }
 
45749
  }
 
45750
  {
 
45751
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45752
    result = (bool)(arg1)->Create(arg2,arg3,(wxColour const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
45753
    wxPyEndAllowThreads(__tstate);
 
45754
    if (PyErr_Occurred()) SWIG_fail;
 
45755
  }
 
45756
  {
 
45757
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
45758
  }
 
45759
  {
 
45760
    if (temp9)
 
45761
    delete arg9;
 
45762
  }
 
45763
  return resultobj;
 
45764
fail:
 
45765
  {
 
45766
    if (temp9)
 
45767
    delete arg9;
 
45768
  }
 
45769
  return NULL;
 
45770
}
 
45771
 
 
45772
 
 
45773
SWIGINTERN PyObject *_wrap_ColourPickerCtrl_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45774
  PyObject *resultobj = 0;
 
45775
  wxColourPickerCtrl *arg1 = (wxColourPickerCtrl *) 0 ;
 
45776
  wxColour result;
 
45777
  void *argp1 = 0 ;
 
45778
  int res1 = 0 ;
 
45779
  PyObject *swig_obj[1] ;
 
45780
  
 
45781
  if (!args) SWIG_fail;
 
45782
  swig_obj[0] = args;
 
45783
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColourPickerCtrl, 0 |  0 );
 
45784
  if (!SWIG_IsOK(res1)) {
 
45785
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourPickerCtrl_GetColour" "', expected argument " "1"" of type '" "wxColourPickerCtrl const *""'"); 
 
45786
  }
 
45787
  arg1 = reinterpret_cast< wxColourPickerCtrl * >(argp1);
 
45788
  {
 
45789
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45790
    result = ((wxColourPickerCtrl const *)arg1)->GetColour();
 
45791
    wxPyEndAllowThreads(__tstate);
 
45792
    if (PyErr_Occurred()) SWIG_fail;
 
45793
  }
 
45794
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
45795
  return resultobj;
 
45796
fail:
 
45797
  return NULL;
 
45798
}
 
45799
 
 
45800
 
 
45801
SWIGINTERN PyObject *_wrap_ColourPickerCtrl_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45802
  PyObject *resultobj = 0;
 
45803
  wxColourPickerCtrl *arg1 = (wxColourPickerCtrl *) 0 ;
 
45804
  wxColour *arg2 = 0 ;
 
45805
  void *argp1 = 0 ;
 
45806
  int res1 = 0 ;
 
45807
  wxColour temp2 ;
 
45808
  PyObject * obj0 = 0 ;
 
45809
  PyObject * obj1 = 0 ;
 
45810
  char *  kwnames[] = {
 
45811
    (char *) "self",(char *) "col", NULL 
 
45812
  };
 
45813
  
 
45814
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourPickerCtrl_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
45815
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourPickerCtrl, 0 |  0 );
 
45816
  if (!SWIG_IsOK(res1)) {
 
45817
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourPickerCtrl_SetColour" "', expected argument " "1"" of type '" "wxColourPickerCtrl *""'"); 
 
45818
  }
 
45819
  arg1 = reinterpret_cast< wxColourPickerCtrl * >(argp1);
 
45820
  {
 
45821
    arg2 = &temp2;
 
45822
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
45823
  }
 
45824
  {
 
45825
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45826
    (arg1)->SetColour((wxColour const &)*arg2);
 
45827
    wxPyEndAllowThreads(__tstate);
 
45828
    if (PyErr_Occurred()) SWIG_fail;
 
45829
  }
 
45830
  resultobj = SWIG_Py_Void();
 
45831
  return resultobj;
 
45832
fail:
 
45833
  return NULL;
 
45834
}
 
45835
 
 
45836
 
 
45837
SWIGINTERN PyObject *ColourPickerCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45838
  PyObject *obj;
 
45839
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
45840
  SWIG_TypeNewClientData(SWIGTYPE_p_wxColourPickerCtrl, SWIG_NewClientData(obj));
 
45841
  return SWIG_Py_Void();
 
45842
}
 
45843
 
 
45844
SWIGINTERN PyObject *ColourPickerCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45845
  return SWIG_Python_InitShadowInstance(args);
 
45846
}
 
45847
 
 
45848
SWIGINTERN PyObject *_wrap_new_ColourPickerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45849
  PyObject *resultobj = 0;
 
45850
  wxObject *arg1 = (wxObject *) 0 ;
 
45851
  int arg2 ;
 
45852
  wxColour *arg3 = 0 ;
 
45853
  wxColourPickerEvent *result = 0 ;
 
45854
  void *argp1 = 0 ;
 
45855
  int res1 = 0 ;
 
45856
  int val2 ;
 
45857
  int ecode2 = 0 ;
 
45858
  wxColour temp3 ;
 
45859
  PyObject * obj0 = 0 ;
 
45860
  PyObject * obj1 = 0 ;
 
45861
  PyObject * obj2 = 0 ;
 
45862
  char *  kwnames[] = {
 
45863
    (char *) "generator",(char *) "id",(char *) "col", NULL 
 
45864
  };
 
45865
  
 
45866
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ColourPickerEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
45867
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 |  0 );
 
45868
  if (!SWIG_IsOK(res1)) {
 
45869
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColourPickerEvent" "', expected argument " "1"" of type '" "wxObject *""'"); 
 
45870
  }
 
45871
  arg1 = reinterpret_cast< wxObject * >(argp1);
 
45872
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
45873
  if (!SWIG_IsOK(ecode2)) {
 
45874
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColourPickerEvent" "', expected argument " "2"" of type '" "int""'");
 
45875
  } 
 
45876
  arg2 = static_cast< int >(val2);
 
45877
  {
 
45878
    arg3 = &temp3;
 
45879
    if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
 
45880
  }
 
45881
  {
 
45882
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45883
    result = (wxColourPickerEvent *)new wxColourPickerEvent(arg1,arg2,(wxColour const &)*arg3);
 
45884
    wxPyEndAllowThreads(__tstate);
 
45885
    if (PyErr_Occurred()) SWIG_fail;
 
45886
  }
 
45887
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourPickerEvent, SWIG_POINTER_NEW |  0 );
 
45888
  return resultobj;
 
45889
fail:
 
45890
  return NULL;
 
45891
}
 
45892
 
 
45893
 
 
45894
SWIGINTERN PyObject *_wrap_ColourPickerEvent_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45895
  PyObject *resultobj = 0;
 
45896
  wxColourPickerEvent *arg1 = (wxColourPickerEvent *) 0 ;
 
45897
  wxColour result;
 
45898
  void *argp1 = 0 ;
 
45899
  int res1 = 0 ;
 
45900
  PyObject *swig_obj[1] ;
 
45901
  
 
45902
  if (!args) SWIG_fail;
 
45903
  swig_obj[0] = args;
 
45904
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColourPickerEvent, 0 |  0 );
 
45905
  if (!SWIG_IsOK(res1)) {
 
45906
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourPickerEvent_GetColour" "', expected argument " "1"" of type '" "wxColourPickerEvent const *""'"); 
 
45907
  }
 
45908
  arg1 = reinterpret_cast< wxColourPickerEvent * >(argp1);
 
45909
  {
 
45910
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45911
    result = ((wxColourPickerEvent const *)arg1)->GetColour();
 
45912
    wxPyEndAllowThreads(__tstate);
 
45913
    if (PyErr_Occurred()) SWIG_fail;
 
45914
  }
 
45915
  resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN |  0 );
 
45916
  return resultobj;
 
45917
fail:
 
45918
  return NULL;
 
45919
}
 
45920
 
 
45921
 
 
45922
SWIGINTERN PyObject *_wrap_ColourPickerEvent_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
45923
  PyObject *resultobj = 0;
 
45924
  wxColourPickerEvent *arg1 = (wxColourPickerEvent *) 0 ;
 
45925
  wxColour *arg2 = 0 ;
 
45926
  void *argp1 = 0 ;
 
45927
  int res1 = 0 ;
 
45928
  wxColour temp2 ;
 
45929
  PyObject * obj0 = 0 ;
 
45930
  PyObject * obj1 = 0 ;
 
45931
  char *  kwnames[] = {
 
45932
    (char *) "self",(char *) "c", NULL 
 
45933
  };
 
45934
  
 
45935
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourPickerEvent_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
 
45936
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourPickerEvent, 0 |  0 );
 
45937
  if (!SWIG_IsOK(res1)) {
 
45938
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourPickerEvent_SetColour" "', expected argument " "1"" of type '" "wxColourPickerEvent *""'"); 
 
45939
  }
 
45940
  arg1 = reinterpret_cast< wxColourPickerEvent * >(argp1);
 
45941
  {
 
45942
    arg2 = &temp2;
 
45943
    if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
 
45944
  }
 
45945
  {
 
45946
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
45947
    (arg1)->SetColour((wxColour const &)*arg2);
 
45948
    wxPyEndAllowThreads(__tstate);
 
45949
    if (PyErr_Occurred()) SWIG_fail;
 
45950
  }
 
45951
  resultobj = SWIG_Py_Void();
 
45952
  return resultobj;
 
45953
fail:
 
45954
  return NULL;
 
45955
}
 
45956
 
 
45957
 
 
45958
SWIGINTERN PyObject *ColourPickerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45959
  PyObject *obj;
 
45960
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
45961
  SWIG_TypeNewClientData(SWIGTYPE_p_wxColourPickerEvent, SWIG_NewClientData(obj));
 
45962
  return SWIG_Py_Void();
 
45963
}
 
45964
 
 
45965
SWIGINTERN PyObject *ColourPickerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
45966
  return SWIG_Python_InitShadowInstance(args);
 
45967
}
 
45968
 
 
45969
SWIGINTERN int FilePickerCtrlNameStr_set(PyObject *) {
 
45970
  SWIG_Error(SWIG_AttributeError,"Variable FilePickerCtrlNameStr is read-only.");
 
45971
  return 1;
 
45972
}
 
45973
 
 
45974
 
 
45975
SWIGINTERN PyObject *FilePickerCtrlNameStr_get(void) {
 
45976
  PyObject *pyobj = 0;
 
45977
  
 
45978
  {
 
45979
#if wxUSE_UNICODE
 
45980
    pyobj = PyUnicode_FromWideChar((&wxPyFilePickerCtrlNameStr)->c_str(), (&wxPyFilePickerCtrlNameStr)->Len());
 
45981
#else
 
45982
    pyobj = PyString_FromStringAndSize((&wxPyFilePickerCtrlNameStr)->c_str(), (&wxPyFilePickerCtrlNameStr)->Len());
 
45983
#endif
 
45984
  }
 
45985
  return pyobj;
 
45986
}
 
45987
 
 
45988
 
 
45989
SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
 
45990
  SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
 
45991
  return 1;
 
45992
}
 
45993
 
 
45994
 
 
45995
SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
 
45996
  PyObject *pyobj = 0;
 
45997
  
 
45998
  {
 
45999
#if wxUSE_UNICODE
 
46000
    pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
 
46001
#else
 
46002
    pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
 
46003
#endif
 
46004
  }
 
46005
  return pyobj;
 
46006
}
 
46007
 
 
46008
 
 
46009
SWIGINTERN int DirPickerCtrlNameStr_set(PyObject *) {
 
46010
  SWIG_Error(SWIG_AttributeError,"Variable DirPickerCtrlNameStr is read-only.");
 
46011
  return 1;
 
46012
}
 
46013
 
 
46014
 
 
46015
SWIGINTERN PyObject *DirPickerCtrlNameStr_get(void) {
 
46016
  PyObject *pyobj = 0;
 
46017
  
 
46018
  {
 
46019
#if wxUSE_UNICODE
 
46020
    pyobj = PyUnicode_FromWideChar((&wxPyDirPickerCtrlNameStr)->c_str(), (&wxPyDirPickerCtrlNameStr)->Len());
 
46021
#else
 
46022
    pyobj = PyString_FromStringAndSize((&wxPyDirPickerCtrlNameStr)->c_str(), (&wxPyDirPickerCtrlNameStr)->Len());
 
46023
#endif
 
46024
  }
 
46025
  return pyobj;
 
46026
}
 
46027
 
 
46028
 
 
46029
SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
 
46030
  SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
 
46031
  return 1;
 
46032
}
 
46033
 
 
46034
 
 
46035
SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
 
46036
  PyObject *pyobj = 0;
 
46037
  
 
46038
  {
 
46039
#if wxUSE_UNICODE
 
46040
    pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
 
46041
#else
 
46042
    pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
 
46043
#endif
 
46044
  }
 
46045
  return pyobj;
 
46046
}
 
46047
 
 
46048
 
 
46049
SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
 
46050
  SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
 
46051
  return 1;
 
46052
}
 
46053
 
 
46054
 
 
46055
SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
 
46056
  PyObject *pyobj = 0;
 
46057
  
 
46058
  {
 
46059
#if wxUSE_UNICODE
 
46060
    pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
 
46061
#else
 
46062
    pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
 
46063
#endif
 
46064
  }
 
46065
  return pyobj;
 
46066
}
 
46067
 
 
46068
 
 
46069
SWIGINTERN PyObject *_wrap_new_FilePickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
46070
  PyObject *resultobj = 0;
 
46071
  wxWindow *arg1 = (wxWindow *) 0 ;
 
46072
  int arg2 = (int) -1 ;
 
46073
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
46074
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
46075
  wxString const &arg4_defvalue = wxPyFileSelectorPromptStr ;
 
46076
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
46077
  wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
 
46078
  wxString *arg5 = (wxString *) &arg5_defvalue ;
 
46079
  wxPoint const &arg6_defvalue = wxDefaultPosition ;
 
46080
  wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
 
46081
  wxSize const &arg7_defvalue = wxDefaultSize ;
 
46082
  wxSize *arg7 = (wxSize *) &arg7_defvalue ;
 
46083
  long arg8 = (long) wxFLP_DEFAULT_STYLE ;
 
46084
  wxValidator const &arg9_defvalue = wxDefaultValidator ;
 
46085
  wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
 
46086
  wxString const &arg10_defvalue = wxPyFilePickerCtrlNameStr ;
 
46087
  wxString *arg10 = (wxString *) &arg10_defvalue ;
 
46088
  wxFilePickerCtrl *result = 0 ;
 
46089
  void *argp1 = 0 ;
 
46090
  int res1 = 0 ;
 
46091
  int val2 ;
 
46092
  int ecode2 = 0 ;
 
46093
  bool temp3 = false ;
 
46094
  bool temp4 = false ;
 
46095
  bool temp5 = false ;
 
46096
  wxPoint temp6 ;
 
46097
  wxSize temp7 ;
 
46098
  long val8 ;
 
46099
  int ecode8 = 0 ;
 
46100
  void *argp9 = 0 ;
 
46101
  int res9 = 0 ;
 
46102
  bool temp10 = false ;
 
46103
  PyObject * obj0 = 0 ;
 
46104
  PyObject * obj1 = 0 ;
 
46105
  PyObject * obj2 = 0 ;
 
46106
  PyObject * obj3 = 0 ;
 
46107
  PyObject * obj4 = 0 ;
 
46108
  PyObject * obj5 = 0 ;
 
46109
  PyObject * obj6 = 0 ;
 
46110
  PyObject * obj7 = 0 ;
 
46111
  PyObject * obj8 = 0 ;
 
46112
  PyObject * obj9 = 0 ;
 
46113
  char *  kwnames[] = {
 
46114
    (char *) "parent",(char *) "id",(char *) "path",(char *) "message",(char *) "wildcard",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
46115
  };
 
46116
  
 
46117
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOOO:new_FilePickerCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
 
46118
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
46119
  if (!SWIG_IsOK(res1)) {
 
46120
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FilePickerCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
46121
  }
 
46122
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
46123
  if (obj1) {
 
46124
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
46125
    if (!SWIG_IsOK(ecode2)) {
 
46126
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FilePickerCtrl" "', expected argument " "2"" of type '" "int""'");
 
46127
    } 
 
46128
    arg2 = static_cast< int >(val2);
 
46129
  }
 
46130
  if (obj2) {
 
46131
    {
 
46132
      arg3 = wxString_in_helper(obj2);
 
46133
      if (arg3 == NULL) SWIG_fail;
 
46134
      temp3 = true;
 
46135
    }
 
46136
  }
 
46137
  if (obj3) {
 
46138
    {
 
46139
      arg4 = wxString_in_helper(obj3);
 
46140
      if (arg4 == NULL) SWIG_fail;
 
46141
      temp4 = true;
 
46142
    }
 
46143
  }
 
46144
  if (obj4) {
 
46145
    {
 
46146
      arg5 = wxString_in_helper(obj4);
 
46147
      if (arg5 == NULL) SWIG_fail;
 
46148
      temp5 = true;
 
46149
    }
 
46150
  }
 
46151
  if (obj5) {
 
46152
    {
 
46153
      arg6 = &temp6;
 
46154
      if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
 
46155
    }
 
46156
  }
 
46157
  if (obj6) {
 
46158
    {
 
46159
      arg7 = &temp7;
 
46160
      if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
 
46161
    }
 
46162
  }
 
46163
  if (obj7) {
 
46164
    ecode8 = SWIG_AsVal_long(obj7, &val8);
 
46165
    if (!SWIG_IsOK(ecode8)) {
 
46166
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FilePickerCtrl" "', expected argument " "8"" of type '" "long""'");
 
46167
    } 
 
46168
    arg8 = static_cast< long >(val8);
 
46169
  }
 
46170
  if (obj8) {
 
46171
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_wxValidator,  0  | 0);
 
46172
    if (!SWIG_IsOK(res9)) {
 
46173
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FilePickerCtrl" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
46174
    }
 
46175
    if (!argp9) {
 
46176
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FilePickerCtrl" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
46177
    }
 
46178
    arg9 = reinterpret_cast< wxValidator * >(argp9);
 
46179
  }
 
46180
  if (obj9) {
 
46181
    {
 
46182
      arg10 = wxString_in_helper(obj9);
 
46183
      if (arg10 == NULL) SWIG_fail;
 
46184
      temp10 = true;
 
46185
    }
 
46186
  }
 
46187
  {
 
46188
    if (!wxPyCheckForApp()) SWIG_fail;
 
46189
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46190
    result = (wxFilePickerCtrl *)new wxFilePickerCtrl(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);
 
46191
    wxPyEndAllowThreads(__tstate);
 
46192
    if (PyErr_Occurred()) SWIG_fail;
 
46193
  }
 
46194
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFilePickerCtrl, SWIG_POINTER_NEW |  0 );
 
46195
  {
 
46196
    if (temp3)
 
46197
    delete arg3;
 
46198
  }
 
46199
  {
 
46200
    if (temp4)
 
46201
    delete arg4;
 
46202
  }
 
46203
  {
 
46204
    if (temp5)
 
46205
    delete arg5;
 
46206
  }
 
46207
  {
 
46208
    if (temp10)
 
46209
    delete arg10;
 
46210
  }
 
46211
  return resultobj;
 
46212
fail:
 
46213
  {
 
46214
    if (temp3)
 
46215
    delete arg3;
 
46216
  }
 
46217
  {
 
46218
    if (temp4)
 
46219
    delete arg4;
 
46220
  }
 
46221
  {
 
46222
    if (temp5)
 
46223
    delete arg5;
 
46224
  }
 
46225
  {
 
46226
    if (temp10)
 
46227
    delete arg10;
 
46228
  }
 
46229
  return NULL;
 
46230
}
 
46231
 
 
46232
 
 
46233
SWIGINTERN PyObject *_wrap_new_PreFilePickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
46234
  PyObject *resultobj = 0;
 
46235
  wxFilePickerCtrl *result = 0 ;
 
46236
  
 
46237
  if (!SWIG_Python_UnpackTuple(args,"new_PreFilePickerCtrl",0,0,0)) SWIG_fail;
 
46238
  {
 
46239
    if (!wxPyCheckForApp()) SWIG_fail;
 
46240
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46241
    result = (wxFilePickerCtrl *)new wxFilePickerCtrl();
 
46242
    wxPyEndAllowThreads(__tstate);
 
46243
    if (PyErr_Occurred()) SWIG_fail;
 
46244
  }
 
46245
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFilePickerCtrl, SWIG_POINTER_OWN |  0 );
 
46246
  return resultobj;
 
46247
fail:
 
46248
  return NULL;
 
46249
}
 
46250
 
 
46251
 
 
46252
SWIGINTERN PyObject *_wrap_FilePickerCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
46253
  PyObject *resultobj = 0;
 
46254
  wxFilePickerCtrl *arg1 = (wxFilePickerCtrl *) 0 ;
 
46255
  wxWindow *arg2 = (wxWindow *) 0 ;
 
46256
  int arg3 = (int) -1 ;
 
46257
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
46258
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
46259
  wxString const &arg5_defvalue = wxPyFileSelectorPromptStr ;
 
46260
  wxString *arg5 = (wxString *) &arg5_defvalue ;
 
46261
  wxString const &arg6_defvalue = wxPyFileSelectorDefaultWildcardStr ;
 
46262
  wxString *arg6 = (wxString *) &arg6_defvalue ;
 
46263
  wxPoint const &arg7_defvalue = wxDefaultPosition ;
 
46264
  wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
 
46265
  wxSize const &arg8_defvalue = wxDefaultSize ;
 
46266
  wxSize *arg8 = (wxSize *) &arg8_defvalue ;
 
46267
  long arg9 = (long) wxFLP_DEFAULT_STYLE ;
 
46268
  wxValidator const &arg10_defvalue = wxDefaultValidator ;
 
46269
  wxValidator *arg10 = (wxValidator *) &arg10_defvalue ;
 
46270
  wxString const &arg11_defvalue = wxPyFilePickerCtrlNameStr ;
 
46271
  wxString *arg11 = (wxString *) &arg11_defvalue ;
 
46272
  bool result;
 
46273
  void *argp1 = 0 ;
 
46274
  int res1 = 0 ;
 
46275
  void *argp2 = 0 ;
 
46276
  int res2 = 0 ;
 
46277
  int val3 ;
 
46278
  int ecode3 = 0 ;
 
46279
  bool temp4 = false ;
 
46280
  bool temp5 = false ;
 
46281
  bool temp6 = false ;
 
46282
  wxPoint temp7 ;
 
46283
  wxSize temp8 ;
 
46284
  long val9 ;
 
46285
  int ecode9 = 0 ;
 
46286
  void *argp10 = 0 ;
 
46287
  int res10 = 0 ;
 
46288
  bool temp11 = false ;
 
46289
  PyObject * obj0 = 0 ;
 
46290
  PyObject * obj1 = 0 ;
 
46291
  PyObject * obj2 = 0 ;
 
46292
  PyObject * obj3 = 0 ;
 
46293
  PyObject * obj4 = 0 ;
 
46294
  PyObject * obj5 = 0 ;
 
46295
  PyObject * obj6 = 0 ;
 
46296
  PyObject * obj7 = 0 ;
 
46297
  PyObject * obj8 = 0 ;
 
46298
  PyObject * obj9 = 0 ;
 
46299
  PyObject * obj10 = 0 ;
 
46300
  char *  kwnames[] = {
 
46301
    (char *) "self",(char *) "parent",(char *) "id",(char *) "path",(char *) "message",(char *) "wildcard",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
46302
  };
 
46303
  
 
46304
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOOO:FilePickerCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
 
46305
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFilePickerCtrl, 0 |  0 );
 
46306
  if (!SWIG_IsOK(res1)) {
 
46307
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FilePickerCtrl_Create" "', expected argument " "1"" of type '" "wxFilePickerCtrl *""'"); 
 
46308
  }
 
46309
  arg1 = reinterpret_cast< wxFilePickerCtrl * >(argp1);
 
46310
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
46311
  if (!SWIG_IsOK(res2)) {
 
46312
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FilePickerCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
46313
  }
 
46314
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
46315
  if (obj2) {
 
46316
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
46317
    if (!SWIG_IsOK(ecode3)) {
 
46318
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FilePickerCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
46319
    } 
 
46320
    arg3 = static_cast< int >(val3);
 
46321
  }
 
46322
  if (obj3) {
 
46323
    {
 
46324
      arg4 = wxString_in_helper(obj3);
 
46325
      if (arg4 == NULL) SWIG_fail;
 
46326
      temp4 = true;
 
46327
    }
 
46328
  }
 
46329
  if (obj4) {
 
46330
    {
 
46331
      arg5 = wxString_in_helper(obj4);
 
46332
      if (arg5 == NULL) SWIG_fail;
 
46333
      temp5 = true;
 
46334
    }
 
46335
  }
 
46336
  if (obj5) {
 
46337
    {
 
46338
      arg6 = wxString_in_helper(obj5);
 
46339
      if (arg6 == NULL) SWIG_fail;
 
46340
      temp6 = true;
 
46341
    }
 
46342
  }
 
46343
  if (obj6) {
 
46344
    {
 
46345
      arg7 = &temp7;
 
46346
      if ( ! wxPoint_helper(obj6, &arg7)) SWIG_fail;
 
46347
    }
 
46348
  }
 
46349
  if (obj7) {
 
46350
    {
 
46351
      arg8 = &temp8;
 
46352
      if ( ! wxSize_helper(obj7, &arg8)) SWIG_fail;
 
46353
    }
 
46354
  }
 
46355
  if (obj8) {
 
46356
    ecode9 = SWIG_AsVal_long(obj8, &val9);
 
46357
    if (!SWIG_IsOK(ecode9)) {
 
46358
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FilePickerCtrl_Create" "', expected argument " "9"" of type '" "long""'");
 
46359
    } 
 
46360
    arg9 = static_cast< long >(val9);
 
46361
  }
 
46362
  if (obj9) {
 
46363
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_wxValidator,  0  | 0);
 
46364
    if (!SWIG_IsOK(res10)) {
 
46365
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "FilePickerCtrl_Create" "', expected argument " "10"" of type '" "wxValidator const &""'"); 
 
46366
    }
 
46367
    if (!argp10) {
 
46368
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FilePickerCtrl_Create" "', expected argument " "10"" of type '" "wxValidator const &""'"); 
 
46369
    }
 
46370
    arg10 = reinterpret_cast< wxValidator * >(argp10);
 
46371
  }
 
46372
  if (obj10) {
 
46373
    {
 
46374
      arg11 = wxString_in_helper(obj10);
 
46375
      if (arg11 == NULL) SWIG_fail;
 
46376
      temp11 = true;
 
46377
    }
 
46378
  }
 
46379
  {
 
46380
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46381
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxString const &)*arg6,(wxPoint const &)*arg7,(wxSize const &)*arg8,arg9,(wxValidator const &)*arg10,(wxString const &)*arg11);
 
46382
    wxPyEndAllowThreads(__tstate);
 
46383
    if (PyErr_Occurred()) SWIG_fail;
 
46384
  }
 
46385
  {
 
46386
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
46387
  }
 
46388
  {
 
46389
    if (temp4)
 
46390
    delete arg4;
 
46391
  }
 
46392
  {
 
46393
    if (temp5)
 
46394
    delete arg5;
 
46395
  }
 
46396
  {
 
46397
    if (temp6)
 
46398
    delete arg6;
 
46399
  }
 
46400
  {
 
46401
    if (temp11)
 
46402
    delete arg11;
 
46403
  }
 
46404
  return resultobj;
 
46405
fail:
 
46406
  {
 
46407
    if (temp4)
 
46408
    delete arg4;
 
46409
  }
 
46410
  {
 
46411
    if (temp5)
 
46412
    delete arg5;
 
46413
  }
 
46414
  {
 
46415
    if (temp6)
 
46416
    delete arg6;
 
46417
  }
 
46418
  {
 
46419
    if (temp11)
 
46420
    delete arg11;
 
46421
  }
 
46422
  return NULL;
 
46423
}
 
46424
 
 
46425
 
 
46426
SWIGINTERN PyObject *_wrap_FilePickerCtrl_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
46427
  PyObject *resultobj = 0;
 
46428
  wxFilePickerCtrl *arg1 = (wxFilePickerCtrl *) 0 ;
 
46429
  wxString result;
 
46430
  void *argp1 = 0 ;
 
46431
  int res1 = 0 ;
 
46432
  PyObject *swig_obj[1] ;
 
46433
  
 
46434
  if (!args) SWIG_fail;
 
46435
  swig_obj[0] = args;
 
46436
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFilePickerCtrl, 0 |  0 );
 
46437
  if (!SWIG_IsOK(res1)) {
 
46438
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FilePickerCtrl_GetPath" "', expected argument " "1"" of type '" "wxFilePickerCtrl const *""'"); 
 
46439
  }
 
46440
  arg1 = reinterpret_cast< wxFilePickerCtrl * >(argp1);
 
46441
  {
 
46442
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46443
    result = ((wxFilePickerCtrl const *)arg1)->GetPath();
 
46444
    wxPyEndAllowThreads(__tstate);
 
46445
    if (PyErr_Occurred()) SWIG_fail;
 
46446
  }
 
46447
  {
 
46448
#if wxUSE_UNICODE
 
46449
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
46450
#else
 
46451
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
46452
#endif
 
46453
  }
 
46454
  return resultobj;
 
46455
fail:
 
46456
  return NULL;
 
46457
}
 
46458
 
 
46459
 
 
46460
SWIGINTERN PyObject *_wrap_FilePickerCtrl_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
46461
  PyObject *resultobj = 0;
 
46462
  wxFilePickerCtrl *arg1 = (wxFilePickerCtrl *) 0 ;
 
46463
  wxString *arg2 = 0 ;
 
46464
  void *argp1 = 0 ;
 
46465
  int res1 = 0 ;
 
46466
  bool temp2 = false ;
 
46467
  PyObject * obj0 = 0 ;
 
46468
  PyObject * obj1 = 0 ;
 
46469
  char *  kwnames[] = {
 
46470
    (char *) "self",(char *) "str", NULL 
 
46471
  };
 
46472
  
 
46473
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FilePickerCtrl_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
 
46474
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFilePickerCtrl, 0 |  0 );
 
46475
  if (!SWIG_IsOK(res1)) {
 
46476
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FilePickerCtrl_SetPath" "', expected argument " "1"" of type '" "wxFilePickerCtrl *""'"); 
 
46477
  }
 
46478
  arg1 = reinterpret_cast< wxFilePickerCtrl * >(argp1);
 
46479
  {
 
46480
    arg2 = wxString_in_helper(obj1);
 
46481
    if (arg2 == NULL) SWIG_fail;
 
46482
    temp2 = true;
 
46483
  }
 
46484
  {
 
46485
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46486
    (arg1)->SetPath((wxString const &)*arg2);
 
46487
    wxPyEndAllowThreads(__tstate);
 
46488
    if (PyErr_Occurred()) SWIG_fail;
 
46489
  }
 
46490
  resultobj = SWIG_Py_Void();
 
46491
  {
 
46492
    if (temp2)
 
46493
    delete arg2;
 
46494
  }
 
46495
  return resultobj;
 
46496
fail:
 
46497
  {
 
46498
    if (temp2)
 
46499
    delete arg2;
 
46500
  }
 
46501
  return NULL;
 
46502
}
 
46503
 
 
46504
 
 
46505
SWIGINTERN PyObject *_wrap_FilePickerCtrl_CheckPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
46506
  PyObject *resultobj = 0;
 
46507
  wxFilePickerCtrl *arg1 = (wxFilePickerCtrl *) 0 ;
 
46508
  wxString *arg2 = 0 ;
 
46509
  bool result;
 
46510
  void *argp1 = 0 ;
 
46511
  int res1 = 0 ;
 
46512
  bool temp2 = false ;
 
46513
  PyObject * obj0 = 0 ;
 
46514
  PyObject * obj1 = 0 ;
 
46515
  char *  kwnames[] = {
 
46516
    (char *) "self",(char *) "path", NULL 
 
46517
  };
 
46518
  
 
46519
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FilePickerCtrl_CheckPath",kwnames,&obj0,&obj1)) SWIG_fail;
 
46520
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFilePickerCtrl, 0 |  0 );
 
46521
  if (!SWIG_IsOK(res1)) {
 
46522
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FilePickerCtrl_CheckPath" "', expected argument " "1"" of type '" "wxFilePickerCtrl const *""'"); 
 
46523
  }
 
46524
  arg1 = reinterpret_cast< wxFilePickerCtrl * >(argp1);
 
46525
  {
 
46526
    arg2 = wxString_in_helper(obj1);
 
46527
    if (arg2 == NULL) SWIG_fail;
 
46528
    temp2 = true;
 
46529
  }
 
46530
  {
 
46531
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46532
    result = (bool)((wxFilePickerCtrl const *)arg1)->CheckPath((wxString const &)*arg2);
 
46533
    wxPyEndAllowThreads(__tstate);
 
46534
    if (PyErr_Occurred()) SWIG_fail;
 
46535
  }
 
46536
  {
 
46537
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
46538
  }
 
46539
  {
 
46540
    if (temp2)
 
46541
    delete arg2;
 
46542
  }
 
46543
  return resultobj;
 
46544
fail:
 
46545
  {
 
46546
    if (temp2)
 
46547
    delete arg2;
 
46548
  }
 
46549
  return NULL;
 
46550
}
 
46551
 
 
46552
 
 
46553
SWIGINTERN PyObject *_wrap_FilePickerCtrl_GetTextCtrlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
46554
  PyObject *resultobj = 0;
 
46555
  wxFilePickerCtrl *arg1 = (wxFilePickerCtrl *) 0 ;
 
46556
  wxString result;
 
46557
  void *argp1 = 0 ;
 
46558
  int res1 = 0 ;
 
46559
  PyObject *swig_obj[1] ;
 
46560
  
 
46561
  if (!args) SWIG_fail;
 
46562
  swig_obj[0] = args;
 
46563
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFilePickerCtrl, 0 |  0 );
 
46564
  if (!SWIG_IsOK(res1)) {
 
46565
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FilePickerCtrl_GetTextCtrlValue" "', expected argument " "1"" of type '" "wxFilePickerCtrl const *""'"); 
 
46566
  }
 
46567
  arg1 = reinterpret_cast< wxFilePickerCtrl * >(argp1);
 
46568
  {
 
46569
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46570
    result = ((wxFilePickerCtrl const *)arg1)->GetTextCtrlValue();
 
46571
    wxPyEndAllowThreads(__tstate);
 
46572
    if (PyErr_Occurred()) SWIG_fail;
 
46573
  }
 
46574
  {
 
46575
#if wxUSE_UNICODE
 
46576
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
46577
#else
 
46578
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
46579
#endif
 
46580
  }
 
46581
  return resultobj;
 
46582
fail:
 
46583
  return NULL;
 
46584
}
 
46585
 
 
46586
 
 
46587
SWIGINTERN PyObject *FilePickerCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
46588
  PyObject *obj;
 
46589
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
46590
  SWIG_TypeNewClientData(SWIGTYPE_p_wxFilePickerCtrl, SWIG_NewClientData(obj));
 
46591
  return SWIG_Py_Void();
 
46592
}
 
46593
 
 
46594
SWIGINTERN PyObject *FilePickerCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
46595
  return SWIG_Python_InitShadowInstance(args);
 
46596
}
 
46597
 
 
46598
SWIGINTERN PyObject *_wrap_new_DirPickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
46599
  PyObject *resultobj = 0;
 
46600
  wxWindow *arg1 = (wxWindow *) 0 ;
 
46601
  int arg2 = (int) -1 ;
 
46602
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
46603
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
46604
  wxString const &arg4_defvalue = wxPyDirSelectorPromptStr ;
 
46605
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
46606
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
46607
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
46608
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
46609
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
46610
  long arg7 = (long) wxDIRP_DEFAULT_STYLE ;
 
46611
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
46612
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
46613
  wxString const &arg9_defvalue = wxPyDirPickerCtrlNameStr ;
 
46614
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
46615
  wxDirPickerCtrl *result = 0 ;
 
46616
  void *argp1 = 0 ;
 
46617
  int res1 = 0 ;
 
46618
  int val2 ;
 
46619
  int ecode2 = 0 ;
 
46620
  bool temp3 = false ;
 
46621
  bool temp4 = false ;
 
46622
  wxPoint temp5 ;
 
46623
  wxSize temp6 ;
 
46624
  long val7 ;
 
46625
  int ecode7 = 0 ;
 
46626
  void *argp8 = 0 ;
 
46627
  int res8 = 0 ;
 
46628
  bool temp9 = false ;
 
46629
  PyObject * obj0 = 0 ;
 
46630
  PyObject * obj1 = 0 ;
 
46631
  PyObject * obj2 = 0 ;
 
46632
  PyObject * obj3 = 0 ;
 
46633
  PyObject * obj4 = 0 ;
 
46634
  PyObject * obj5 = 0 ;
 
46635
  PyObject * obj6 = 0 ;
 
46636
  PyObject * obj7 = 0 ;
 
46637
  PyObject * obj8 = 0 ;
 
46638
  char *  kwnames[] = {
 
46639
    (char *) "parent",(char *) "id",(char *) "path",(char *) "message",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
46640
  };
 
46641
  
 
46642
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_DirPickerCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
46643
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
46644
  if (!SWIG_IsOK(res1)) {
 
46645
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DirPickerCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
46646
  }
 
46647
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
46648
  if (obj1) {
 
46649
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
46650
    if (!SWIG_IsOK(ecode2)) {
 
46651
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DirPickerCtrl" "', expected argument " "2"" of type '" "int""'");
 
46652
    } 
 
46653
    arg2 = static_cast< int >(val2);
 
46654
  }
 
46655
  if (obj2) {
 
46656
    {
 
46657
      arg3 = wxString_in_helper(obj2);
 
46658
      if (arg3 == NULL) SWIG_fail;
 
46659
      temp3 = true;
 
46660
    }
 
46661
  }
 
46662
  if (obj3) {
 
46663
    {
 
46664
      arg4 = wxString_in_helper(obj3);
 
46665
      if (arg4 == NULL) SWIG_fail;
 
46666
      temp4 = true;
 
46667
    }
 
46668
  }
 
46669
  if (obj4) {
 
46670
    {
 
46671
      arg5 = &temp5;
 
46672
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
46673
    }
 
46674
  }
 
46675
  if (obj5) {
 
46676
    {
 
46677
      arg6 = &temp6;
 
46678
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
46679
    }
 
46680
  }
 
46681
  if (obj6) {
 
46682
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
46683
    if (!SWIG_IsOK(ecode7)) {
 
46684
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DirPickerCtrl" "', expected argument " "7"" of type '" "long""'");
 
46685
    } 
 
46686
    arg7 = static_cast< long >(val7);
 
46687
  }
 
46688
  if (obj7) {
 
46689
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
46690
    if (!SWIG_IsOK(res8)) {
 
46691
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_DirPickerCtrl" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
46692
    }
 
46693
    if (!argp8) {
 
46694
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DirPickerCtrl" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
46695
    }
 
46696
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
46697
  }
 
46698
  if (obj8) {
 
46699
    {
 
46700
      arg9 = wxString_in_helper(obj8);
 
46701
      if (arg9 == NULL) SWIG_fail;
 
46702
      temp9 = true;
 
46703
    }
 
46704
  }
 
46705
  {
 
46706
    if (!wxPyCheckForApp()) SWIG_fail;
 
46707
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46708
    result = (wxDirPickerCtrl *)new wxDirPickerCtrl(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
46709
    wxPyEndAllowThreads(__tstate);
 
46710
    if (PyErr_Occurred()) SWIG_fail;
 
46711
  }
 
46712
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDirPickerCtrl, SWIG_POINTER_NEW |  0 );
 
46713
  {
 
46714
    if (temp3)
 
46715
    delete arg3;
 
46716
  }
 
46717
  {
 
46718
    if (temp4)
 
46719
    delete arg4;
 
46720
  }
 
46721
  {
 
46722
    if (temp9)
 
46723
    delete arg9;
 
46724
  }
 
46725
  return resultobj;
 
46726
fail:
 
46727
  {
 
46728
    if (temp3)
 
46729
    delete arg3;
 
46730
  }
 
46731
  {
 
46732
    if (temp4)
 
46733
    delete arg4;
 
46734
  }
 
46735
  {
 
46736
    if (temp9)
 
46737
    delete arg9;
 
46738
  }
 
46739
  return NULL;
 
46740
}
 
46741
 
 
46742
 
 
46743
SWIGINTERN PyObject *_wrap_new_PreDirPickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
46744
  PyObject *resultobj = 0;
 
46745
  wxDirPickerCtrl *result = 0 ;
 
46746
  
 
46747
  if (!SWIG_Python_UnpackTuple(args,"new_PreDirPickerCtrl",0,0,0)) SWIG_fail;
 
46748
  {
 
46749
    if (!wxPyCheckForApp()) SWIG_fail;
 
46750
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46751
    result = (wxDirPickerCtrl *)new wxDirPickerCtrl();
 
46752
    wxPyEndAllowThreads(__tstate);
 
46753
    if (PyErr_Occurred()) SWIG_fail;
 
46754
  }
 
46755
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDirPickerCtrl, SWIG_POINTER_OWN |  0 );
 
46756
  return resultobj;
 
46757
fail:
 
46758
  return NULL;
 
46759
}
 
46760
 
 
46761
 
 
46762
SWIGINTERN PyObject *_wrap_DirPickerCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
46763
  PyObject *resultobj = 0;
 
46764
  wxDirPickerCtrl *arg1 = (wxDirPickerCtrl *) 0 ;
 
46765
  wxWindow *arg2 = (wxWindow *) 0 ;
 
46766
  int arg3 = (int) -1 ;
 
46767
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
46768
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
46769
  wxString const &arg5_defvalue = wxPyDirSelectorPromptStr ;
 
46770
  wxString *arg5 = (wxString *) &arg5_defvalue ;
 
46771
  wxPoint const &arg6_defvalue = wxDefaultPosition ;
 
46772
  wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
 
46773
  wxSize const &arg7_defvalue = wxDefaultSize ;
 
46774
  wxSize *arg7 = (wxSize *) &arg7_defvalue ;
 
46775
  long arg8 = (long) wxDIRP_DEFAULT_STYLE ;
 
46776
  wxValidator const &arg9_defvalue = wxDefaultValidator ;
 
46777
  wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
 
46778
  wxString const &arg10_defvalue = wxPyDirPickerCtrlNameStr ;
 
46779
  wxString *arg10 = (wxString *) &arg10_defvalue ;
 
46780
  bool result;
 
46781
  void *argp1 = 0 ;
 
46782
  int res1 = 0 ;
 
46783
  void *argp2 = 0 ;
 
46784
  int res2 = 0 ;
 
46785
  int val3 ;
 
46786
  int ecode3 = 0 ;
 
46787
  bool temp4 = false ;
 
46788
  bool temp5 = false ;
 
46789
  wxPoint temp6 ;
 
46790
  wxSize temp7 ;
 
46791
  long val8 ;
 
46792
  int ecode8 = 0 ;
 
46793
  void *argp9 = 0 ;
 
46794
  int res9 = 0 ;
 
46795
  bool temp10 = false ;
 
46796
  PyObject * obj0 = 0 ;
 
46797
  PyObject * obj1 = 0 ;
 
46798
  PyObject * obj2 = 0 ;
 
46799
  PyObject * obj3 = 0 ;
 
46800
  PyObject * obj4 = 0 ;
 
46801
  PyObject * obj5 = 0 ;
 
46802
  PyObject * obj6 = 0 ;
 
46803
  PyObject * obj7 = 0 ;
 
46804
  PyObject * obj8 = 0 ;
 
46805
  PyObject * obj9 = 0 ;
 
46806
  char *  kwnames[] = {
 
46807
    (char *) "self",(char *) "parent",(char *) "id",(char *) "path",(char *) "message",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
46808
  };
 
46809
  
 
46810
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:DirPickerCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
 
46811
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDirPickerCtrl, 0 |  0 );
 
46812
  if (!SWIG_IsOK(res1)) {
 
46813
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirPickerCtrl_Create" "', expected argument " "1"" of type '" "wxDirPickerCtrl *""'"); 
 
46814
  }
 
46815
  arg1 = reinterpret_cast< wxDirPickerCtrl * >(argp1);
 
46816
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
46817
  if (!SWIG_IsOK(res2)) {
 
46818
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DirPickerCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
46819
  }
 
46820
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
46821
  if (obj2) {
 
46822
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
46823
    if (!SWIG_IsOK(ecode3)) {
 
46824
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirPickerCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
46825
    } 
 
46826
    arg3 = static_cast< int >(val3);
 
46827
  }
 
46828
  if (obj3) {
 
46829
    {
 
46830
      arg4 = wxString_in_helper(obj3);
 
46831
      if (arg4 == NULL) SWIG_fail;
 
46832
      temp4 = true;
 
46833
    }
 
46834
  }
 
46835
  if (obj4) {
 
46836
    {
 
46837
      arg5 = wxString_in_helper(obj4);
 
46838
      if (arg5 == NULL) SWIG_fail;
 
46839
      temp5 = true;
 
46840
    }
 
46841
  }
 
46842
  if (obj5) {
 
46843
    {
 
46844
      arg6 = &temp6;
 
46845
      if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
 
46846
    }
 
46847
  }
 
46848
  if (obj6) {
 
46849
    {
 
46850
      arg7 = &temp7;
 
46851
      if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
 
46852
    }
 
46853
  }
 
46854
  if (obj7) {
 
46855
    ecode8 = SWIG_AsVal_long(obj7, &val8);
 
46856
    if (!SWIG_IsOK(ecode8)) {
 
46857
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DirPickerCtrl_Create" "', expected argument " "8"" of type '" "long""'");
 
46858
    } 
 
46859
    arg8 = static_cast< long >(val8);
 
46860
  }
 
46861
  if (obj8) {
 
46862
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_wxValidator,  0  | 0);
 
46863
    if (!SWIG_IsOK(res9)) {
 
46864
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "DirPickerCtrl_Create" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
46865
    }
 
46866
    if (!argp9) {
 
46867
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DirPickerCtrl_Create" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
46868
    }
 
46869
    arg9 = reinterpret_cast< wxValidator * >(argp9);
 
46870
  }
 
46871
  if (obj9) {
 
46872
    {
 
46873
      arg10 = wxString_in_helper(obj9);
 
46874
      if (arg10 == NULL) SWIG_fail;
 
46875
      temp10 = true;
 
46876
    }
 
46877
  }
 
46878
  {
 
46879
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46880
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);
 
46881
    wxPyEndAllowThreads(__tstate);
 
46882
    if (PyErr_Occurred()) SWIG_fail;
 
46883
  }
 
46884
  {
 
46885
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
46886
  }
 
46887
  {
 
46888
    if (temp4)
 
46889
    delete arg4;
 
46890
  }
 
46891
  {
 
46892
    if (temp5)
 
46893
    delete arg5;
 
46894
  }
 
46895
  {
 
46896
    if (temp10)
 
46897
    delete arg10;
 
46898
  }
 
46899
  return resultobj;
 
46900
fail:
 
46901
  {
 
46902
    if (temp4)
 
46903
    delete arg4;
 
46904
  }
 
46905
  {
 
46906
    if (temp5)
 
46907
    delete arg5;
 
46908
  }
 
46909
  {
 
46910
    if (temp10)
 
46911
    delete arg10;
 
46912
  }
 
46913
  return NULL;
 
46914
}
 
46915
 
 
46916
 
 
46917
SWIGINTERN PyObject *_wrap_DirPickerCtrl_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
46918
  PyObject *resultobj = 0;
 
46919
  wxDirPickerCtrl *arg1 = (wxDirPickerCtrl *) 0 ;
 
46920
  wxString result;
 
46921
  void *argp1 = 0 ;
 
46922
  int res1 = 0 ;
 
46923
  PyObject *swig_obj[1] ;
 
46924
  
 
46925
  if (!args) SWIG_fail;
 
46926
  swig_obj[0] = args;
 
46927
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirPickerCtrl, 0 |  0 );
 
46928
  if (!SWIG_IsOK(res1)) {
 
46929
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirPickerCtrl_GetPath" "', expected argument " "1"" of type '" "wxDirPickerCtrl const *""'"); 
 
46930
  }
 
46931
  arg1 = reinterpret_cast< wxDirPickerCtrl * >(argp1);
 
46932
  {
 
46933
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46934
    result = ((wxDirPickerCtrl const *)arg1)->GetPath();
 
46935
    wxPyEndAllowThreads(__tstate);
 
46936
    if (PyErr_Occurred()) SWIG_fail;
 
46937
  }
 
46938
  {
 
46939
#if wxUSE_UNICODE
 
46940
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
46941
#else
 
46942
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
46943
#endif
 
46944
  }
 
46945
  return resultobj;
 
46946
fail:
 
46947
  return NULL;
 
46948
}
 
46949
 
 
46950
 
 
46951
SWIGINTERN PyObject *_wrap_DirPickerCtrl_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
46952
  PyObject *resultobj = 0;
 
46953
  wxDirPickerCtrl *arg1 = (wxDirPickerCtrl *) 0 ;
 
46954
  wxString *arg2 = 0 ;
 
46955
  void *argp1 = 0 ;
 
46956
  int res1 = 0 ;
 
46957
  bool temp2 = false ;
 
46958
  PyObject * obj0 = 0 ;
 
46959
  PyObject * obj1 = 0 ;
 
46960
  char *  kwnames[] = {
 
46961
    (char *) "self",(char *) "str", NULL 
 
46962
  };
 
46963
  
 
46964
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirPickerCtrl_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
 
46965
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDirPickerCtrl, 0 |  0 );
 
46966
  if (!SWIG_IsOK(res1)) {
 
46967
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirPickerCtrl_SetPath" "', expected argument " "1"" of type '" "wxDirPickerCtrl *""'"); 
 
46968
  }
 
46969
  arg1 = reinterpret_cast< wxDirPickerCtrl * >(argp1);
 
46970
  {
 
46971
    arg2 = wxString_in_helper(obj1);
 
46972
    if (arg2 == NULL) SWIG_fail;
 
46973
    temp2 = true;
 
46974
  }
 
46975
  {
 
46976
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
46977
    (arg1)->SetPath((wxString const &)*arg2);
 
46978
    wxPyEndAllowThreads(__tstate);
 
46979
    if (PyErr_Occurred()) SWIG_fail;
 
46980
  }
 
46981
  resultobj = SWIG_Py_Void();
 
46982
  {
 
46983
    if (temp2)
 
46984
    delete arg2;
 
46985
  }
 
46986
  return resultobj;
 
46987
fail:
 
46988
  {
 
46989
    if (temp2)
 
46990
    delete arg2;
 
46991
  }
 
46992
  return NULL;
 
46993
}
 
46994
 
 
46995
 
 
46996
SWIGINTERN PyObject *_wrap_DirPickerCtrl_CheckPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
46997
  PyObject *resultobj = 0;
 
46998
  wxDirPickerCtrl *arg1 = (wxDirPickerCtrl *) 0 ;
 
46999
  wxString *arg2 = 0 ;
 
47000
  bool result;
 
47001
  void *argp1 = 0 ;
 
47002
  int res1 = 0 ;
 
47003
  bool temp2 = false ;
 
47004
  PyObject * obj0 = 0 ;
 
47005
  PyObject * obj1 = 0 ;
 
47006
  char *  kwnames[] = {
 
47007
    (char *) "self",(char *) "path", NULL 
 
47008
  };
 
47009
  
 
47010
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DirPickerCtrl_CheckPath",kwnames,&obj0,&obj1)) SWIG_fail;
 
47011
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDirPickerCtrl, 0 |  0 );
 
47012
  if (!SWIG_IsOK(res1)) {
 
47013
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirPickerCtrl_CheckPath" "', expected argument " "1"" of type '" "wxDirPickerCtrl const *""'"); 
 
47014
  }
 
47015
  arg1 = reinterpret_cast< wxDirPickerCtrl * >(argp1);
 
47016
  {
 
47017
    arg2 = wxString_in_helper(obj1);
 
47018
    if (arg2 == NULL) SWIG_fail;
 
47019
    temp2 = true;
 
47020
  }
 
47021
  {
 
47022
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47023
    result = (bool)((wxDirPickerCtrl const *)arg1)->CheckPath((wxString const &)*arg2);
 
47024
    wxPyEndAllowThreads(__tstate);
 
47025
    if (PyErr_Occurred()) SWIG_fail;
 
47026
  }
 
47027
  {
 
47028
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
47029
  }
 
47030
  {
 
47031
    if (temp2)
 
47032
    delete arg2;
 
47033
  }
 
47034
  return resultobj;
 
47035
fail:
 
47036
  {
 
47037
    if (temp2)
 
47038
    delete arg2;
 
47039
  }
 
47040
  return NULL;
 
47041
}
 
47042
 
 
47043
 
 
47044
SWIGINTERN PyObject *_wrap_DirPickerCtrl_GetTextCtrlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47045
  PyObject *resultobj = 0;
 
47046
  wxDirPickerCtrl *arg1 = (wxDirPickerCtrl *) 0 ;
 
47047
  wxString result;
 
47048
  void *argp1 = 0 ;
 
47049
  int res1 = 0 ;
 
47050
  PyObject *swig_obj[1] ;
 
47051
  
 
47052
  if (!args) SWIG_fail;
 
47053
  swig_obj[0] = args;
 
47054
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDirPickerCtrl, 0 |  0 );
 
47055
  if (!SWIG_IsOK(res1)) {
 
47056
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirPickerCtrl_GetTextCtrlValue" "', expected argument " "1"" of type '" "wxDirPickerCtrl const *""'"); 
 
47057
  }
 
47058
  arg1 = reinterpret_cast< wxDirPickerCtrl * >(argp1);
 
47059
  {
 
47060
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47061
    result = ((wxDirPickerCtrl const *)arg1)->GetTextCtrlValue();
 
47062
    wxPyEndAllowThreads(__tstate);
 
47063
    if (PyErr_Occurred()) SWIG_fail;
 
47064
  }
 
47065
  {
 
47066
#if wxUSE_UNICODE
 
47067
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
47068
#else
 
47069
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
47070
#endif
 
47071
  }
 
47072
  return resultobj;
 
47073
fail:
 
47074
  return NULL;
 
47075
}
 
47076
 
 
47077
 
 
47078
SWIGINTERN PyObject *DirPickerCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47079
  PyObject *obj;
 
47080
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
47081
  SWIG_TypeNewClientData(SWIGTYPE_p_wxDirPickerCtrl, SWIG_NewClientData(obj));
 
47082
  return SWIG_Py_Void();
 
47083
}
 
47084
 
 
47085
SWIGINTERN PyObject *DirPickerCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47086
  return SWIG_Python_InitShadowInstance(args);
 
47087
}
 
47088
 
 
47089
SWIGINTERN PyObject *_wrap_new_FileDirPickerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
47090
  PyObject *resultobj = 0;
 
47091
  wxEventType arg1 ;
 
47092
  wxObject *arg2 = (wxObject *) 0 ;
 
47093
  int arg3 ;
 
47094
  wxString *arg4 = 0 ;
 
47095
  wxFileDirPickerEvent *result = 0 ;
 
47096
  int val1 ;
 
47097
  int ecode1 = 0 ;
 
47098
  void *argp2 = 0 ;
 
47099
  int res2 = 0 ;
 
47100
  int val3 ;
 
47101
  int ecode3 = 0 ;
 
47102
  bool temp4 = false ;
 
47103
  PyObject * obj0 = 0 ;
 
47104
  PyObject * obj1 = 0 ;
 
47105
  PyObject * obj2 = 0 ;
 
47106
  PyObject * obj3 = 0 ;
 
47107
  char *  kwnames[] = {
 
47108
    (char *) "type",(char *) "generator",(char *) "id",(char *) "path", NULL 
 
47109
  };
 
47110
  
 
47111
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileDirPickerEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
 
47112
  ecode1 = SWIG_AsVal_int(obj0, &val1);
 
47113
  if (!SWIG_IsOK(ecode1)) {
 
47114
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileDirPickerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
 
47115
  } 
 
47116
  arg1 = static_cast< wxEventType >(val1);
 
47117
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 |  0 );
 
47118
  if (!SWIG_IsOK(res2)) {
 
47119
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FileDirPickerEvent" "', expected argument " "2"" of type '" "wxObject *""'"); 
 
47120
  }
 
47121
  arg2 = reinterpret_cast< wxObject * >(argp2);
 
47122
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
47123
  if (!SWIG_IsOK(ecode3)) {
 
47124
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FileDirPickerEvent" "', expected argument " "3"" of type '" "int""'");
 
47125
  } 
 
47126
  arg3 = static_cast< int >(val3);
 
47127
  {
 
47128
    arg4 = wxString_in_helper(obj3);
 
47129
    if (arg4 == NULL) SWIG_fail;
 
47130
    temp4 = true;
 
47131
  }
 
47132
  {
 
47133
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47134
    result = (wxFileDirPickerEvent *)new wxFileDirPickerEvent(arg1,arg2,arg3,(wxString const &)*arg4);
 
47135
    wxPyEndAllowThreads(__tstate);
 
47136
    if (PyErr_Occurred()) SWIG_fail;
 
47137
  }
 
47138
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDirPickerEvent, SWIG_POINTER_NEW |  0 );
 
47139
  {
 
47140
    if (temp4)
 
47141
    delete arg4;
 
47142
  }
 
47143
  return resultobj;
 
47144
fail:
 
47145
  {
 
47146
    if (temp4)
 
47147
    delete arg4;
 
47148
  }
 
47149
  return NULL;
 
47150
}
 
47151
 
 
47152
 
 
47153
SWIGINTERN PyObject *_wrap_FileDirPickerEvent_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47154
  PyObject *resultobj = 0;
 
47155
  wxFileDirPickerEvent *arg1 = (wxFileDirPickerEvent *) 0 ;
 
47156
  wxString result;
 
47157
  void *argp1 = 0 ;
 
47158
  int res1 = 0 ;
 
47159
  PyObject *swig_obj[1] ;
 
47160
  
 
47161
  if (!args) SWIG_fail;
 
47162
  swig_obj[0] = args;
 
47163
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDirPickerEvent, 0 |  0 );
 
47164
  if (!SWIG_IsOK(res1)) {
 
47165
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDirPickerEvent_GetPath" "', expected argument " "1"" of type '" "wxFileDirPickerEvent const *""'"); 
 
47166
  }
 
47167
  arg1 = reinterpret_cast< wxFileDirPickerEvent * >(argp1);
 
47168
  {
 
47169
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47170
    result = ((wxFileDirPickerEvent const *)arg1)->GetPath();
 
47171
    wxPyEndAllowThreads(__tstate);
 
47172
    if (PyErr_Occurred()) SWIG_fail;
 
47173
  }
 
47174
  {
 
47175
#if wxUSE_UNICODE
 
47176
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
47177
#else
 
47178
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
47179
#endif
 
47180
  }
 
47181
  return resultobj;
 
47182
fail:
 
47183
  return NULL;
 
47184
}
 
47185
 
 
47186
 
 
47187
SWIGINTERN PyObject *_wrap_FileDirPickerEvent_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
47188
  PyObject *resultobj = 0;
 
47189
  wxFileDirPickerEvent *arg1 = (wxFileDirPickerEvent *) 0 ;
 
47190
  wxString *arg2 = 0 ;
 
47191
  void *argp1 = 0 ;
 
47192
  int res1 = 0 ;
 
47193
  bool temp2 = false ;
 
47194
  PyObject * obj0 = 0 ;
 
47195
  PyObject * obj1 = 0 ;
 
47196
  char *  kwnames[] = {
 
47197
    (char *) "self",(char *) "p", NULL 
 
47198
  };
 
47199
  
 
47200
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDirPickerEvent_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
 
47201
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDirPickerEvent, 0 |  0 );
 
47202
  if (!SWIG_IsOK(res1)) {
 
47203
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDirPickerEvent_SetPath" "', expected argument " "1"" of type '" "wxFileDirPickerEvent *""'"); 
 
47204
  }
 
47205
  arg1 = reinterpret_cast< wxFileDirPickerEvent * >(argp1);
 
47206
  {
 
47207
    arg2 = wxString_in_helper(obj1);
 
47208
    if (arg2 == NULL) SWIG_fail;
 
47209
    temp2 = true;
 
47210
  }
 
47211
  {
 
47212
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47213
    (arg1)->SetPath((wxString const &)*arg2);
 
47214
    wxPyEndAllowThreads(__tstate);
 
47215
    if (PyErr_Occurred()) SWIG_fail;
 
47216
  }
 
47217
  resultobj = SWIG_Py_Void();
 
47218
  {
 
47219
    if (temp2)
 
47220
    delete arg2;
 
47221
  }
 
47222
  return resultobj;
 
47223
fail:
 
47224
  {
 
47225
    if (temp2)
 
47226
    delete arg2;
 
47227
  }
 
47228
  return NULL;
 
47229
}
 
47230
 
 
47231
 
 
47232
SWIGINTERN PyObject *FileDirPickerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47233
  PyObject *obj;
 
47234
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
47235
  SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDirPickerEvent, SWIG_NewClientData(obj));
 
47236
  return SWIG_Py_Void();
 
47237
}
 
47238
 
 
47239
SWIGINTERN PyObject *FileDirPickerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47240
  return SWIG_Python_InitShadowInstance(args);
 
47241
}
 
47242
 
 
47243
SWIGINTERN int FontPickerCtrlNameStr_set(PyObject *) {
 
47244
  SWIG_Error(SWIG_AttributeError,"Variable FontPickerCtrlNameStr is read-only.");
 
47245
  return 1;
 
47246
}
 
47247
 
 
47248
 
 
47249
SWIGINTERN PyObject *FontPickerCtrlNameStr_get(void) {
 
47250
  PyObject *pyobj = 0;
 
47251
  
 
47252
  {
 
47253
#if wxUSE_UNICODE
 
47254
    pyobj = PyUnicode_FromWideChar((&wxPyFontPickerCtrlNameStr)->c_str(), (&wxPyFontPickerCtrlNameStr)->Len());
 
47255
#else
 
47256
    pyobj = PyString_FromStringAndSize((&wxPyFontPickerCtrlNameStr)->c_str(), (&wxPyFontPickerCtrlNameStr)->Len());
 
47257
#endif
 
47258
  }
 
47259
  return pyobj;
 
47260
}
 
47261
 
 
47262
 
 
47263
SWIGINTERN PyObject *_wrap_new_FontPickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
47264
  PyObject *resultobj = 0;
 
47265
  wxWindow *arg1 = (wxWindow *) 0 ;
 
47266
  int arg2 = (int) -1 ;
 
47267
  wxFont const &arg3_defvalue = wxNullFont ;
 
47268
  wxFont *arg3 = (wxFont *) &arg3_defvalue ;
 
47269
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
47270
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
47271
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
47272
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
47273
  long arg6 = (long) wxFNTP_DEFAULT_STYLE ;
 
47274
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
47275
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
47276
  wxString const &arg8_defvalue = wxPyFontPickerCtrlNameStr ;
 
47277
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
47278
  wxFontPickerCtrl *result = 0 ;
 
47279
  void *argp1 = 0 ;
 
47280
  int res1 = 0 ;
 
47281
  int val2 ;
 
47282
  int ecode2 = 0 ;
 
47283
  void *argp3 = 0 ;
 
47284
  int res3 = 0 ;
 
47285
  wxPoint temp4 ;
 
47286
  wxSize temp5 ;
 
47287
  long val6 ;
 
47288
  int ecode6 = 0 ;
 
47289
  void *argp7 = 0 ;
 
47290
  int res7 = 0 ;
 
47291
  bool temp8 = false ;
 
47292
  PyObject * obj0 = 0 ;
 
47293
  PyObject * obj1 = 0 ;
 
47294
  PyObject * obj2 = 0 ;
 
47295
  PyObject * obj3 = 0 ;
 
47296
  PyObject * obj4 = 0 ;
 
47297
  PyObject * obj5 = 0 ;
 
47298
  PyObject * obj6 = 0 ;
 
47299
  PyObject * obj7 = 0 ;
 
47300
  char *  kwnames[] = {
 
47301
    (char *) "parent",(char *) "id",(char *) "initial",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
47302
  };
 
47303
  
 
47304
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_FontPickerCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
47305
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
47306
  if (!SWIG_IsOK(res1)) {
 
47307
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FontPickerCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
47308
  }
 
47309
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
47310
  if (obj1) {
 
47311
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
47312
    if (!SWIG_IsOK(ecode2)) {
 
47313
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FontPickerCtrl" "', expected argument " "2"" of type '" "int""'");
 
47314
    } 
 
47315
    arg2 = static_cast< int >(val2);
 
47316
  }
 
47317
  if (obj2) {
 
47318
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxFont,  0  | 0);
 
47319
    if (!SWIG_IsOK(res3)) {
 
47320
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FontPickerCtrl" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
47321
    }
 
47322
    if (!argp3) {
 
47323
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FontPickerCtrl" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
47324
    }
 
47325
    arg3 = reinterpret_cast< wxFont * >(argp3);
 
47326
  }
 
47327
  if (obj3) {
 
47328
    {
 
47329
      arg4 = &temp4;
 
47330
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
47331
    }
 
47332
  }
 
47333
  if (obj4) {
 
47334
    {
 
47335
      arg5 = &temp5;
 
47336
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
47337
    }
 
47338
  }
 
47339
  if (obj5) {
 
47340
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
47341
    if (!SWIG_IsOK(ecode6)) {
 
47342
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FontPickerCtrl" "', expected argument " "6"" of type '" "long""'");
 
47343
    } 
 
47344
    arg6 = static_cast< long >(val6);
 
47345
  }
 
47346
  if (obj6) {
 
47347
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
47348
    if (!SWIG_IsOK(res7)) {
 
47349
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FontPickerCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
47350
    }
 
47351
    if (!argp7) {
 
47352
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FontPickerCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
47353
    }
 
47354
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
47355
  }
 
47356
  if (obj7) {
 
47357
    {
 
47358
      arg8 = wxString_in_helper(obj7);
 
47359
      if (arg8 == NULL) SWIG_fail;
 
47360
      temp8 = true;
 
47361
    }
 
47362
  }
 
47363
  {
 
47364
    if (!wxPyCheckForApp()) SWIG_fail;
 
47365
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47366
    result = (wxFontPickerCtrl *)new wxFontPickerCtrl(arg1,arg2,(wxFont const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
47367
    wxPyEndAllowThreads(__tstate);
 
47368
    if (PyErr_Occurred()) SWIG_fail;
 
47369
  }
 
47370
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontPickerCtrl, SWIG_POINTER_NEW |  0 );
 
47371
  {
 
47372
    if (temp8)
 
47373
    delete arg8;
 
47374
  }
 
47375
  return resultobj;
 
47376
fail:
 
47377
  {
 
47378
    if (temp8)
 
47379
    delete arg8;
 
47380
  }
 
47381
  return NULL;
 
47382
}
 
47383
 
 
47384
 
 
47385
SWIGINTERN PyObject *_wrap_new_PreFontPickerCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47386
  PyObject *resultobj = 0;
 
47387
  wxFontPickerCtrl *result = 0 ;
 
47388
  
 
47389
  if (!SWIG_Python_UnpackTuple(args,"new_PreFontPickerCtrl",0,0,0)) SWIG_fail;
 
47390
  {
 
47391
    if (!wxPyCheckForApp()) SWIG_fail;
 
47392
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47393
    result = (wxFontPickerCtrl *)new wxFontPickerCtrl();
 
47394
    wxPyEndAllowThreads(__tstate);
 
47395
    if (PyErr_Occurred()) SWIG_fail;
 
47396
  }
 
47397
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontPickerCtrl, SWIG_POINTER_OWN |  0 );
 
47398
  return resultobj;
 
47399
fail:
 
47400
  return NULL;
 
47401
}
 
47402
 
 
47403
 
 
47404
SWIGINTERN PyObject *_wrap_FontPickerCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
47405
  PyObject *resultobj = 0;
 
47406
  wxFontPickerCtrl *arg1 = (wxFontPickerCtrl *) 0 ;
 
47407
  wxWindow *arg2 = (wxWindow *) 0 ;
 
47408
  int arg3 = (int) -1 ;
 
47409
  wxFont const &arg4_defvalue = wxNullFont ;
 
47410
  wxFont *arg4 = (wxFont *) &arg4_defvalue ;
 
47411
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
47412
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
47413
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
47414
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
47415
  long arg7 = (long) wxFNTP_DEFAULT_STYLE ;
 
47416
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
47417
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
47418
  wxString const &arg9_defvalue = wxPyFontPickerCtrlNameStr ;
 
47419
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
47420
  bool result;
 
47421
  void *argp1 = 0 ;
 
47422
  int res1 = 0 ;
 
47423
  void *argp2 = 0 ;
 
47424
  int res2 = 0 ;
 
47425
  int val3 ;
 
47426
  int ecode3 = 0 ;
 
47427
  void *argp4 = 0 ;
 
47428
  int res4 = 0 ;
 
47429
  wxPoint temp5 ;
 
47430
  wxSize temp6 ;
 
47431
  long val7 ;
 
47432
  int ecode7 = 0 ;
 
47433
  void *argp8 = 0 ;
 
47434
  int res8 = 0 ;
 
47435
  bool temp9 = false ;
 
47436
  PyObject * obj0 = 0 ;
 
47437
  PyObject * obj1 = 0 ;
 
47438
  PyObject * obj2 = 0 ;
 
47439
  PyObject * obj3 = 0 ;
 
47440
  PyObject * obj4 = 0 ;
 
47441
  PyObject * obj5 = 0 ;
 
47442
  PyObject * obj6 = 0 ;
 
47443
  PyObject * obj7 = 0 ;
 
47444
  PyObject * obj8 = 0 ;
 
47445
  char *  kwnames[] = {
 
47446
    (char *) "self",(char *) "parent",(char *) "id",(char *) "initial",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
47447
  };
 
47448
  
 
47449
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:FontPickerCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
47450
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontPickerCtrl, 0 |  0 );
 
47451
  if (!SWIG_IsOK(res1)) {
 
47452
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontPickerCtrl_Create" "', expected argument " "1"" of type '" "wxFontPickerCtrl *""'"); 
 
47453
  }
 
47454
  arg1 = reinterpret_cast< wxFontPickerCtrl * >(argp1);
 
47455
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
47456
  if (!SWIG_IsOK(res2)) {
 
47457
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontPickerCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
47458
  }
 
47459
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
47460
  if (obj2) {
 
47461
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
47462
    if (!SWIG_IsOK(ecode3)) {
 
47463
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontPickerCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
47464
    } 
 
47465
    arg3 = static_cast< int >(val3);
 
47466
  }
 
47467
  if (obj3) {
 
47468
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont,  0  | 0);
 
47469
    if (!SWIG_IsOK(res4)) {
 
47470
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FontPickerCtrl_Create" "', expected argument " "4"" of type '" "wxFont const &""'"); 
 
47471
    }
 
47472
    if (!argp4) {
 
47473
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FontPickerCtrl_Create" "', expected argument " "4"" of type '" "wxFont const &""'"); 
 
47474
    }
 
47475
    arg4 = reinterpret_cast< wxFont * >(argp4);
 
47476
  }
 
47477
  if (obj4) {
 
47478
    {
 
47479
      arg5 = &temp5;
 
47480
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
47481
    }
 
47482
  }
 
47483
  if (obj5) {
 
47484
    {
 
47485
      arg6 = &temp6;
 
47486
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
47487
    }
 
47488
  }
 
47489
  if (obj6) {
 
47490
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
47491
    if (!SWIG_IsOK(ecode7)) {
 
47492
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "FontPickerCtrl_Create" "', expected argument " "7"" of type '" "long""'");
 
47493
    } 
 
47494
    arg7 = static_cast< long >(val7);
 
47495
  }
 
47496
  if (obj7) {
 
47497
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
47498
    if (!SWIG_IsOK(res8)) {
 
47499
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "FontPickerCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
47500
    }
 
47501
    if (!argp8) {
 
47502
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FontPickerCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
47503
    }
 
47504
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
47505
  }
 
47506
  if (obj8) {
 
47507
    {
 
47508
      arg9 = wxString_in_helper(obj8);
 
47509
      if (arg9 == NULL) SWIG_fail;
 
47510
      temp9 = true;
 
47511
    }
 
47512
  }
 
47513
  {
 
47514
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47515
    result = (bool)(arg1)->Create(arg2,arg3,(wxFont const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
47516
    wxPyEndAllowThreads(__tstate);
 
47517
    if (PyErr_Occurred()) SWIG_fail;
 
47518
  }
 
47519
  {
 
47520
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
47521
  }
 
47522
  {
 
47523
    if (temp9)
 
47524
    delete arg9;
 
47525
  }
 
47526
  return resultobj;
 
47527
fail:
 
47528
  {
 
47529
    if (temp9)
 
47530
    delete arg9;
 
47531
  }
 
47532
  return NULL;
 
47533
}
 
47534
 
 
47535
 
 
47536
SWIGINTERN PyObject *_wrap_FontPickerCtrl_GetSelectedFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47537
  PyObject *resultobj = 0;
 
47538
  wxFontPickerCtrl *arg1 = (wxFontPickerCtrl *) 0 ;
 
47539
  wxFont result;
 
47540
  void *argp1 = 0 ;
 
47541
  int res1 = 0 ;
 
47542
  PyObject *swig_obj[1] ;
 
47543
  
 
47544
  if (!args) SWIG_fail;
 
47545
  swig_obj[0] = args;
 
47546
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFontPickerCtrl, 0 |  0 );
 
47547
  if (!SWIG_IsOK(res1)) {
 
47548
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontPickerCtrl_GetSelectedFont" "', expected argument " "1"" of type '" "wxFontPickerCtrl const *""'"); 
 
47549
  }
 
47550
  arg1 = reinterpret_cast< wxFontPickerCtrl * >(argp1);
 
47551
  {
 
47552
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47553
    result = ((wxFontPickerCtrl const *)arg1)->GetSelectedFont();
 
47554
    wxPyEndAllowThreads(__tstate);
 
47555
    if (PyErr_Occurred()) SWIG_fail;
 
47556
  }
 
47557
  resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN |  0 );
 
47558
  return resultobj;
 
47559
fail:
 
47560
  return NULL;
 
47561
}
 
47562
 
 
47563
 
 
47564
SWIGINTERN PyObject *_wrap_FontPickerCtrl_SetSelectedFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
47565
  PyObject *resultobj = 0;
 
47566
  wxFontPickerCtrl *arg1 = (wxFontPickerCtrl *) 0 ;
 
47567
  wxFont *arg2 = 0 ;
 
47568
  void *argp1 = 0 ;
 
47569
  int res1 = 0 ;
 
47570
  void *argp2 = 0 ;
 
47571
  int res2 = 0 ;
 
47572
  PyObject * obj0 = 0 ;
 
47573
  PyObject * obj1 = 0 ;
 
47574
  char *  kwnames[] = {
 
47575
    (char *) "self",(char *) "f", NULL 
 
47576
  };
 
47577
  
 
47578
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontPickerCtrl_SetSelectedFont",kwnames,&obj0,&obj1)) SWIG_fail;
 
47579
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontPickerCtrl, 0 |  0 );
 
47580
  if (!SWIG_IsOK(res1)) {
 
47581
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontPickerCtrl_SetSelectedFont" "', expected argument " "1"" of type '" "wxFontPickerCtrl *""'"); 
 
47582
  }
 
47583
  arg1 = reinterpret_cast< wxFontPickerCtrl * >(argp1);
 
47584
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont,  0  | 0);
 
47585
  if (!SWIG_IsOK(res2)) {
 
47586
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontPickerCtrl_SetSelectedFont" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
47587
  }
 
47588
  if (!argp2) {
 
47589
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FontPickerCtrl_SetSelectedFont" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
47590
  }
 
47591
  arg2 = reinterpret_cast< wxFont * >(argp2);
 
47592
  {
 
47593
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47594
    (arg1)->SetSelectedFont((wxFont const &)*arg2);
 
47595
    wxPyEndAllowThreads(__tstate);
 
47596
    if (PyErr_Occurred()) SWIG_fail;
 
47597
  }
 
47598
  resultobj = SWIG_Py_Void();
 
47599
  return resultobj;
 
47600
fail:
 
47601
  return NULL;
 
47602
}
 
47603
 
 
47604
 
 
47605
SWIGINTERN PyObject *_wrap_FontPickerCtrl_SetMaxPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
47606
  PyObject *resultobj = 0;
 
47607
  wxFontPickerCtrl *arg1 = (wxFontPickerCtrl *) 0 ;
 
47608
  unsigned int arg2 ;
 
47609
  void *argp1 = 0 ;
 
47610
  int res1 = 0 ;
 
47611
  unsigned int val2 ;
 
47612
  int ecode2 = 0 ;
 
47613
  PyObject * obj0 = 0 ;
 
47614
  PyObject * obj1 = 0 ;
 
47615
  char *  kwnames[] = {
 
47616
    (char *) "self",(char *) "max", NULL 
 
47617
  };
 
47618
  
 
47619
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontPickerCtrl_SetMaxPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
 
47620
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontPickerCtrl, 0 |  0 );
 
47621
  if (!SWIG_IsOK(res1)) {
 
47622
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontPickerCtrl_SetMaxPointSize" "', expected argument " "1"" of type '" "wxFontPickerCtrl *""'"); 
 
47623
  }
 
47624
  arg1 = reinterpret_cast< wxFontPickerCtrl * >(argp1);
 
47625
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
 
47626
  if (!SWIG_IsOK(ecode2)) {
 
47627
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontPickerCtrl_SetMaxPointSize" "', expected argument " "2"" of type '" "unsigned int""'");
 
47628
  } 
 
47629
  arg2 = static_cast< unsigned int >(val2);
 
47630
  {
 
47631
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47632
    (arg1)->SetMaxPointSize(arg2);
 
47633
    wxPyEndAllowThreads(__tstate);
 
47634
    if (PyErr_Occurred()) SWIG_fail;
 
47635
  }
 
47636
  resultobj = SWIG_Py_Void();
 
47637
  return resultobj;
 
47638
fail:
 
47639
  return NULL;
 
47640
}
 
47641
 
 
47642
 
 
47643
SWIGINTERN PyObject *_wrap_FontPickerCtrl_GetMaxPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47644
  PyObject *resultobj = 0;
 
47645
  wxFontPickerCtrl *arg1 = (wxFontPickerCtrl *) 0 ;
 
47646
  unsigned int result;
 
47647
  void *argp1 = 0 ;
 
47648
  int res1 = 0 ;
 
47649
  PyObject *swig_obj[1] ;
 
47650
  
 
47651
  if (!args) SWIG_fail;
 
47652
  swig_obj[0] = args;
 
47653
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFontPickerCtrl, 0 |  0 );
 
47654
  if (!SWIG_IsOK(res1)) {
 
47655
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontPickerCtrl_GetMaxPointSize" "', expected argument " "1"" of type '" "wxFontPickerCtrl const *""'"); 
 
47656
  }
 
47657
  arg1 = reinterpret_cast< wxFontPickerCtrl * >(argp1);
 
47658
  {
 
47659
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47660
    result = (unsigned int)((wxFontPickerCtrl const *)arg1)->GetMaxPointSize();
 
47661
    wxPyEndAllowThreads(__tstate);
 
47662
    if (PyErr_Occurred()) SWIG_fail;
 
47663
  }
 
47664
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
 
47665
  return resultobj;
 
47666
fail:
 
47667
  return NULL;
 
47668
}
 
47669
 
 
47670
 
 
47671
SWIGINTERN PyObject *FontPickerCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47672
  PyObject *obj;
 
47673
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
47674
  SWIG_TypeNewClientData(SWIGTYPE_p_wxFontPickerCtrl, SWIG_NewClientData(obj));
 
47675
  return SWIG_Py_Void();
 
47676
}
 
47677
 
 
47678
SWIGINTERN PyObject *FontPickerCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47679
  return SWIG_Python_InitShadowInstance(args);
 
47680
}
 
47681
 
 
47682
SWIGINTERN PyObject *_wrap_new_FontPickerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
47683
  PyObject *resultobj = 0;
 
47684
  wxObject *arg1 = (wxObject *) 0 ;
 
47685
  int arg2 ;
 
47686
  wxFont *arg3 = 0 ;
 
47687
  wxFontPickerEvent *result = 0 ;
 
47688
  void *argp1 = 0 ;
 
47689
  int res1 = 0 ;
 
47690
  int val2 ;
 
47691
  int ecode2 = 0 ;
 
47692
  void *argp3 = 0 ;
 
47693
  int res3 = 0 ;
 
47694
  PyObject * obj0 = 0 ;
 
47695
  PyObject * obj1 = 0 ;
 
47696
  PyObject * obj2 = 0 ;
 
47697
  char *  kwnames[] = {
 
47698
    (char *) "generator",(char *) "id",(char *) "f", NULL 
 
47699
  };
 
47700
  
 
47701
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_FontPickerEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
47702
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 |  0 );
 
47703
  if (!SWIG_IsOK(res1)) {
 
47704
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FontPickerEvent" "', expected argument " "1"" of type '" "wxObject *""'"); 
 
47705
  }
 
47706
  arg1 = reinterpret_cast< wxObject * >(argp1);
 
47707
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
47708
  if (!SWIG_IsOK(ecode2)) {
 
47709
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FontPickerEvent" "', expected argument " "2"" of type '" "int""'");
 
47710
  } 
 
47711
  arg2 = static_cast< int >(val2);
 
47712
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxFont,  0  | 0);
 
47713
  if (!SWIG_IsOK(res3)) {
 
47714
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FontPickerEvent" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
47715
  }
 
47716
  if (!argp3) {
 
47717
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FontPickerEvent" "', expected argument " "3"" of type '" "wxFont const &""'"); 
 
47718
  }
 
47719
  arg3 = reinterpret_cast< wxFont * >(argp3);
 
47720
  {
 
47721
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47722
    result = (wxFontPickerEvent *)new wxFontPickerEvent(arg1,arg2,(wxFont const &)*arg3);
 
47723
    wxPyEndAllowThreads(__tstate);
 
47724
    if (PyErr_Occurred()) SWIG_fail;
 
47725
  }
 
47726
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontPickerEvent, SWIG_POINTER_NEW |  0 );
 
47727
  return resultobj;
 
47728
fail:
 
47729
  return NULL;
 
47730
}
 
47731
 
 
47732
 
 
47733
SWIGINTERN PyObject *_wrap_FontPickerEvent_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47734
  PyObject *resultobj = 0;
 
47735
  wxFontPickerEvent *arg1 = (wxFontPickerEvent *) 0 ;
 
47736
  wxFont result;
 
47737
  void *argp1 = 0 ;
 
47738
  int res1 = 0 ;
 
47739
  PyObject *swig_obj[1] ;
 
47740
  
 
47741
  if (!args) SWIG_fail;
 
47742
  swig_obj[0] = args;
 
47743
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFontPickerEvent, 0 |  0 );
 
47744
  if (!SWIG_IsOK(res1)) {
 
47745
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontPickerEvent_GetFont" "', expected argument " "1"" of type '" "wxFontPickerEvent const *""'"); 
 
47746
  }
 
47747
  arg1 = reinterpret_cast< wxFontPickerEvent * >(argp1);
 
47748
  {
 
47749
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47750
    result = ((wxFontPickerEvent const *)arg1)->GetFont();
 
47751
    wxPyEndAllowThreads(__tstate);
 
47752
    if (PyErr_Occurred()) SWIG_fail;
 
47753
  }
 
47754
  resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN |  0 );
 
47755
  return resultobj;
 
47756
fail:
 
47757
  return NULL;
 
47758
}
 
47759
 
 
47760
 
 
47761
SWIGINTERN PyObject *_wrap_FontPickerEvent_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
47762
  PyObject *resultobj = 0;
 
47763
  wxFontPickerEvent *arg1 = (wxFontPickerEvent *) 0 ;
 
47764
  wxFont *arg2 = 0 ;
 
47765
  void *argp1 = 0 ;
 
47766
  int res1 = 0 ;
 
47767
  void *argp2 = 0 ;
 
47768
  int res2 = 0 ;
 
47769
  PyObject * obj0 = 0 ;
 
47770
  PyObject * obj1 = 0 ;
 
47771
  char *  kwnames[] = {
 
47772
    (char *) "self",(char *) "c", NULL 
 
47773
  };
 
47774
  
 
47775
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontPickerEvent_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
 
47776
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontPickerEvent, 0 |  0 );
 
47777
  if (!SWIG_IsOK(res1)) {
 
47778
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontPickerEvent_SetFont" "', expected argument " "1"" of type '" "wxFontPickerEvent *""'"); 
 
47779
  }
 
47780
  arg1 = reinterpret_cast< wxFontPickerEvent * >(argp1);
 
47781
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont,  0  | 0);
 
47782
  if (!SWIG_IsOK(res2)) {
 
47783
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontPickerEvent_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
47784
  }
 
47785
  if (!argp2) {
 
47786
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FontPickerEvent_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'"); 
 
47787
  }
 
47788
  arg2 = reinterpret_cast< wxFont * >(argp2);
 
47789
  {
 
47790
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47791
    (arg1)->SetFont((wxFont const &)*arg2);
 
47792
    wxPyEndAllowThreads(__tstate);
 
47793
    if (PyErr_Occurred()) SWIG_fail;
 
47794
  }
 
47795
  resultobj = SWIG_Py_Void();
 
47796
  return resultobj;
 
47797
fail:
 
47798
  return NULL;
 
47799
}
 
47800
 
 
47801
 
 
47802
SWIGINTERN PyObject *FontPickerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47803
  PyObject *obj;
 
47804
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
47805
  SWIG_TypeNewClientData(SWIGTYPE_p_wxFontPickerEvent, SWIG_NewClientData(obj));
 
47806
  return SWIG_Py_Void();
 
47807
}
 
47808
 
 
47809
SWIGINTERN PyObject *FontPickerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47810
  return SWIG_Python_InitShadowInstance(args);
 
47811
}
 
47812
 
 
47813
SWIGINTERN int CollapsiblePaneNameStr_set(PyObject *) {
 
47814
  SWIG_Error(SWIG_AttributeError,"Variable CollapsiblePaneNameStr is read-only.");
 
47815
  return 1;
 
47816
}
 
47817
 
 
47818
 
 
47819
SWIGINTERN PyObject *CollapsiblePaneNameStr_get(void) {
 
47820
  PyObject *pyobj = 0;
 
47821
  
 
47822
  {
 
47823
#if wxUSE_UNICODE
 
47824
    pyobj = PyUnicode_FromWideChar((&wxPyCollapsiblePaneNameStr)->c_str(), (&wxPyCollapsiblePaneNameStr)->Len());
 
47825
#else
 
47826
    pyobj = PyString_FromStringAndSize((&wxPyCollapsiblePaneNameStr)->c_str(), (&wxPyCollapsiblePaneNameStr)->Len());
 
47827
#endif
 
47828
  }
 
47829
  return pyobj;
 
47830
}
 
47831
 
 
47832
 
 
47833
SWIGINTERN PyObject *_wrap_new_CollapsiblePane(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
47834
  PyObject *resultobj = 0;
 
47835
  wxWindow *arg1 = (wxWindow *) 0 ;
 
47836
  int arg2 = (int) -1 ;
 
47837
  wxString const &arg3_defvalue = wxPyEmptyString ;
 
47838
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
47839
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
47840
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
47841
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
47842
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
47843
  long arg6 = (long) wxCP_DEFAULT_STYLE ;
 
47844
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
47845
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
47846
  wxString const &arg8_defvalue = wxPyCollapsiblePaneNameStr ;
 
47847
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
47848
  wxCollapsiblePane *result = 0 ;
 
47849
  void *argp1 = 0 ;
 
47850
  int res1 = 0 ;
 
47851
  int val2 ;
 
47852
  int ecode2 = 0 ;
 
47853
  bool temp3 = false ;
 
47854
  wxPoint temp4 ;
 
47855
  wxSize temp5 ;
 
47856
  long val6 ;
 
47857
  int ecode6 = 0 ;
 
47858
  void *argp7 = 0 ;
 
47859
  int res7 = 0 ;
 
47860
  bool temp8 = false ;
 
47861
  PyObject * obj0 = 0 ;
 
47862
  PyObject * obj1 = 0 ;
 
47863
  PyObject * obj2 = 0 ;
 
47864
  PyObject * obj3 = 0 ;
 
47865
  PyObject * obj4 = 0 ;
 
47866
  PyObject * obj5 = 0 ;
 
47867
  PyObject * obj6 = 0 ;
 
47868
  PyObject * obj7 = 0 ;
 
47869
  char *  kwnames[] = {
 
47870
    (char *) "parent",(char *) "winid",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "val",(char *) "name", NULL 
 
47871
  };
 
47872
  
 
47873
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_CollapsiblePane",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
47874
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
47875
  if (!SWIG_IsOK(res1)) {
 
47876
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollapsiblePane" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
47877
  }
 
47878
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
47879
  if (obj1) {
 
47880
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
47881
    if (!SWIG_IsOK(ecode2)) {
 
47882
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CollapsiblePane" "', expected argument " "2"" of type '" "int""'");
 
47883
    } 
 
47884
    arg2 = static_cast< int >(val2);
 
47885
  }
 
47886
  if (obj2) {
 
47887
    {
 
47888
      arg3 = wxString_in_helper(obj2);
 
47889
      if (arg3 == NULL) SWIG_fail;
 
47890
      temp3 = true;
 
47891
    }
 
47892
  }
 
47893
  if (obj3) {
 
47894
    {
 
47895
      arg4 = &temp4;
 
47896
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
47897
    }
 
47898
  }
 
47899
  if (obj4) {
 
47900
    {
 
47901
      arg5 = &temp5;
 
47902
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
47903
    }
 
47904
  }
 
47905
  if (obj5) {
 
47906
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
47907
    if (!SWIG_IsOK(ecode6)) {
 
47908
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CollapsiblePane" "', expected argument " "6"" of type '" "long""'");
 
47909
    } 
 
47910
    arg6 = static_cast< long >(val6);
 
47911
  }
 
47912
  if (obj6) {
 
47913
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
47914
    if (!SWIG_IsOK(res7)) {
 
47915
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CollapsiblePane" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
47916
    }
 
47917
    if (!argp7) {
 
47918
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollapsiblePane" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
47919
    }
 
47920
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
47921
  }
 
47922
  if (obj7) {
 
47923
    {
 
47924
      arg8 = wxString_in_helper(obj7);
 
47925
      if (arg8 == NULL) SWIG_fail;
 
47926
      temp8 = true;
 
47927
    }
 
47928
  }
 
47929
  {
 
47930
    if (!wxPyCheckForApp()) SWIG_fail;
 
47931
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47932
    result = (wxCollapsiblePane *)new wxCollapsiblePane(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
47933
    wxPyEndAllowThreads(__tstate);
 
47934
    if (PyErr_Occurred()) SWIG_fail;
 
47935
  }
 
47936
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCollapsiblePane, SWIG_POINTER_NEW |  0 );
 
47937
  {
 
47938
    if (temp3)
 
47939
    delete arg3;
 
47940
  }
 
47941
  {
 
47942
    if (temp8)
 
47943
    delete arg8;
 
47944
  }
 
47945
  return resultobj;
 
47946
fail:
 
47947
  {
 
47948
    if (temp3)
 
47949
    delete arg3;
 
47950
  }
 
47951
  {
 
47952
    if (temp8)
 
47953
    delete arg8;
 
47954
  }
 
47955
  return NULL;
 
47956
}
 
47957
 
 
47958
 
 
47959
SWIGINTERN PyObject *_wrap_new_PreCollapsiblePane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
47960
  PyObject *resultobj = 0;
 
47961
  wxCollapsiblePane *result = 0 ;
 
47962
  
 
47963
  if (!SWIG_Python_UnpackTuple(args,"new_PreCollapsiblePane",0,0,0)) SWIG_fail;
 
47964
  {
 
47965
    if (!wxPyCheckForApp()) SWIG_fail;
 
47966
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
47967
    result = (wxCollapsiblePane *)new wxCollapsiblePane();
 
47968
    wxPyEndAllowThreads(__tstate);
 
47969
    if (PyErr_Occurred()) SWIG_fail;
 
47970
  }
 
47971
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCollapsiblePane, SWIG_POINTER_OWN |  0 );
 
47972
  return resultobj;
 
47973
fail:
 
47974
  return NULL;
 
47975
}
 
47976
 
 
47977
 
 
47978
SWIGINTERN PyObject *_wrap_CollapsiblePane_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
47979
  PyObject *resultobj = 0;
 
47980
  wxCollapsiblePane *arg1 = (wxCollapsiblePane *) 0 ;
 
47981
  wxWindow *arg2 = (wxWindow *) 0 ;
 
47982
  int arg3 = (int) -1 ;
 
47983
  wxString const &arg4_defvalue = wxPyEmptyString ;
 
47984
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
47985
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
47986
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
47987
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
47988
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
47989
  long arg7 = (long) wxCP_DEFAULT_STYLE ;
 
47990
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
47991
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
47992
  wxString const &arg9_defvalue = wxPyCollapsiblePaneNameStr ;
 
47993
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
47994
  bool result;
 
47995
  void *argp1 = 0 ;
 
47996
  int res1 = 0 ;
 
47997
  void *argp2 = 0 ;
 
47998
  int res2 = 0 ;
 
47999
  int val3 ;
 
48000
  int ecode3 = 0 ;
 
48001
  bool temp4 = false ;
 
48002
  wxPoint temp5 ;
 
48003
  wxSize temp6 ;
 
48004
  long val7 ;
 
48005
  int ecode7 = 0 ;
 
48006
  void *argp8 = 0 ;
 
48007
  int res8 = 0 ;
 
48008
  bool temp9 = false ;
 
48009
  PyObject * obj0 = 0 ;
 
48010
  PyObject * obj1 = 0 ;
 
48011
  PyObject * obj2 = 0 ;
 
48012
  PyObject * obj3 = 0 ;
 
48013
  PyObject * obj4 = 0 ;
 
48014
  PyObject * obj5 = 0 ;
 
48015
  PyObject * obj6 = 0 ;
 
48016
  PyObject * obj7 = 0 ;
 
48017
  PyObject * obj8 = 0 ;
 
48018
  char *  kwnames[] = {
 
48019
    (char *) "self",(char *) "parent",(char *) "winid",(char *) "label",(char *) "pos",(char *) "size",(char *) "style",(char *) "val",(char *) "name", NULL 
 
48020
  };
 
48021
  
 
48022
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:CollapsiblePane_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
48023
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCollapsiblePane, 0 |  0 );
 
48024
  if (!SWIG_IsOK(res1)) {
 
48025
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CollapsiblePane_Create" "', expected argument " "1"" of type '" "wxCollapsiblePane *""'"); 
 
48026
  }
 
48027
  arg1 = reinterpret_cast< wxCollapsiblePane * >(argp1);
 
48028
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
48029
  if (!SWIG_IsOK(res2)) {
 
48030
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CollapsiblePane_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
48031
  }
 
48032
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
48033
  if (obj2) {
 
48034
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
48035
    if (!SWIG_IsOK(ecode3)) {
 
48036
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CollapsiblePane_Create" "', expected argument " "3"" of type '" "int""'");
 
48037
    } 
 
48038
    arg3 = static_cast< int >(val3);
 
48039
  }
 
48040
  if (obj3) {
 
48041
    {
 
48042
      arg4 = wxString_in_helper(obj3);
 
48043
      if (arg4 == NULL) SWIG_fail;
 
48044
      temp4 = true;
 
48045
    }
 
48046
  }
 
48047
  if (obj4) {
 
48048
    {
 
48049
      arg5 = &temp5;
 
48050
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
48051
    }
 
48052
  }
 
48053
  if (obj5) {
 
48054
    {
 
48055
      arg6 = &temp6;
 
48056
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
48057
    }
 
48058
  }
 
48059
  if (obj6) {
 
48060
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
48061
    if (!SWIG_IsOK(ecode7)) {
 
48062
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CollapsiblePane_Create" "', expected argument " "7"" of type '" "long""'");
 
48063
    } 
 
48064
    arg7 = static_cast< long >(val7);
 
48065
  }
 
48066
  if (obj7) {
 
48067
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
48068
    if (!SWIG_IsOK(res8)) {
 
48069
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CollapsiblePane_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
48070
    }
 
48071
    if (!argp8) {
 
48072
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CollapsiblePane_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
48073
    }
 
48074
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
48075
  }
 
48076
  if (obj8) {
 
48077
    {
 
48078
      arg9 = wxString_in_helper(obj8);
 
48079
      if (arg9 == NULL) SWIG_fail;
 
48080
      temp9 = true;
 
48081
    }
 
48082
  }
 
48083
  {
 
48084
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48085
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
48086
    wxPyEndAllowThreads(__tstate);
 
48087
    if (PyErr_Occurred()) SWIG_fail;
 
48088
  }
 
48089
  {
 
48090
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
48091
  }
 
48092
  {
 
48093
    if (temp4)
 
48094
    delete arg4;
 
48095
  }
 
48096
  {
 
48097
    if (temp9)
 
48098
    delete arg9;
 
48099
  }
 
48100
  return resultobj;
 
48101
fail:
 
48102
  {
 
48103
    if (temp4)
 
48104
    delete arg4;
 
48105
  }
 
48106
  {
 
48107
    if (temp9)
 
48108
    delete arg9;
 
48109
  }
 
48110
  return NULL;
 
48111
}
 
48112
 
 
48113
 
 
48114
SWIGINTERN PyObject *_wrap_CollapsiblePane_Collapse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
48115
  PyObject *resultobj = 0;
 
48116
  wxCollapsiblePane *arg1 = (wxCollapsiblePane *) 0 ;
 
48117
  bool arg2 = (bool) true ;
 
48118
  void *argp1 = 0 ;
 
48119
  int res1 = 0 ;
 
48120
  bool val2 ;
 
48121
  int ecode2 = 0 ;
 
48122
  PyObject * obj0 = 0 ;
 
48123
  PyObject * obj1 = 0 ;
 
48124
  char *  kwnames[] = {
 
48125
    (char *) "self",(char *) "collapse", NULL 
 
48126
  };
 
48127
  
 
48128
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CollapsiblePane_Collapse",kwnames,&obj0,&obj1)) SWIG_fail;
 
48129
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCollapsiblePane, 0 |  0 );
 
48130
  if (!SWIG_IsOK(res1)) {
 
48131
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CollapsiblePane_Collapse" "', expected argument " "1"" of type '" "wxCollapsiblePane *""'"); 
 
48132
  }
 
48133
  arg1 = reinterpret_cast< wxCollapsiblePane * >(argp1);
 
48134
  if (obj1) {
 
48135
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
48136
    if (!SWIG_IsOK(ecode2)) {
 
48137
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CollapsiblePane_Collapse" "', expected argument " "2"" of type '" "bool""'");
 
48138
    } 
 
48139
    arg2 = static_cast< bool >(val2);
 
48140
  }
 
48141
  {
 
48142
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48143
    (arg1)->Collapse(arg2);
 
48144
    wxPyEndAllowThreads(__tstate);
 
48145
    if (PyErr_Occurred()) SWIG_fail;
 
48146
  }
 
48147
  resultobj = SWIG_Py_Void();
 
48148
  return resultobj;
 
48149
fail:
 
48150
  return NULL;
 
48151
}
 
48152
 
 
48153
 
 
48154
SWIGINTERN PyObject *_wrap_CollapsiblePane_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48155
  PyObject *resultobj = 0;
 
48156
  wxCollapsiblePane *arg1 = (wxCollapsiblePane *) 0 ;
 
48157
  void *argp1 = 0 ;
 
48158
  int res1 = 0 ;
 
48159
  PyObject *swig_obj[1] ;
 
48160
  
 
48161
  if (!args) SWIG_fail;
 
48162
  swig_obj[0] = args;
 
48163
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCollapsiblePane, 0 |  0 );
 
48164
  if (!SWIG_IsOK(res1)) {
 
48165
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CollapsiblePane_Expand" "', expected argument " "1"" of type '" "wxCollapsiblePane *""'"); 
 
48166
  }
 
48167
  arg1 = reinterpret_cast< wxCollapsiblePane * >(argp1);
 
48168
  {
 
48169
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48170
    (arg1)->Expand();
 
48171
    wxPyEndAllowThreads(__tstate);
 
48172
    if (PyErr_Occurred()) SWIG_fail;
 
48173
  }
 
48174
  resultobj = SWIG_Py_Void();
 
48175
  return resultobj;
 
48176
fail:
 
48177
  return NULL;
 
48178
}
 
48179
 
 
48180
 
 
48181
SWIGINTERN PyObject *_wrap_CollapsiblePane_IsCollapsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48182
  PyObject *resultobj = 0;
 
48183
  wxCollapsiblePane *arg1 = (wxCollapsiblePane *) 0 ;
 
48184
  bool result;
 
48185
  void *argp1 = 0 ;
 
48186
  int res1 = 0 ;
 
48187
  PyObject *swig_obj[1] ;
 
48188
  
 
48189
  if (!args) SWIG_fail;
 
48190
  swig_obj[0] = args;
 
48191
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCollapsiblePane, 0 |  0 );
 
48192
  if (!SWIG_IsOK(res1)) {
 
48193
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CollapsiblePane_IsCollapsed" "', expected argument " "1"" of type '" "wxCollapsiblePane const *""'"); 
 
48194
  }
 
48195
  arg1 = reinterpret_cast< wxCollapsiblePane * >(argp1);
 
48196
  {
 
48197
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48198
    result = (bool)((wxCollapsiblePane const *)arg1)->IsCollapsed();
 
48199
    wxPyEndAllowThreads(__tstate);
 
48200
    if (PyErr_Occurred()) SWIG_fail;
 
48201
  }
 
48202
  {
 
48203
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
48204
  }
 
48205
  return resultobj;
 
48206
fail:
 
48207
  return NULL;
 
48208
}
 
48209
 
 
48210
 
 
48211
SWIGINTERN PyObject *_wrap_CollapsiblePane_IsExpanded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48212
  PyObject *resultobj = 0;
 
48213
  wxCollapsiblePane *arg1 = (wxCollapsiblePane *) 0 ;
 
48214
  bool result;
 
48215
  void *argp1 = 0 ;
 
48216
  int res1 = 0 ;
 
48217
  PyObject *swig_obj[1] ;
 
48218
  
 
48219
  if (!args) SWIG_fail;
 
48220
  swig_obj[0] = args;
 
48221
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCollapsiblePane, 0 |  0 );
 
48222
  if (!SWIG_IsOK(res1)) {
 
48223
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CollapsiblePane_IsExpanded" "', expected argument " "1"" of type '" "wxCollapsiblePane const *""'"); 
 
48224
  }
 
48225
  arg1 = reinterpret_cast< wxCollapsiblePane * >(argp1);
 
48226
  {
 
48227
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48228
    result = (bool)((wxCollapsiblePane const *)arg1)->IsExpanded();
 
48229
    wxPyEndAllowThreads(__tstate);
 
48230
    if (PyErr_Occurred()) SWIG_fail;
 
48231
  }
 
48232
  {
 
48233
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
48234
  }
 
48235
  return resultobj;
 
48236
fail:
 
48237
  return NULL;
 
48238
}
 
48239
 
 
48240
 
 
48241
SWIGINTERN PyObject *_wrap_CollapsiblePane_GetPane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48242
  PyObject *resultobj = 0;
 
48243
  wxCollapsiblePane *arg1 = (wxCollapsiblePane *) 0 ;
 
48244
  wxWindow *result = 0 ;
 
48245
  void *argp1 = 0 ;
 
48246
  int res1 = 0 ;
 
48247
  PyObject *swig_obj[1] ;
 
48248
  
 
48249
  if (!args) SWIG_fail;
 
48250
  swig_obj[0] = args;
 
48251
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCollapsiblePane, 0 |  0 );
 
48252
  if (!SWIG_IsOK(res1)) {
 
48253
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CollapsiblePane_GetPane" "', expected argument " "1"" of type '" "wxCollapsiblePane const *""'"); 
 
48254
  }
 
48255
  arg1 = reinterpret_cast< wxCollapsiblePane * >(argp1);
 
48256
  {
 
48257
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48258
    result = (wxWindow *)((wxCollapsiblePane const *)arg1)->GetPane();
 
48259
    wxPyEndAllowThreads(__tstate);
 
48260
    if (PyErr_Occurred()) SWIG_fail;
 
48261
  }
 
48262
  {
 
48263
    resultobj = wxPyMake_wxObject(result, 0); 
 
48264
  }
 
48265
  return resultobj;
 
48266
fail:
 
48267
  return NULL;
 
48268
}
 
48269
 
 
48270
 
 
48271
SWIGINTERN PyObject *CollapsiblePane_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48272
  PyObject *obj;
 
48273
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
48274
  SWIG_TypeNewClientData(SWIGTYPE_p_wxCollapsiblePane, SWIG_NewClientData(obj));
 
48275
  return SWIG_Py_Void();
 
48276
}
 
48277
 
 
48278
SWIGINTERN PyObject *CollapsiblePane_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48279
  return SWIG_Python_InitShadowInstance(args);
 
48280
}
 
48281
 
 
48282
SWIGINTERN PyObject *_wrap_new_CollapsiblePaneEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
48283
  PyObject *resultobj = 0;
 
48284
  wxObject *arg1 = (wxObject *) 0 ;
 
48285
  int arg2 ;
 
48286
  bool arg3 ;
 
48287
  wxCollapsiblePaneEvent *result = 0 ;
 
48288
  void *argp1 = 0 ;
 
48289
  int res1 = 0 ;
 
48290
  int val2 ;
 
48291
  int ecode2 = 0 ;
 
48292
  bool val3 ;
 
48293
  int ecode3 = 0 ;
 
48294
  PyObject * obj0 = 0 ;
 
48295
  PyObject * obj1 = 0 ;
 
48296
  PyObject * obj2 = 0 ;
 
48297
  char *  kwnames[] = {
 
48298
    (char *) "generator",(char *) "id",(char *) "collapsed", NULL 
 
48299
  };
 
48300
  
 
48301
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_CollapsiblePaneEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
48302
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 |  0 );
 
48303
  if (!SWIG_IsOK(res1)) {
 
48304
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollapsiblePaneEvent" "', expected argument " "1"" of type '" "wxObject *""'"); 
 
48305
  }
 
48306
  arg1 = reinterpret_cast< wxObject * >(argp1);
 
48307
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
48308
  if (!SWIG_IsOK(ecode2)) {
 
48309
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CollapsiblePaneEvent" "', expected argument " "2"" of type '" "int""'");
 
48310
  } 
 
48311
  arg2 = static_cast< int >(val2);
 
48312
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
 
48313
  if (!SWIG_IsOK(ecode3)) {
 
48314
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CollapsiblePaneEvent" "', expected argument " "3"" of type '" "bool""'");
 
48315
  } 
 
48316
  arg3 = static_cast< bool >(val3);
 
48317
  {
 
48318
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48319
    result = (wxCollapsiblePaneEvent *)new wxCollapsiblePaneEvent(arg1,arg2,arg3);
 
48320
    wxPyEndAllowThreads(__tstate);
 
48321
    if (PyErr_Occurred()) SWIG_fail;
 
48322
  }
 
48323
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCollapsiblePaneEvent, SWIG_POINTER_NEW |  0 );
 
48324
  return resultobj;
 
48325
fail:
 
48326
  return NULL;
 
48327
}
 
48328
 
 
48329
 
 
48330
SWIGINTERN PyObject *_wrap_CollapsiblePaneEvent_GetCollapsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48331
  PyObject *resultobj = 0;
 
48332
  wxCollapsiblePaneEvent *arg1 = (wxCollapsiblePaneEvent *) 0 ;
 
48333
  bool result;
 
48334
  void *argp1 = 0 ;
 
48335
  int res1 = 0 ;
 
48336
  PyObject *swig_obj[1] ;
 
48337
  
 
48338
  if (!args) SWIG_fail;
 
48339
  swig_obj[0] = args;
 
48340
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCollapsiblePaneEvent, 0 |  0 );
 
48341
  if (!SWIG_IsOK(res1)) {
 
48342
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CollapsiblePaneEvent_GetCollapsed" "', expected argument " "1"" of type '" "wxCollapsiblePaneEvent const *""'"); 
 
48343
  }
 
48344
  arg1 = reinterpret_cast< wxCollapsiblePaneEvent * >(argp1);
 
48345
  {
 
48346
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48347
    result = (bool)((wxCollapsiblePaneEvent const *)arg1)->GetCollapsed();
 
48348
    wxPyEndAllowThreads(__tstate);
 
48349
    if (PyErr_Occurred()) SWIG_fail;
 
48350
  }
 
48351
  {
 
48352
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
48353
  }
 
48354
  return resultobj;
 
48355
fail:
 
48356
  return NULL;
 
48357
}
 
48358
 
 
48359
 
 
48360
SWIGINTERN PyObject *_wrap_CollapsiblePaneEvent_SetCollapsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
48361
  PyObject *resultobj = 0;
 
48362
  wxCollapsiblePaneEvent *arg1 = (wxCollapsiblePaneEvent *) 0 ;
 
48363
  bool arg2 ;
 
48364
  void *argp1 = 0 ;
 
48365
  int res1 = 0 ;
 
48366
  bool val2 ;
 
48367
  int ecode2 = 0 ;
 
48368
  PyObject * obj0 = 0 ;
 
48369
  PyObject * obj1 = 0 ;
 
48370
  char *  kwnames[] = {
 
48371
    (char *) "self",(char *) "c", NULL 
 
48372
  };
 
48373
  
 
48374
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CollapsiblePaneEvent_SetCollapsed",kwnames,&obj0,&obj1)) SWIG_fail;
 
48375
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCollapsiblePaneEvent, 0 |  0 );
 
48376
  if (!SWIG_IsOK(res1)) {
 
48377
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CollapsiblePaneEvent_SetCollapsed" "', expected argument " "1"" of type '" "wxCollapsiblePaneEvent *""'"); 
 
48378
  }
 
48379
  arg1 = reinterpret_cast< wxCollapsiblePaneEvent * >(argp1);
 
48380
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
48381
  if (!SWIG_IsOK(ecode2)) {
 
48382
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CollapsiblePaneEvent_SetCollapsed" "', expected argument " "2"" of type '" "bool""'");
 
48383
  } 
 
48384
  arg2 = static_cast< bool >(val2);
 
48385
  {
 
48386
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48387
    (arg1)->SetCollapsed(arg2);
 
48388
    wxPyEndAllowThreads(__tstate);
 
48389
    if (PyErr_Occurred()) SWIG_fail;
 
48390
  }
 
48391
  resultobj = SWIG_Py_Void();
 
48392
  return resultobj;
 
48393
fail:
 
48394
  return NULL;
 
48395
}
 
48396
 
 
48397
 
 
48398
SWIGINTERN PyObject *CollapsiblePaneEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48399
  PyObject *obj;
 
48400
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
48401
  SWIG_TypeNewClientData(SWIGTYPE_p_wxCollapsiblePaneEvent, SWIG_NewClientData(obj));
 
48402
  return SWIG_Py_Void();
 
48403
}
 
48404
 
 
48405
SWIGINTERN PyObject *CollapsiblePaneEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48406
  return SWIG_Python_InitShadowInstance(args);
 
48407
}
 
48408
 
 
48409
SWIGINTERN int SearchCtrlNameStr_set(PyObject *) {
 
48410
  SWIG_Error(SWIG_AttributeError,"Variable SearchCtrlNameStr is read-only.");
 
48411
  return 1;
 
48412
}
 
48413
 
 
48414
 
 
48415
SWIGINTERN PyObject *SearchCtrlNameStr_get(void) {
 
48416
  PyObject *pyobj = 0;
 
48417
  
 
48418
  {
 
48419
#if wxUSE_UNICODE
 
48420
    pyobj = PyUnicode_FromWideChar((&wxPySearchCtrlNameStr)->c_str(), (&wxPySearchCtrlNameStr)->Len());
 
48421
#else
 
48422
    pyobj = PyString_FromStringAndSize((&wxPySearchCtrlNameStr)->c_str(), (&wxPySearchCtrlNameStr)->Len());
 
48423
#endif
 
48424
  }
 
48425
  return pyobj;
 
48426
}
 
48427
 
 
48428
 
 
48429
SWIGINTERN PyObject *SearchCtrlBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48430
  PyObject *obj;
 
48431
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
48432
  SWIG_TypeNewClientData(SWIGTYPE_p_wxSearchCtrlBase, SWIG_NewClientData(obj));
 
48433
  return SWIG_Py_Void();
 
48434
}
 
48435
 
 
48436
SWIGINTERN PyObject *_wrap_new_SearchCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
48437
  PyObject *resultobj = 0;
 
48438
  wxWindow *arg1 = (wxWindow *) 0 ;
 
48439
  int arg2 = (int) -1 ;
 
48440
  wxString const &arg3_defvalue = wxEmptyString ;
 
48441
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
48442
  wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
48443
  wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
48444
  wxSize const &arg5_defvalue = wxDefaultSize ;
 
48445
  wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
48446
  long arg6 = (long) 0 ;
 
48447
  wxValidator const &arg7_defvalue = wxDefaultValidator ;
 
48448
  wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
 
48449
  wxString const &arg8_defvalue = wxPySearchCtrlNameStr ;
 
48450
  wxString *arg8 = (wxString *) &arg8_defvalue ;
 
48451
  wxSearchCtrl *result = 0 ;
 
48452
  void *argp1 = 0 ;
 
48453
  int res1 = 0 ;
 
48454
  int val2 ;
 
48455
  int ecode2 = 0 ;
 
48456
  bool temp3 = false ;
 
48457
  wxPoint temp4 ;
 
48458
  wxSize temp5 ;
 
48459
  long val6 ;
 
48460
  int ecode6 = 0 ;
 
48461
  void *argp7 = 0 ;
 
48462
  int res7 = 0 ;
 
48463
  bool temp8 = false ;
 
48464
  PyObject * obj0 = 0 ;
 
48465
  PyObject * obj1 = 0 ;
 
48466
  PyObject * obj2 = 0 ;
 
48467
  PyObject * obj3 = 0 ;
 
48468
  PyObject * obj4 = 0 ;
 
48469
  PyObject * obj5 = 0 ;
 
48470
  PyObject * obj6 = 0 ;
 
48471
  PyObject * obj7 = 0 ;
 
48472
  char *  kwnames[] = {
 
48473
    (char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
48474
  };
 
48475
  
 
48476
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_SearchCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
 
48477
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
48478
  if (!SWIG_IsOK(res1)) {
 
48479
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SearchCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
48480
  }
 
48481
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
48482
  if (obj1) {
 
48483
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
48484
    if (!SWIG_IsOK(ecode2)) {
 
48485
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SearchCtrl" "', expected argument " "2"" of type '" "int""'");
 
48486
    } 
 
48487
    arg2 = static_cast< int >(val2);
 
48488
  }
 
48489
  if (obj2) {
 
48490
    {
 
48491
      arg3 = wxString_in_helper(obj2);
 
48492
      if (arg3 == NULL) SWIG_fail;
 
48493
      temp3 = true;
 
48494
    }
 
48495
  }
 
48496
  if (obj3) {
 
48497
    {
 
48498
      arg4 = &temp4;
 
48499
      if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
48500
    }
 
48501
  }
 
48502
  if (obj4) {
 
48503
    {
 
48504
      arg5 = &temp5;
 
48505
      if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
48506
    }
 
48507
  }
 
48508
  if (obj5) {
 
48509
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
48510
    if (!SWIG_IsOK(ecode6)) {
 
48511
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SearchCtrl" "', expected argument " "6"" of type '" "long""'");
 
48512
    } 
 
48513
    arg6 = static_cast< long >(val6);
 
48514
  }
 
48515
  if (obj6) {
 
48516
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator,  0  | 0);
 
48517
    if (!SWIG_IsOK(res7)) {
 
48518
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SearchCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
48519
    }
 
48520
    if (!argp7) {
 
48521
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SearchCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'"); 
 
48522
    }
 
48523
    arg7 = reinterpret_cast< wxValidator * >(argp7);
 
48524
  }
 
48525
  if (obj7) {
 
48526
    {
 
48527
      arg8 = wxString_in_helper(obj7);
 
48528
      if (arg8 == NULL) SWIG_fail;
 
48529
      temp8 = true;
 
48530
    }
 
48531
  }
 
48532
  {
 
48533
    if (!wxPyCheckForApp()) SWIG_fail;
 
48534
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48535
    result = (wxSearchCtrl *)new wxSearchCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
 
48536
    wxPyEndAllowThreads(__tstate);
 
48537
    if (PyErr_Occurred()) SWIG_fail;
 
48538
  }
 
48539
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSearchCtrl, SWIG_POINTER_NEW |  0 );
 
48540
  {
 
48541
    if (temp3)
 
48542
    delete arg3;
 
48543
  }
 
48544
  {
 
48545
    if (temp8)
 
48546
    delete arg8;
 
48547
  }
 
48548
  return resultobj;
 
48549
fail:
 
48550
  {
 
48551
    if (temp3)
 
48552
    delete arg3;
 
48553
  }
 
48554
  {
 
48555
    if (temp8)
 
48556
    delete arg8;
 
48557
  }
 
48558
  return NULL;
 
48559
}
 
48560
 
 
48561
 
 
48562
SWIGINTERN PyObject *_wrap_new_PreSearchCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48563
  PyObject *resultobj = 0;
 
48564
  wxSearchCtrl *result = 0 ;
 
48565
  
 
48566
  if (!SWIG_Python_UnpackTuple(args,"new_PreSearchCtrl",0,0,0)) SWIG_fail;
 
48567
  {
 
48568
    if (!wxPyCheckForApp()) SWIG_fail;
 
48569
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48570
    result = (wxSearchCtrl *)new wxSearchCtrl();
 
48571
    wxPyEndAllowThreads(__tstate);
 
48572
    if (PyErr_Occurred()) SWIG_fail;
 
48573
  }
 
48574
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSearchCtrl, SWIG_POINTER_OWN |  0 );
 
48575
  return resultobj;
 
48576
fail:
 
48577
  return NULL;
 
48578
}
 
48579
 
 
48580
 
 
48581
SWIGINTERN PyObject *_wrap_SearchCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
48582
  PyObject *resultobj = 0;
 
48583
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
48584
  wxWindow *arg2 = (wxWindow *) 0 ;
 
48585
  int arg3 = (int) -1 ;
 
48586
  wxString const &arg4_defvalue = wxEmptyString ;
 
48587
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
48588
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
48589
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
48590
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
48591
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
48592
  long arg7 = (long) 0 ;
 
48593
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
48594
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
48595
  wxString const &arg9_defvalue = wxPySearchCtrlNameStr ;
 
48596
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
48597
  bool result;
 
48598
  void *argp1 = 0 ;
 
48599
  int res1 = 0 ;
 
48600
  void *argp2 = 0 ;
 
48601
  int res2 = 0 ;
 
48602
  int val3 ;
 
48603
  int ecode3 = 0 ;
 
48604
  bool temp4 = false ;
 
48605
  wxPoint temp5 ;
 
48606
  wxSize temp6 ;
 
48607
  long val7 ;
 
48608
  int ecode7 = 0 ;
 
48609
  void *argp8 = 0 ;
 
48610
  int res8 = 0 ;
 
48611
  bool temp9 = false ;
 
48612
  PyObject * obj0 = 0 ;
 
48613
  PyObject * obj1 = 0 ;
 
48614
  PyObject * obj2 = 0 ;
 
48615
  PyObject * obj3 = 0 ;
 
48616
  PyObject * obj4 = 0 ;
 
48617
  PyObject * obj5 = 0 ;
 
48618
  PyObject * obj6 = 0 ;
 
48619
  PyObject * obj7 = 0 ;
 
48620
  PyObject * obj8 = 0 ;
 
48621
  char *  kwnames[] = {
 
48622
    (char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
48623
  };
 
48624
  
 
48625
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:SearchCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
48626
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
48627
  if (!SWIG_IsOK(res1)) {
 
48628
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_Create" "', expected argument " "1"" of type '" "wxSearchCtrl *""'"); 
 
48629
  }
 
48630
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
48631
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
48632
  if (!SWIG_IsOK(res2)) {
 
48633
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SearchCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
48634
  }
 
48635
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
48636
  if (obj2) {
 
48637
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
48638
    if (!SWIG_IsOK(ecode3)) {
 
48639
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SearchCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
48640
    } 
 
48641
    arg3 = static_cast< int >(val3);
 
48642
  }
 
48643
  if (obj3) {
 
48644
    {
 
48645
      arg4 = wxString_in_helper(obj3);
 
48646
      if (arg4 == NULL) SWIG_fail;
 
48647
      temp4 = true;
 
48648
    }
 
48649
  }
 
48650
  if (obj4) {
 
48651
    {
 
48652
      arg5 = &temp5;
 
48653
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
48654
    }
 
48655
  }
 
48656
  if (obj5) {
 
48657
    {
 
48658
      arg6 = &temp6;
 
48659
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
48660
    }
 
48661
  }
 
48662
  if (obj6) {
 
48663
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
48664
    if (!SWIG_IsOK(ecode7)) {
 
48665
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SearchCtrl_Create" "', expected argument " "7"" of type '" "long""'");
 
48666
    } 
 
48667
    arg7 = static_cast< long >(val7);
 
48668
  }
 
48669
  if (obj7) {
 
48670
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
48671
    if (!SWIG_IsOK(res8)) {
 
48672
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SearchCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
48673
    }
 
48674
    if (!argp8) {
 
48675
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SearchCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
48676
    }
 
48677
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
48678
  }
 
48679
  if (obj8) {
 
48680
    {
 
48681
      arg9 = wxString_in_helper(obj8);
 
48682
      if (arg9 == NULL) SWIG_fail;
 
48683
      temp9 = true;
 
48684
    }
 
48685
  }
 
48686
  {
 
48687
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48688
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
48689
    wxPyEndAllowThreads(__tstate);
 
48690
    if (PyErr_Occurred()) SWIG_fail;
 
48691
  }
 
48692
  {
 
48693
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
48694
  }
 
48695
  {
 
48696
    if (temp4)
 
48697
    delete arg4;
 
48698
  }
 
48699
  {
 
48700
    if (temp9)
 
48701
    delete arg9;
 
48702
  }
 
48703
  return resultobj;
 
48704
fail:
 
48705
  {
 
48706
    if (temp4)
 
48707
    delete arg4;
 
48708
  }
 
48709
  {
 
48710
    if (temp9)
 
48711
    delete arg9;
 
48712
  }
 
48713
  return NULL;
 
48714
}
 
48715
 
 
48716
 
 
48717
SWIGINTERN PyObject *_wrap_SearchCtrl_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
48718
  PyObject *resultobj = 0;
 
48719
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
48720
  wxMenu *arg2 = (wxMenu *) 0 ;
 
48721
  void *argp1 = 0 ;
 
48722
  int res1 = 0 ;
 
48723
  void *argp2 = 0 ;
 
48724
  int res2 = 0 ;
 
48725
  PyObject * obj0 = 0 ;
 
48726
  PyObject * obj1 = 0 ;
 
48727
  char *  kwnames[] = {
 
48728
    (char *) "self",(char *) "menu", NULL 
 
48729
  };
 
48730
  
 
48731
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SearchCtrl_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
 
48732
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
48733
  if (!SWIG_IsOK(res1)) {
 
48734
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_SetMenu" "', expected argument " "1"" of type '" "wxSearchCtrl *""'"); 
 
48735
  }
 
48736
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
48737
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 |  0 );
 
48738
  if (!SWIG_IsOK(res2)) {
 
48739
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SearchCtrl_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'"); 
 
48740
  }
 
48741
  arg2 = reinterpret_cast< wxMenu * >(argp2);
 
48742
  {
 
48743
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48744
    (arg1)->SetMenu(arg2);
 
48745
    wxPyEndAllowThreads(__tstate);
 
48746
    if (PyErr_Occurred()) SWIG_fail;
 
48747
  }
 
48748
  resultobj = SWIG_Py_Void();
 
48749
  return resultobj;
 
48750
fail:
 
48751
  return NULL;
 
48752
}
 
48753
 
 
48754
 
 
48755
SWIGINTERN PyObject *_wrap_SearchCtrl_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48756
  PyObject *resultobj = 0;
 
48757
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
48758
  wxMenu *result = 0 ;
 
48759
  void *argp1 = 0 ;
 
48760
  int res1 = 0 ;
 
48761
  PyObject *swig_obj[1] ;
 
48762
  
 
48763
  if (!args) SWIG_fail;
 
48764
  swig_obj[0] = args;
 
48765
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
48766
  if (!SWIG_IsOK(res1)) {
 
48767
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_GetMenu" "', expected argument " "1"" of type '" "wxSearchCtrl *""'"); 
 
48768
  }
 
48769
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
48770
  {
 
48771
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48772
    result = (wxMenu *)(arg1)->GetMenu();
 
48773
    wxPyEndAllowThreads(__tstate);
 
48774
    if (PyErr_Occurred()) SWIG_fail;
 
48775
  }
 
48776
  {
 
48777
    resultobj = wxPyMake_wxObject(result, 0); 
 
48778
  }
 
48779
  return resultobj;
 
48780
fail:
 
48781
  return NULL;
 
48782
}
 
48783
 
 
48784
 
 
48785
SWIGINTERN PyObject *_wrap_SearchCtrl_ShowSearchButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
48786
  PyObject *resultobj = 0;
 
48787
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
48788
  bool arg2 ;
 
48789
  void *argp1 = 0 ;
 
48790
  int res1 = 0 ;
 
48791
  bool val2 ;
 
48792
  int ecode2 = 0 ;
 
48793
  PyObject * obj0 = 0 ;
 
48794
  PyObject * obj1 = 0 ;
 
48795
  char *  kwnames[] = {
 
48796
    (char *) "self",(char *) "show", NULL 
 
48797
  };
 
48798
  
 
48799
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SearchCtrl_ShowSearchButton",kwnames,&obj0,&obj1)) SWIG_fail;
 
48800
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
48801
  if (!SWIG_IsOK(res1)) {
 
48802
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_ShowSearchButton" "', expected argument " "1"" of type '" "wxSearchCtrl *""'"); 
 
48803
  }
 
48804
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
48805
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
48806
  if (!SWIG_IsOK(ecode2)) {
 
48807
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SearchCtrl_ShowSearchButton" "', expected argument " "2"" of type '" "bool""'");
 
48808
  } 
 
48809
  arg2 = static_cast< bool >(val2);
 
48810
  {
 
48811
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48812
    (arg1)->ShowSearchButton(arg2);
 
48813
    wxPyEndAllowThreads(__tstate);
 
48814
    if (PyErr_Occurred()) SWIG_fail;
 
48815
  }
 
48816
  resultobj = SWIG_Py_Void();
 
48817
  return resultobj;
 
48818
fail:
 
48819
  return NULL;
 
48820
}
 
48821
 
 
48822
 
 
48823
SWIGINTERN PyObject *_wrap_SearchCtrl_IsSearchButtonVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48824
  PyObject *resultobj = 0;
 
48825
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
48826
  bool result;
 
48827
  void *argp1 = 0 ;
 
48828
  int res1 = 0 ;
 
48829
  PyObject *swig_obj[1] ;
 
48830
  
 
48831
  if (!args) SWIG_fail;
 
48832
  swig_obj[0] = args;
 
48833
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
48834
  if (!SWIG_IsOK(res1)) {
 
48835
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_IsSearchButtonVisible" "', expected argument " "1"" of type '" "wxSearchCtrl const *""'"); 
 
48836
  }
 
48837
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
48838
  {
 
48839
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48840
    result = (bool)((wxSearchCtrl const *)arg1)->IsSearchButtonVisible();
 
48841
    wxPyEndAllowThreads(__tstate);
 
48842
    if (PyErr_Occurred()) SWIG_fail;
 
48843
  }
 
48844
  {
 
48845
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
48846
  }
 
48847
  return resultobj;
 
48848
fail:
 
48849
  return NULL;
 
48850
}
 
48851
 
 
48852
 
 
48853
SWIGINTERN PyObject *_wrap_SearchCtrl_ShowCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
48854
  PyObject *resultobj = 0;
 
48855
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
48856
  bool arg2 ;
 
48857
  void *argp1 = 0 ;
 
48858
  int res1 = 0 ;
 
48859
  bool val2 ;
 
48860
  int ecode2 = 0 ;
 
48861
  PyObject * obj0 = 0 ;
 
48862
  PyObject * obj1 = 0 ;
 
48863
  char *  kwnames[] = {
 
48864
    (char *) "self",(char *) "show", NULL 
 
48865
  };
 
48866
  
 
48867
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SearchCtrl_ShowCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
 
48868
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
48869
  if (!SWIG_IsOK(res1)) {
 
48870
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_ShowCancelButton" "', expected argument " "1"" of type '" "wxSearchCtrl *""'"); 
 
48871
  }
 
48872
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
48873
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
48874
  if (!SWIG_IsOK(ecode2)) {
 
48875
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SearchCtrl_ShowCancelButton" "', expected argument " "2"" of type '" "bool""'");
 
48876
  } 
 
48877
  arg2 = static_cast< bool >(val2);
 
48878
  {
 
48879
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48880
    (arg1)->ShowCancelButton(arg2);
 
48881
    wxPyEndAllowThreads(__tstate);
 
48882
    if (PyErr_Occurred()) SWIG_fail;
 
48883
  }
 
48884
  resultobj = SWIG_Py_Void();
 
48885
  return resultobj;
 
48886
fail:
 
48887
  return NULL;
 
48888
}
 
48889
 
 
48890
 
 
48891
SWIGINTERN PyObject *_wrap_SearchCtrl_IsCancelButtonVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48892
  PyObject *resultobj = 0;
 
48893
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
48894
  bool result;
 
48895
  void *argp1 = 0 ;
 
48896
  int res1 = 0 ;
 
48897
  PyObject *swig_obj[1] ;
 
48898
  
 
48899
  if (!args) SWIG_fail;
 
48900
  swig_obj[0] = args;
 
48901
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
48902
  if (!SWIG_IsOK(res1)) {
 
48903
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_IsCancelButtonVisible" "', expected argument " "1"" of type '" "wxSearchCtrl const *""'"); 
 
48904
  }
 
48905
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
48906
  {
 
48907
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48908
    result = (bool)((wxSearchCtrl const *)arg1)->IsCancelButtonVisible();
 
48909
    wxPyEndAllowThreads(__tstate);
 
48910
    if (PyErr_Occurred()) SWIG_fail;
 
48911
  }
 
48912
  {
 
48913
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
48914
  }
 
48915
  return resultobj;
 
48916
fail:
 
48917
  return NULL;
 
48918
}
 
48919
 
 
48920
 
 
48921
SWIGINTERN PyObject *_wrap_SearchCtrl_SetDescriptiveText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
48922
  PyObject *resultobj = 0;
 
48923
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
48924
  wxString *arg2 = 0 ;
 
48925
  void *argp1 = 0 ;
 
48926
  int res1 = 0 ;
 
48927
  bool temp2 = false ;
 
48928
  PyObject * obj0 = 0 ;
 
48929
  PyObject * obj1 = 0 ;
 
48930
  char *  kwnames[] = {
 
48931
    (char *) "self",(char *) "text", NULL 
 
48932
  };
 
48933
  
 
48934
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SearchCtrl_SetDescriptiveText",kwnames,&obj0,&obj1)) SWIG_fail;
 
48935
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
48936
  if (!SWIG_IsOK(res1)) {
 
48937
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_SetDescriptiveText" "', expected argument " "1"" of type '" "wxSearchCtrl *""'"); 
 
48938
  }
 
48939
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
48940
  {
 
48941
    arg2 = wxString_in_helper(obj1);
 
48942
    if (arg2 == NULL) SWIG_fail;
 
48943
    temp2 = true;
 
48944
  }
 
48945
  {
 
48946
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48947
    (arg1)->SetDescriptiveText((wxString const &)*arg2);
 
48948
    wxPyEndAllowThreads(__tstate);
 
48949
    if (PyErr_Occurred()) SWIG_fail;
 
48950
  }
 
48951
  resultobj = SWIG_Py_Void();
 
48952
  {
 
48953
    if (temp2)
 
48954
    delete arg2;
 
48955
  }
 
48956
  return resultobj;
 
48957
fail:
 
48958
  {
 
48959
    if (temp2)
 
48960
    delete arg2;
 
48961
  }
 
48962
  return NULL;
 
48963
}
 
48964
 
 
48965
 
 
48966
SWIGINTERN PyObject *_wrap_SearchCtrl_GetDescriptiveText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
48967
  PyObject *resultobj = 0;
 
48968
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
48969
  wxString result;
 
48970
  void *argp1 = 0 ;
 
48971
  int res1 = 0 ;
 
48972
  PyObject *swig_obj[1] ;
 
48973
  
 
48974
  if (!args) SWIG_fail;
 
48975
  swig_obj[0] = args;
 
48976
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
48977
  if (!SWIG_IsOK(res1)) {
 
48978
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_GetDescriptiveText" "', expected argument " "1"" of type '" "wxSearchCtrl const *""'"); 
 
48979
  }
 
48980
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
48981
  {
 
48982
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
48983
    result = ((wxSearchCtrl const *)arg1)->GetDescriptiveText();
 
48984
    wxPyEndAllowThreads(__tstate);
 
48985
    if (PyErr_Occurred()) SWIG_fail;
 
48986
  }
 
48987
  {
 
48988
#if wxUSE_UNICODE
 
48989
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
48990
#else
 
48991
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
48992
#endif
 
48993
  }
 
48994
  return resultobj;
 
48995
fail:
 
48996
  return NULL;
 
48997
}
 
48998
 
 
48999
 
 
49000
SWIGINTERN PyObject *_wrap_SearchCtrl_SetSearchBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49001
  PyObject *resultobj = 0;
 
49002
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
49003
  wxBitmap *arg2 = 0 ;
 
49004
  void *argp1 = 0 ;
 
49005
  int res1 = 0 ;
 
49006
  void *argp2 = 0 ;
 
49007
  int res2 = 0 ;
 
49008
  PyObject * obj0 = 0 ;
 
49009
  PyObject * obj1 = 0 ;
 
49010
  char *  kwnames[] = {
 
49011
    (char *) "self",(char *) "bitmap", NULL 
 
49012
  };
 
49013
  
 
49014
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SearchCtrl_SetSearchBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
 
49015
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
49016
  if (!SWIG_IsOK(res1)) {
 
49017
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_SetSearchBitmap" "', expected argument " "1"" of type '" "wxSearchCtrl *""'"); 
 
49018
  }
 
49019
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
49020
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
49021
  if (!SWIG_IsOK(res2)) {
 
49022
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SearchCtrl_SetSearchBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
49023
  }
 
49024
  if (!argp2) {
 
49025
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SearchCtrl_SetSearchBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
49026
  }
 
49027
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
49028
  {
 
49029
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49030
    (arg1)->SetSearchBitmap((wxBitmap const &)*arg2);
 
49031
    wxPyEndAllowThreads(__tstate);
 
49032
    if (PyErr_Occurred()) SWIG_fail;
 
49033
  }
 
49034
  resultobj = SWIG_Py_Void();
 
49035
  return resultobj;
 
49036
fail:
 
49037
  return NULL;
 
49038
}
 
49039
 
 
49040
 
 
49041
SWIGINTERN PyObject *_wrap_SearchCtrl_SetSearchMenuBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49042
  PyObject *resultobj = 0;
 
49043
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
49044
  wxBitmap *arg2 = 0 ;
 
49045
  void *argp1 = 0 ;
 
49046
  int res1 = 0 ;
 
49047
  void *argp2 = 0 ;
 
49048
  int res2 = 0 ;
 
49049
  PyObject * obj0 = 0 ;
 
49050
  PyObject * obj1 = 0 ;
 
49051
  char *  kwnames[] = {
 
49052
    (char *) "self",(char *) "bitmap", NULL 
 
49053
  };
 
49054
  
 
49055
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SearchCtrl_SetSearchMenuBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
 
49056
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
49057
  if (!SWIG_IsOK(res1)) {
 
49058
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_SetSearchMenuBitmap" "', expected argument " "1"" of type '" "wxSearchCtrl *""'"); 
 
49059
  }
 
49060
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
49061
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
49062
  if (!SWIG_IsOK(res2)) {
 
49063
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SearchCtrl_SetSearchMenuBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
49064
  }
 
49065
  if (!argp2) {
 
49066
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SearchCtrl_SetSearchMenuBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
49067
  }
 
49068
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
49069
  {
 
49070
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49071
    (arg1)->SetSearchMenuBitmap((wxBitmap const &)*arg2);
 
49072
    wxPyEndAllowThreads(__tstate);
 
49073
    if (PyErr_Occurred()) SWIG_fail;
 
49074
  }
 
49075
  resultobj = SWIG_Py_Void();
 
49076
  return resultobj;
 
49077
fail:
 
49078
  return NULL;
 
49079
}
 
49080
 
 
49081
 
 
49082
SWIGINTERN PyObject *_wrap_SearchCtrl_SetCancelBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49083
  PyObject *resultobj = 0;
 
49084
  wxSearchCtrl *arg1 = (wxSearchCtrl *) 0 ;
 
49085
  wxBitmap *arg2 = 0 ;
 
49086
  void *argp1 = 0 ;
 
49087
  int res1 = 0 ;
 
49088
  void *argp2 = 0 ;
 
49089
  int res2 = 0 ;
 
49090
  PyObject * obj0 = 0 ;
 
49091
  PyObject * obj1 = 0 ;
 
49092
  char *  kwnames[] = {
 
49093
    (char *) "self",(char *) "bitmap", NULL 
 
49094
  };
 
49095
  
 
49096
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SearchCtrl_SetCancelBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
 
49097
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSearchCtrl, 0 |  0 );
 
49098
  if (!SWIG_IsOK(res1)) {
 
49099
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SearchCtrl_SetCancelBitmap" "', expected argument " "1"" of type '" "wxSearchCtrl *""'"); 
 
49100
  }
 
49101
  arg1 = reinterpret_cast< wxSearchCtrl * >(argp1);
 
49102
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap,  0  | 0);
 
49103
  if (!SWIG_IsOK(res2)) {
 
49104
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SearchCtrl_SetCancelBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
49105
  }
 
49106
  if (!argp2) {
 
49107
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SearchCtrl_SetCancelBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'"); 
 
49108
  }
 
49109
  arg2 = reinterpret_cast< wxBitmap * >(argp2);
 
49110
  {
 
49111
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49112
    (arg1)->SetCancelBitmap((wxBitmap const &)*arg2);
 
49113
    wxPyEndAllowThreads(__tstate);
 
49114
    if (PyErr_Occurred()) SWIG_fail;
 
49115
  }
 
49116
  resultobj = SWIG_Py_Void();
 
49117
  return resultobj;
 
49118
fail:
 
49119
  return NULL;
 
49120
}
 
49121
 
 
49122
 
 
49123
SWIGINTERN PyObject *SearchCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49124
  PyObject *obj;
 
49125
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
49126
  SWIG_TypeNewClientData(SWIGTYPE_p_wxSearchCtrl, SWIG_NewClientData(obj));
 
49127
  return SWIG_Py_Void();
 
49128
}
 
49129
 
 
49130
SWIGINTERN PyObject *SearchCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49131
  return SWIG_Python_InitShadowInstance(args);
 
49132
}
 
49133
 
 
49134
SWIGINTERN int FileCtrlNameStr_set(PyObject *) {
 
49135
  SWIG_Error(SWIG_AttributeError,"Variable FileCtrlNameStr is read-only.");
 
49136
  return 1;
 
49137
}
 
49138
 
 
49139
 
 
49140
SWIGINTERN PyObject *FileCtrlNameStr_get(void) {
 
49141
  PyObject *pyobj = 0;
 
49142
  
 
49143
  {
 
49144
#if wxUSE_UNICODE
 
49145
    pyobj = PyUnicode_FromWideChar((&wxPyFileCtrlNameStr)->c_str(), (&wxPyFileCtrlNameStr)->Len());
 
49146
#else
 
49147
    pyobj = PyString_FromStringAndSize((&wxPyFileCtrlNameStr)->c_str(), (&wxPyFileCtrlNameStr)->Len());
 
49148
#endif
 
49149
  }
 
49150
  return pyobj;
 
49151
}
 
49152
 
 
49153
 
 
49154
SWIGINTERN PyObject *_wrap_new_FileCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49155
  PyObject *resultobj = 0;
 
49156
  wxWindow *arg1 = (wxWindow *) 0 ;
 
49157
  int arg2 = (int) -1 ;
 
49158
  wxString const &arg3_defvalue = wxEmptyString ;
 
49159
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
49160
  wxString const &arg4_defvalue = wxEmptyString ;
 
49161
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
49162
  wxString const &arg5_defvalue = wxFileSelectorDefaultWildcardStr ;
 
49163
  wxString *arg5 = (wxString *) &arg5_defvalue ;
 
49164
  long arg6 = (long) wxFC_DEFAULT_STYLE ;
 
49165
  wxPoint const &arg7_defvalue = wxDefaultPosition ;
 
49166
  wxPoint *arg7 = (wxPoint *) &arg7_defvalue ;
 
49167
  wxSize const &arg8_defvalue = wxDefaultSize ;
 
49168
  wxSize *arg8 = (wxSize *) &arg8_defvalue ;
 
49169
  wxString const &arg9_defvalue = wxPyFileCtrlNameStr ;
 
49170
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
49171
  wxFileCtrl *result = 0 ;
 
49172
  void *argp1 = 0 ;
 
49173
  int res1 = 0 ;
 
49174
  int val2 ;
 
49175
  int ecode2 = 0 ;
 
49176
  bool temp3 = false ;
 
49177
  bool temp4 = false ;
 
49178
  bool temp5 = false ;
 
49179
  long val6 ;
 
49180
  int ecode6 = 0 ;
 
49181
  wxPoint temp7 ;
 
49182
  wxSize temp8 ;
 
49183
  bool temp9 = false ;
 
49184
  PyObject * obj0 = 0 ;
 
49185
  PyObject * obj1 = 0 ;
 
49186
  PyObject * obj2 = 0 ;
 
49187
  PyObject * obj3 = 0 ;
 
49188
  PyObject * obj4 = 0 ;
 
49189
  PyObject * obj5 = 0 ;
 
49190
  PyObject * obj6 = 0 ;
 
49191
  PyObject * obj7 = 0 ;
 
49192
  PyObject * obj8 = 0 ;
 
49193
  char *  kwnames[] = {
 
49194
    (char *) "parent",(char *) "id",(char *) "defaultDirectory",(char *) "defaultFilename",(char *) "wildCard",(char *) "style",(char *) "pos",(char *) "size",(char *) "name", NULL 
 
49195
  };
 
49196
  
 
49197
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_FileCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
49198
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
49199
  if (!SWIG_IsOK(res1)) {
 
49200
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileCtrl" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
49201
  }
 
49202
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
49203
  if (obj1) {
 
49204
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
49205
    if (!SWIG_IsOK(ecode2)) {
 
49206
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileCtrl" "', expected argument " "2"" of type '" "int""'");
 
49207
    } 
 
49208
    arg2 = static_cast< int >(val2);
 
49209
  }
 
49210
  if (obj2) {
 
49211
    {
 
49212
      arg3 = wxString_in_helper(obj2);
 
49213
      if (arg3 == NULL) SWIG_fail;
 
49214
      temp3 = true;
 
49215
    }
 
49216
  }
 
49217
  if (obj3) {
 
49218
    {
 
49219
      arg4 = wxString_in_helper(obj3);
 
49220
      if (arg4 == NULL) SWIG_fail;
 
49221
      temp4 = true;
 
49222
    }
 
49223
  }
 
49224
  if (obj4) {
 
49225
    {
 
49226
      arg5 = wxString_in_helper(obj4);
 
49227
      if (arg5 == NULL) SWIG_fail;
 
49228
      temp5 = true;
 
49229
    }
 
49230
  }
 
49231
  if (obj5) {
 
49232
    ecode6 = SWIG_AsVal_long(obj5, &val6);
 
49233
    if (!SWIG_IsOK(ecode6)) {
 
49234
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FileCtrl" "', expected argument " "6"" of type '" "long""'");
 
49235
    } 
 
49236
    arg6 = static_cast< long >(val6);
 
49237
  }
 
49238
  if (obj6) {
 
49239
    {
 
49240
      arg7 = &temp7;
 
49241
      if ( ! wxPoint_helper(obj6, &arg7)) SWIG_fail;
 
49242
    }
 
49243
  }
 
49244
  if (obj7) {
 
49245
    {
 
49246
      arg8 = &temp8;
 
49247
      if ( ! wxSize_helper(obj7, &arg8)) SWIG_fail;
 
49248
    }
 
49249
  }
 
49250
  if (obj8) {
 
49251
    {
 
49252
      arg9 = wxString_in_helper(obj8);
 
49253
      if (arg9 == NULL) SWIG_fail;
 
49254
      temp9 = true;
 
49255
    }
 
49256
  }
 
49257
  {
 
49258
    if (!wxPyCheckForApp()) SWIG_fail;
 
49259
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49260
    result = (wxFileCtrl *)new wxFileCtrl(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,(wxPoint const &)*arg7,(wxSize const &)*arg8,(wxString const &)*arg9);
 
49261
    wxPyEndAllowThreads(__tstate);
 
49262
    if (PyErr_Occurred()) SWIG_fail;
 
49263
  }
 
49264
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileCtrl, SWIG_POINTER_NEW |  0 );
 
49265
  {
 
49266
    if (temp3)
 
49267
    delete arg3;
 
49268
  }
 
49269
  {
 
49270
    if (temp4)
 
49271
    delete arg4;
 
49272
  }
 
49273
  {
 
49274
    if (temp5)
 
49275
    delete arg5;
 
49276
  }
 
49277
  {
 
49278
    if (temp9)
 
49279
    delete arg9;
 
49280
  }
 
49281
  return resultobj;
 
49282
fail:
 
49283
  {
 
49284
    if (temp3)
 
49285
    delete arg3;
 
49286
  }
 
49287
  {
 
49288
    if (temp4)
 
49289
    delete arg4;
 
49290
  }
 
49291
  {
 
49292
    if (temp5)
 
49293
    delete arg5;
 
49294
  }
 
49295
  {
 
49296
    if (temp9)
 
49297
    delete arg9;
 
49298
  }
 
49299
  return NULL;
 
49300
}
 
49301
 
 
49302
 
 
49303
SWIGINTERN PyObject *_wrap_new_PreFileCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49304
  PyObject *resultobj = 0;
 
49305
  wxFileCtrl *result = 0 ;
 
49306
  
 
49307
  if (!SWIG_Python_UnpackTuple(args,"new_PreFileCtrl",0,0,0)) SWIG_fail;
 
49308
  {
 
49309
    if (!wxPyCheckForApp()) SWIG_fail;
 
49310
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49311
    result = (wxFileCtrl *)new wxFileCtrl();
 
49312
    wxPyEndAllowThreads(__tstate);
 
49313
    if (PyErr_Occurred()) SWIG_fail;
 
49314
  }
 
49315
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileCtrl, SWIG_POINTER_OWN |  0 );
 
49316
  return resultobj;
 
49317
fail:
 
49318
  return NULL;
 
49319
}
 
49320
 
 
49321
 
 
49322
SWIGINTERN PyObject *_wrap_FileCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49323
  PyObject *resultobj = 0;
 
49324
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49325
  wxWindow *arg2 = (wxWindow *) 0 ;
 
49326
  int arg3 = (int) -1 ;
 
49327
  wxString const &arg4_defvalue = wxEmptyString ;
 
49328
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
49329
  wxString const &arg5_defvalue = wxEmptyString ;
 
49330
  wxString *arg5 = (wxString *) &arg5_defvalue ;
 
49331
  wxString const &arg6_defvalue = wxFileSelectorDefaultWildcardStr ;
 
49332
  wxString *arg6 = (wxString *) &arg6_defvalue ;
 
49333
  long arg7 = (long) wxFC_DEFAULT_STYLE ;
 
49334
  wxPoint const &arg8_defvalue = wxDefaultPosition ;
 
49335
  wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
 
49336
  wxSize const &arg9_defvalue = wxDefaultSize ;
 
49337
  wxSize *arg9 = (wxSize *) &arg9_defvalue ;
 
49338
  wxString const &arg10_defvalue = wxPyFileCtrlNameStr ;
 
49339
  wxString *arg10 = (wxString *) &arg10_defvalue ;
 
49340
  bool result;
 
49341
  void *argp1 = 0 ;
 
49342
  int res1 = 0 ;
 
49343
  void *argp2 = 0 ;
 
49344
  int res2 = 0 ;
 
49345
  int val3 ;
 
49346
  int ecode3 = 0 ;
 
49347
  bool temp4 = false ;
 
49348
  bool temp5 = false ;
 
49349
  bool temp6 = false ;
 
49350
  long val7 ;
 
49351
  int ecode7 = 0 ;
 
49352
  wxPoint temp8 ;
 
49353
  wxSize temp9 ;
 
49354
  bool temp10 = false ;
 
49355
  PyObject * obj0 = 0 ;
 
49356
  PyObject * obj1 = 0 ;
 
49357
  PyObject * obj2 = 0 ;
 
49358
  PyObject * obj3 = 0 ;
 
49359
  PyObject * obj4 = 0 ;
 
49360
  PyObject * obj5 = 0 ;
 
49361
  PyObject * obj6 = 0 ;
 
49362
  PyObject * obj7 = 0 ;
 
49363
  PyObject * obj8 = 0 ;
 
49364
  PyObject * obj9 = 0 ;
 
49365
  char *  kwnames[] = {
 
49366
    (char *) "self",(char *) "parent",(char *) "id",(char *) "defaultDirectory",(char *) "defaultFilename",(char *) "wildCard",(char *) "style",(char *) "pos",(char *) "size",(char *) "name", NULL 
 
49367
  };
 
49368
  
 
49369
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:FileCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
 
49370
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49371
  if (!SWIG_IsOK(res1)) {
 
49372
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_Create" "', expected argument " "1"" of type '" "wxFileCtrl *""'"); 
 
49373
  }
 
49374
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49375
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
49376
  if (!SWIG_IsOK(res2)) {
 
49377
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
49378
  }
 
49379
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
49380
  if (obj2) {
 
49381
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
49382
    if (!SWIG_IsOK(ecode3)) {
 
49383
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileCtrl_Create" "', expected argument " "3"" of type '" "int""'");
 
49384
    } 
 
49385
    arg3 = static_cast< int >(val3);
 
49386
  }
 
49387
  if (obj3) {
 
49388
    {
 
49389
      arg4 = wxString_in_helper(obj3);
 
49390
      if (arg4 == NULL) SWIG_fail;
 
49391
      temp4 = true;
 
49392
    }
 
49393
  }
 
49394
  if (obj4) {
 
49395
    {
 
49396
      arg5 = wxString_in_helper(obj4);
 
49397
      if (arg5 == NULL) SWIG_fail;
 
49398
      temp5 = true;
 
49399
    }
 
49400
  }
 
49401
  if (obj5) {
 
49402
    {
 
49403
      arg6 = wxString_in_helper(obj5);
 
49404
      if (arg6 == NULL) SWIG_fail;
 
49405
      temp6 = true;
 
49406
    }
 
49407
  }
 
49408
  if (obj6) {
 
49409
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
49410
    if (!SWIG_IsOK(ecode7)) {
 
49411
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "FileCtrl_Create" "', expected argument " "7"" of type '" "long""'");
 
49412
    } 
 
49413
    arg7 = static_cast< long >(val7);
 
49414
  }
 
49415
  if (obj7) {
 
49416
    {
 
49417
      arg8 = &temp8;
 
49418
      if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
 
49419
    }
 
49420
  }
 
49421
  if (obj8) {
 
49422
    {
 
49423
      arg9 = &temp9;
 
49424
      if ( ! wxSize_helper(obj8, &arg9)) SWIG_fail;
 
49425
    }
 
49426
  }
 
49427
  if (obj9) {
 
49428
    {
 
49429
      arg10 = wxString_in_helper(obj9);
 
49430
      if (arg10 == NULL) SWIG_fail;
 
49431
      temp10 = true;
 
49432
    }
 
49433
  }
 
49434
  {
 
49435
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49436
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxString const &)*arg6,arg7,(wxPoint const &)*arg8,(wxSize const &)*arg9,(wxString const &)*arg10);
 
49437
    wxPyEndAllowThreads(__tstate);
 
49438
    if (PyErr_Occurred()) SWIG_fail;
 
49439
  }
 
49440
  {
 
49441
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
49442
  }
 
49443
  {
 
49444
    if (temp4)
 
49445
    delete arg4;
 
49446
  }
 
49447
  {
 
49448
    if (temp5)
 
49449
    delete arg5;
 
49450
  }
 
49451
  {
 
49452
    if (temp6)
 
49453
    delete arg6;
 
49454
  }
 
49455
  {
 
49456
    if (temp10)
 
49457
    delete arg10;
 
49458
  }
 
49459
  return resultobj;
 
49460
fail:
 
49461
  {
 
49462
    if (temp4)
 
49463
    delete arg4;
 
49464
  }
 
49465
  {
 
49466
    if (temp5)
 
49467
    delete arg5;
 
49468
  }
 
49469
  {
 
49470
    if (temp6)
 
49471
    delete arg6;
 
49472
  }
 
49473
  {
 
49474
    if (temp10)
 
49475
    delete arg10;
 
49476
  }
 
49477
  return NULL;
 
49478
}
 
49479
 
 
49480
 
 
49481
SWIGINTERN PyObject *_wrap_FileCtrl_SetWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49482
  PyObject *resultobj = 0;
 
49483
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49484
  wxString *arg2 = 0 ;
 
49485
  void *argp1 = 0 ;
 
49486
  int res1 = 0 ;
 
49487
  bool temp2 = false ;
 
49488
  PyObject * obj0 = 0 ;
 
49489
  PyObject * obj1 = 0 ;
 
49490
  char *  kwnames[] = {
 
49491
    (char *) "self",(char *) "wildCard", NULL 
 
49492
  };
 
49493
  
 
49494
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileCtrl_SetWildcard",kwnames,&obj0,&obj1)) SWIG_fail;
 
49495
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49496
  if (!SWIG_IsOK(res1)) {
 
49497
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_SetWildcard" "', expected argument " "1"" of type '" "wxFileCtrl *""'"); 
 
49498
  }
 
49499
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49500
  {
 
49501
    arg2 = wxString_in_helper(obj1);
 
49502
    if (arg2 == NULL) SWIG_fail;
 
49503
    temp2 = true;
 
49504
  }
 
49505
  {
 
49506
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49507
    (arg1)->SetWildcard((wxString const &)*arg2);
 
49508
    wxPyEndAllowThreads(__tstate);
 
49509
    if (PyErr_Occurred()) SWIG_fail;
 
49510
  }
 
49511
  resultobj = SWIG_Py_Void();
 
49512
  {
 
49513
    if (temp2)
 
49514
    delete arg2;
 
49515
  }
 
49516
  return resultobj;
 
49517
fail:
 
49518
  {
 
49519
    if (temp2)
 
49520
    delete arg2;
 
49521
  }
 
49522
  return NULL;
 
49523
}
 
49524
 
 
49525
 
 
49526
SWIGINTERN PyObject *_wrap_FileCtrl_SetFilterIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49527
  PyObject *resultobj = 0;
 
49528
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49529
  int arg2 ;
 
49530
  void *argp1 = 0 ;
 
49531
  int res1 = 0 ;
 
49532
  int val2 ;
 
49533
  int ecode2 = 0 ;
 
49534
  PyObject * obj0 = 0 ;
 
49535
  PyObject * obj1 = 0 ;
 
49536
  char *  kwnames[] = {
 
49537
    (char *) "self",(char *) "filterindex", NULL 
 
49538
  };
 
49539
  
 
49540
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileCtrl_SetFilterIndex",kwnames,&obj0,&obj1)) SWIG_fail;
 
49541
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49542
  if (!SWIG_IsOK(res1)) {
 
49543
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_SetFilterIndex" "', expected argument " "1"" of type '" "wxFileCtrl *""'"); 
 
49544
  }
 
49545
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49546
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
49547
  if (!SWIG_IsOK(ecode2)) {
 
49548
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileCtrl_SetFilterIndex" "', expected argument " "2"" of type '" "int""'");
 
49549
  } 
 
49550
  arg2 = static_cast< int >(val2);
 
49551
  {
 
49552
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49553
    (arg1)->SetFilterIndex(arg2);
 
49554
    wxPyEndAllowThreads(__tstate);
 
49555
    if (PyErr_Occurred()) SWIG_fail;
 
49556
  }
 
49557
  resultobj = SWIG_Py_Void();
 
49558
  return resultobj;
 
49559
fail:
 
49560
  return NULL;
 
49561
}
 
49562
 
 
49563
 
 
49564
SWIGINTERN PyObject *_wrap_FileCtrl_SetDirectory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49565
  PyObject *resultobj = 0;
 
49566
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49567
  wxString *arg2 = 0 ;
 
49568
  bool result;
 
49569
  void *argp1 = 0 ;
 
49570
  int res1 = 0 ;
 
49571
  bool temp2 = false ;
 
49572
  PyObject * obj0 = 0 ;
 
49573
  PyObject * obj1 = 0 ;
 
49574
  char *  kwnames[] = {
 
49575
    (char *) "self",(char *) "dir", NULL 
 
49576
  };
 
49577
  
 
49578
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileCtrl_SetDirectory",kwnames,&obj0,&obj1)) SWIG_fail;
 
49579
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49580
  if (!SWIG_IsOK(res1)) {
 
49581
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_SetDirectory" "', expected argument " "1"" of type '" "wxFileCtrl *""'"); 
 
49582
  }
 
49583
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49584
  {
 
49585
    arg2 = wxString_in_helper(obj1);
 
49586
    if (arg2 == NULL) SWIG_fail;
 
49587
    temp2 = true;
 
49588
  }
 
49589
  {
 
49590
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49591
    result = (bool)(arg1)->SetDirectory((wxString const &)*arg2);
 
49592
    wxPyEndAllowThreads(__tstate);
 
49593
    if (PyErr_Occurred()) SWIG_fail;
 
49594
  }
 
49595
  {
 
49596
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
49597
  }
 
49598
  {
 
49599
    if (temp2)
 
49600
    delete arg2;
 
49601
  }
 
49602
  return resultobj;
 
49603
fail:
 
49604
  {
 
49605
    if (temp2)
 
49606
    delete arg2;
 
49607
  }
 
49608
  return NULL;
 
49609
}
 
49610
 
 
49611
 
 
49612
SWIGINTERN PyObject *_wrap_FileCtrl_SetFilename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49613
  PyObject *resultobj = 0;
 
49614
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49615
  wxString *arg2 = 0 ;
 
49616
  bool result;
 
49617
  void *argp1 = 0 ;
 
49618
  int res1 = 0 ;
 
49619
  bool temp2 = false ;
 
49620
  PyObject * obj0 = 0 ;
 
49621
  PyObject * obj1 = 0 ;
 
49622
  char *  kwnames[] = {
 
49623
    (char *) "self",(char *) "name", NULL 
 
49624
  };
 
49625
  
 
49626
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileCtrl_SetFilename",kwnames,&obj0,&obj1)) SWIG_fail;
 
49627
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49628
  if (!SWIG_IsOK(res1)) {
 
49629
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_SetFilename" "', expected argument " "1"" of type '" "wxFileCtrl *""'"); 
 
49630
  }
 
49631
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49632
  {
 
49633
    arg2 = wxString_in_helper(obj1);
 
49634
    if (arg2 == NULL) SWIG_fail;
 
49635
    temp2 = true;
 
49636
  }
 
49637
  {
 
49638
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49639
    result = (bool)(arg1)->SetFilename((wxString const &)*arg2);
 
49640
    wxPyEndAllowThreads(__tstate);
 
49641
    if (PyErr_Occurred()) SWIG_fail;
 
49642
  }
 
49643
  {
 
49644
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
49645
  }
 
49646
  {
 
49647
    if (temp2)
 
49648
    delete arg2;
 
49649
  }
 
49650
  return resultobj;
 
49651
fail:
 
49652
  {
 
49653
    if (temp2)
 
49654
    delete arg2;
 
49655
  }
 
49656
  return NULL;
 
49657
}
 
49658
 
 
49659
 
 
49660
SWIGINTERN PyObject *_wrap_FileCtrl_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49661
  PyObject *resultobj = 0;
 
49662
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49663
  wxString *arg2 = 0 ;
 
49664
  bool result;
 
49665
  void *argp1 = 0 ;
 
49666
  int res1 = 0 ;
 
49667
  bool temp2 = false ;
 
49668
  PyObject * obj0 = 0 ;
 
49669
  PyObject * obj1 = 0 ;
 
49670
  char *  kwnames[] = {
 
49671
    (char *) "self",(char *) "path", NULL 
 
49672
  };
 
49673
  
 
49674
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileCtrl_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
 
49675
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49676
  if (!SWIG_IsOK(res1)) {
 
49677
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_SetPath" "', expected argument " "1"" of type '" "wxFileCtrl *""'"); 
 
49678
  }
 
49679
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49680
  {
 
49681
    arg2 = wxString_in_helper(obj1);
 
49682
    if (arg2 == NULL) SWIG_fail;
 
49683
    temp2 = true;
 
49684
  }
 
49685
  {
 
49686
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49687
    result = (bool)(arg1)->SetPath((wxString const &)*arg2);
 
49688
    wxPyEndAllowThreads(__tstate);
 
49689
    if (PyErr_Occurred()) SWIG_fail;
 
49690
  }
 
49691
  {
 
49692
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
49693
  }
 
49694
  {
 
49695
    if (temp2)
 
49696
    delete arg2;
 
49697
  }
 
49698
  return resultobj;
 
49699
fail:
 
49700
  {
 
49701
    if (temp2)
 
49702
    delete arg2;
 
49703
  }
 
49704
  return NULL;
 
49705
}
 
49706
 
 
49707
 
 
49708
SWIGINTERN PyObject *_wrap_FileCtrl_GetFilename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49709
  PyObject *resultobj = 0;
 
49710
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49711
  wxString result;
 
49712
  void *argp1 = 0 ;
 
49713
  int res1 = 0 ;
 
49714
  PyObject *swig_obj[1] ;
 
49715
  
 
49716
  if (!args) SWIG_fail;
 
49717
  swig_obj[0] = args;
 
49718
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49719
  if (!SWIG_IsOK(res1)) {
 
49720
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_GetFilename" "', expected argument " "1"" of type '" "wxFileCtrl const *""'"); 
 
49721
  }
 
49722
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49723
  {
 
49724
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49725
    result = ((wxFileCtrl const *)arg1)->GetFilename();
 
49726
    wxPyEndAllowThreads(__tstate);
 
49727
    if (PyErr_Occurred()) SWIG_fail;
 
49728
  }
 
49729
  {
 
49730
#if wxUSE_UNICODE
 
49731
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
49732
#else
 
49733
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
49734
#endif
 
49735
  }
 
49736
  return resultobj;
 
49737
fail:
 
49738
  return NULL;
 
49739
}
 
49740
 
 
49741
 
 
49742
SWIGINTERN PyObject *_wrap_FileCtrl_GetDirectory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49743
  PyObject *resultobj = 0;
 
49744
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49745
  wxString result;
 
49746
  void *argp1 = 0 ;
 
49747
  int res1 = 0 ;
 
49748
  PyObject *swig_obj[1] ;
 
49749
  
 
49750
  if (!args) SWIG_fail;
 
49751
  swig_obj[0] = args;
 
49752
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49753
  if (!SWIG_IsOK(res1)) {
 
49754
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_GetDirectory" "', expected argument " "1"" of type '" "wxFileCtrl const *""'"); 
 
49755
  }
 
49756
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49757
  {
 
49758
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49759
    result = ((wxFileCtrl const *)arg1)->GetDirectory();
 
49760
    wxPyEndAllowThreads(__tstate);
 
49761
    if (PyErr_Occurred()) SWIG_fail;
 
49762
  }
 
49763
  {
 
49764
#if wxUSE_UNICODE
 
49765
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
49766
#else
 
49767
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
49768
#endif
 
49769
  }
 
49770
  return resultobj;
 
49771
fail:
 
49772
  return NULL;
 
49773
}
 
49774
 
 
49775
 
 
49776
SWIGINTERN PyObject *_wrap_FileCtrl_GetWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49777
  PyObject *resultobj = 0;
 
49778
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49779
  wxString result;
 
49780
  void *argp1 = 0 ;
 
49781
  int res1 = 0 ;
 
49782
  PyObject *swig_obj[1] ;
 
49783
  
 
49784
  if (!args) SWIG_fail;
 
49785
  swig_obj[0] = args;
 
49786
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49787
  if (!SWIG_IsOK(res1)) {
 
49788
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_GetWildcard" "', expected argument " "1"" of type '" "wxFileCtrl const *""'"); 
 
49789
  }
 
49790
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49791
  {
 
49792
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49793
    result = ((wxFileCtrl const *)arg1)->GetWildcard();
 
49794
    wxPyEndAllowThreads(__tstate);
 
49795
    if (PyErr_Occurred()) SWIG_fail;
 
49796
  }
 
49797
  {
 
49798
#if wxUSE_UNICODE
 
49799
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
49800
#else
 
49801
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
49802
#endif
 
49803
  }
 
49804
  return resultobj;
 
49805
fail:
 
49806
  return NULL;
 
49807
}
 
49808
 
 
49809
 
 
49810
SWIGINTERN PyObject *_wrap_FileCtrl_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49811
  PyObject *resultobj = 0;
 
49812
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49813
  wxString result;
 
49814
  void *argp1 = 0 ;
 
49815
  int res1 = 0 ;
 
49816
  PyObject *swig_obj[1] ;
 
49817
  
 
49818
  if (!args) SWIG_fail;
 
49819
  swig_obj[0] = args;
 
49820
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49821
  if (!SWIG_IsOK(res1)) {
 
49822
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_GetPath" "', expected argument " "1"" of type '" "wxFileCtrl const *""'"); 
 
49823
  }
 
49824
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49825
  {
 
49826
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49827
    result = ((wxFileCtrl const *)arg1)->GetPath();
 
49828
    wxPyEndAllowThreads(__tstate);
 
49829
    if (PyErr_Occurred()) SWIG_fail;
 
49830
  }
 
49831
  {
 
49832
#if wxUSE_UNICODE
 
49833
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
49834
#else
 
49835
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
49836
#endif
 
49837
  }
 
49838
  return resultobj;
 
49839
fail:
 
49840
  return NULL;
 
49841
}
 
49842
 
 
49843
 
 
49844
SWIGINTERN PyObject *_wrap_FileCtrl_GetFilterIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49845
  PyObject *resultobj = 0;
 
49846
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49847
  int result;
 
49848
  void *argp1 = 0 ;
 
49849
  int res1 = 0 ;
 
49850
  PyObject *swig_obj[1] ;
 
49851
  
 
49852
  if (!args) SWIG_fail;
 
49853
  swig_obj[0] = args;
 
49854
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49855
  if (!SWIG_IsOK(res1)) {
 
49856
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_GetFilterIndex" "', expected argument " "1"" of type '" "wxFileCtrl const *""'"); 
 
49857
  }
 
49858
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49859
  {
 
49860
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49861
    result = (int)((wxFileCtrl const *)arg1)->GetFilterIndex();
 
49862
    wxPyEndAllowThreads(__tstate);
 
49863
    if (PyErr_Occurred()) SWIG_fail;
 
49864
  }
 
49865
  resultobj = SWIG_From_int(static_cast< int >(result));
 
49866
  return resultobj;
 
49867
fail:
 
49868
  return NULL;
 
49869
}
 
49870
 
 
49871
 
 
49872
SWIGINTERN PyObject *_wrap_FileCtrl_GetPaths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49873
  PyObject *resultobj = 0;
 
49874
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49875
  wxArrayString result;
 
49876
  void *argp1 = 0 ;
 
49877
  int res1 = 0 ;
 
49878
  PyObject *swig_obj[1] ;
 
49879
  
 
49880
  if (!args) SWIG_fail;
 
49881
  swig_obj[0] = args;
 
49882
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49883
  if (!SWIG_IsOK(res1)) {
 
49884
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_GetPaths" "', expected argument " "1"" of type '" "wxFileCtrl *""'"); 
 
49885
  }
 
49886
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49887
  {
 
49888
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49889
    result = wxFileCtrl_GetPaths(arg1);
 
49890
    wxPyEndAllowThreads(__tstate);
 
49891
    if (PyErr_Occurred()) SWIG_fail;
 
49892
  }
 
49893
  {
 
49894
    resultobj = wxArrayString2PyList_helper(result);
 
49895
  }
 
49896
  return resultobj;
 
49897
fail:
 
49898
  return NULL;
 
49899
}
 
49900
 
 
49901
 
 
49902
SWIGINTERN PyObject *_wrap_FileCtrl_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49903
  PyObject *resultobj = 0;
 
49904
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49905
  wxArrayString result;
 
49906
  void *argp1 = 0 ;
 
49907
  int res1 = 0 ;
 
49908
  PyObject *swig_obj[1] ;
 
49909
  
 
49910
  if (!args) SWIG_fail;
 
49911
  swig_obj[0] = args;
 
49912
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49913
  if (!SWIG_IsOK(res1)) {
 
49914
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_GetFilenames" "', expected argument " "1"" of type '" "wxFileCtrl *""'"); 
 
49915
  }
 
49916
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49917
  {
 
49918
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49919
    result = wxFileCtrl_GetFilenames(arg1);
 
49920
    wxPyEndAllowThreads(__tstate);
 
49921
    if (PyErr_Occurred()) SWIG_fail;
 
49922
  }
 
49923
  {
 
49924
    resultobj = wxArrayString2PyList_helper(result);
 
49925
  }
 
49926
  return resultobj;
 
49927
fail:
 
49928
  return NULL;
 
49929
}
 
49930
 
 
49931
 
 
49932
SWIGINTERN PyObject *_wrap_FileCtrl_HasMultipleFileSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
49933
  PyObject *resultobj = 0;
 
49934
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49935
  bool result;
 
49936
  void *argp1 = 0 ;
 
49937
  int res1 = 0 ;
 
49938
  PyObject *swig_obj[1] ;
 
49939
  
 
49940
  if (!args) SWIG_fail;
 
49941
  swig_obj[0] = args;
 
49942
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49943
  if (!SWIG_IsOK(res1)) {
 
49944
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_HasMultipleFileSelection" "', expected argument " "1"" of type '" "wxFileCtrl const *""'"); 
 
49945
  }
 
49946
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49947
  {
 
49948
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49949
    result = (bool)((wxFileCtrl const *)arg1)->HasMultipleFileSelection();
 
49950
    wxPyEndAllowThreads(__tstate);
 
49951
    if (PyErr_Occurred()) SWIG_fail;
 
49952
  }
 
49953
  {
 
49954
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
49955
  }
 
49956
  return resultobj;
 
49957
fail:
 
49958
  return NULL;
 
49959
}
 
49960
 
 
49961
 
 
49962
SWIGINTERN PyObject *_wrap_FileCtrl_ShowHidden(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
49963
  PyObject *resultobj = 0;
 
49964
  wxFileCtrl *arg1 = (wxFileCtrl *) 0 ;
 
49965
  bool arg2 ;
 
49966
  void *argp1 = 0 ;
 
49967
  int res1 = 0 ;
 
49968
  bool val2 ;
 
49969
  int ecode2 = 0 ;
 
49970
  PyObject * obj0 = 0 ;
 
49971
  PyObject * obj1 = 0 ;
 
49972
  char *  kwnames[] = {
 
49973
    (char *) "self",(char *) "show", NULL 
 
49974
  };
 
49975
  
 
49976
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileCtrl_ShowHidden",kwnames,&obj0,&obj1)) SWIG_fail;
 
49977
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileCtrl, 0 |  0 );
 
49978
  if (!SWIG_IsOK(res1)) {
 
49979
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrl_ShowHidden" "', expected argument " "1"" of type '" "wxFileCtrl *""'"); 
 
49980
  }
 
49981
  arg1 = reinterpret_cast< wxFileCtrl * >(argp1);
 
49982
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
 
49983
  if (!SWIG_IsOK(ecode2)) {
 
49984
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileCtrl_ShowHidden" "', expected argument " "2"" of type '" "bool""'");
 
49985
  } 
 
49986
  arg2 = static_cast< bool >(val2);
 
49987
  {
 
49988
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
49989
    (arg1)->ShowHidden(arg2);
 
49990
    wxPyEndAllowThreads(__tstate);
 
49991
    if (PyErr_Occurred()) SWIG_fail;
 
49992
  }
 
49993
  resultobj = SWIG_Py_Void();
 
49994
  return resultobj;
 
49995
fail:
 
49996
  return NULL;
 
49997
}
 
49998
 
 
49999
 
 
50000
SWIGINTERN PyObject *FileCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50001
  PyObject *obj;
 
50002
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
50003
  SWIG_TypeNewClientData(SWIGTYPE_p_wxFileCtrl, SWIG_NewClientData(obj));
 
50004
  return SWIG_Py_Void();
 
50005
}
 
50006
 
 
50007
SWIGINTERN PyObject *FileCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50008
  return SWIG_Python_InitShadowInstance(args);
 
50009
}
 
50010
 
 
50011
SWIGINTERN PyObject *_wrap_new_FileCtrlEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50012
  PyObject *resultobj = 0;
 
50013
  wxEventType arg1 ;
 
50014
  wxObject *arg2 = (wxObject *) 0 ;
 
50015
  int arg3 ;
 
50016
  wxFileCtrlEvent *result = 0 ;
 
50017
  int val1 ;
 
50018
  int ecode1 = 0 ;
 
50019
  void *argp2 = 0 ;
 
50020
  int res2 = 0 ;
 
50021
  int val3 ;
 
50022
  int ecode3 = 0 ;
 
50023
  PyObject * obj0 = 0 ;
 
50024
  PyObject * obj1 = 0 ;
 
50025
  PyObject * obj2 = 0 ;
 
50026
  char *  kwnames[] = {
 
50027
    (char *) "type",(char *) "evtObject",(char *) "id", NULL 
 
50028
  };
 
50029
  
 
50030
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_FileCtrlEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
50031
  ecode1 = SWIG_AsVal_int(obj0, &val1);
 
50032
  if (!SWIG_IsOK(ecode1)) {
 
50033
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileCtrlEvent" "', expected argument " "1"" of type '" "wxEventType""'");
 
50034
  } 
 
50035
  arg1 = static_cast< wxEventType >(val1);
 
50036
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 |  0 );
 
50037
  if (!SWIG_IsOK(res2)) {
 
50038
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FileCtrlEvent" "', expected argument " "2"" of type '" "wxObject *""'"); 
 
50039
  }
 
50040
  arg2 = reinterpret_cast< wxObject * >(argp2);
 
50041
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
50042
  if (!SWIG_IsOK(ecode3)) {
 
50043
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FileCtrlEvent" "', expected argument " "3"" of type '" "int""'");
 
50044
  } 
 
50045
  arg3 = static_cast< int >(val3);
 
50046
  {
 
50047
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50048
    result = (wxFileCtrlEvent *)new wxFileCtrlEvent(arg1,arg2,arg3);
 
50049
    wxPyEndAllowThreads(__tstate);
 
50050
    if (PyErr_Occurred()) SWIG_fail;
 
50051
  }
 
50052
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileCtrlEvent, SWIG_POINTER_NEW |  0 );
 
50053
  return resultobj;
 
50054
fail:
 
50055
  return NULL;
 
50056
}
 
50057
 
 
50058
 
 
50059
SWIGINTERN PyObject *_wrap_FileCtrlEvent_SetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50060
  PyObject *resultobj = 0;
 
50061
  wxFileCtrlEvent *arg1 = (wxFileCtrlEvent *) 0 ;
 
50062
  wxArrayString *arg2 = 0 ;
 
50063
  void *argp1 = 0 ;
 
50064
  int res1 = 0 ;
 
50065
  bool temp2 = false ;
 
50066
  PyObject * obj0 = 0 ;
 
50067
  PyObject * obj1 = 0 ;
 
50068
  char *  kwnames[] = {
 
50069
    (char *) "self",(char *) "files", NULL 
 
50070
  };
 
50071
  
 
50072
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileCtrlEvent_SetFiles",kwnames,&obj0,&obj1)) SWIG_fail;
 
50073
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileCtrlEvent, 0 |  0 );
 
50074
  if (!SWIG_IsOK(res1)) {
 
50075
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrlEvent_SetFiles" "', expected argument " "1"" of type '" "wxFileCtrlEvent *""'"); 
 
50076
  }
 
50077
  arg1 = reinterpret_cast< wxFileCtrlEvent * >(argp1);
 
50078
  {
 
50079
    if (! PySequence_Check(obj1)) {
 
50080
      PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
 
50081
      SWIG_fail;
 
50082
    }
 
50083
    arg2 = new wxArrayString;
 
50084
    temp2 = true;
 
50085
    int i, len=PySequence_Length(obj1);
 
50086
    for (i=0; i<len; i++) {
 
50087
      PyObject* item = PySequence_GetItem(obj1, i);
 
50088
      wxString* s = wxString_in_helper(item);
 
50089
      if (PyErr_Occurred())  SWIG_fail;
 
50090
      arg2->Add(*s);
 
50091
      delete s;
 
50092
      Py_DECREF(item);
 
50093
    }
 
50094
  }
 
50095
  {
 
50096
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50097
    (arg1)->SetFiles((wxArrayString const &)*arg2);
 
50098
    wxPyEndAllowThreads(__tstate);
 
50099
    if (PyErr_Occurred()) SWIG_fail;
 
50100
  }
 
50101
  resultobj = SWIG_Py_Void();
 
50102
  {
 
50103
    if (temp2) delete arg2;
 
50104
  }
 
50105
  return resultobj;
 
50106
fail:
 
50107
  {
 
50108
    if (temp2) delete arg2;
 
50109
  }
 
50110
  return NULL;
 
50111
}
 
50112
 
 
50113
 
 
50114
SWIGINTERN PyObject *_wrap_FileCtrlEvent_SetDirectory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50115
  PyObject *resultobj = 0;
 
50116
  wxFileCtrlEvent *arg1 = (wxFileCtrlEvent *) 0 ;
 
50117
  wxString *arg2 = 0 ;
 
50118
  void *argp1 = 0 ;
 
50119
  int res1 = 0 ;
 
50120
  bool temp2 = false ;
 
50121
  PyObject * obj0 = 0 ;
 
50122
  PyObject * obj1 = 0 ;
 
50123
  char *  kwnames[] = {
 
50124
    (char *) "self",(char *) "directory", NULL 
 
50125
  };
 
50126
  
 
50127
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileCtrlEvent_SetDirectory",kwnames,&obj0,&obj1)) SWIG_fail;
 
50128
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileCtrlEvent, 0 |  0 );
 
50129
  if (!SWIG_IsOK(res1)) {
 
50130
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrlEvent_SetDirectory" "', expected argument " "1"" of type '" "wxFileCtrlEvent *""'"); 
 
50131
  }
 
50132
  arg1 = reinterpret_cast< wxFileCtrlEvent * >(argp1);
 
50133
  {
 
50134
    arg2 = wxString_in_helper(obj1);
 
50135
    if (arg2 == NULL) SWIG_fail;
 
50136
    temp2 = true;
 
50137
  }
 
50138
  {
 
50139
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50140
    (arg1)->SetDirectory((wxString const &)*arg2);
 
50141
    wxPyEndAllowThreads(__tstate);
 
50142
    if (PyErr_Occurred()) SWIG_fail;
 
50143
  }
 
50144
  resultobj = SWIG_Py_Void();
 
50145
  {
 
50146
    if (temp2)
 
50147
    delete arg2;
 
50148
  }
 
50149
  return resultobj;
 
50150
fail:
 
50151
  {
 
50152
    if (temp2)
 
50153
    delete arg2;
 
50154
  }
 
50155
  return NULL;
 
50156
}
 
50157
 
 
50158
 
 
50159
SWIGINTERN PyObject *_wrap_FileCtrlEvent_SetFilterIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50160
  PyObject *resultobj = 0;
 
50161
  wxFileCtrlEvent *arg1 = (wxFileCtrlEvent *) 0 ;
 
50162
  int arg2 ;
 
50163
  void *argp1 = 0 ;
 
50164
  int res1 = 0 ;
 
50165
  int val2 ;
 
50166
  int ecode2 = 0 ;
 
50167
  PyObject * obj0 = 0 ;
 
50168
  PyObject * obj1 = 0 ;
 
50169
  char *  kwnames[] = {
 
50170
    (char *) "self",(char *) "filterIndex", NULL 
 
50171
  };
 
50172
  
 
50173
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileCtrlEvent_SetFilterIndex",kwnames,&obj0,&obj1)) SWIG_fail;
 
50174
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileCtrlEvent, 0 |  0 );
 
50175
  if (!SWIG_IsOK(res1)) {
 
50176
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrlEvent_SetFilterIndex" "', expected argument " "1"" of type '" "wxFileCtrlEvent *""'"); 
 
50177
  }
 
50178
  arg1 = reinterpret_cast< wxFileCtrlEvent * >(argp1);
 
50179
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
50180
  if (!SWIG_IsOK(ecode2)) {
 
50181
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileCtrlEvent_SetFilterIndex" "', expected argument " "2"" of type '" "int""'");
 
50182
  } 
 
50183
  arg2 = static_cast< int >(val2);
 
50184
  {
 
50185
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50186
    (arg1)->SetFilterIndex(arg2);
 
50187
    wxPyEndAllowThreads(__tstate);
 
50188
    if (PyErr_Occurred()) SWIG_fail;
 
50189
  }
 
50190
  resultobj = SWIG_Py_Void();
 
50191
  return resultobj;
 
50192
fail:
 
50193
  return NULL;
 
50194
}
 
50195
 
 
50196
 
 
50197
SWIGINTERN PyObject *_wrap_FileCtrlEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50198
  PyObject *resultobj = 0;
 
50199
  wxFileCtrlEvent *arg1 = (wxFileCtrlEvent *) 0 ;
 
50200
  wxArrayString result;
 
50201
  void *argp1 = 0 ;
 
50202
  int res1 = 0 ;
 
50203
  PyObject *swig_obj[1] ;
 
50204
  
 
50205
  if (!args) SWIG_fail;
 
50206
  swig_obj[0] = args;
 
50207
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrlEvent, 0 |  0 );
 
50208
  if (!SWIG_IsOK(res1)) {
 
50209
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrlEvent_GetFiles" "', expected argument " "1"" of type '" "wxFileCtrlEvent const *""'"); 
 
50210
  }
 
50211
  arg1 = reinterpret_cast< wxFileCtrlEvent * >(argp1);
 
50212
  {
 
50213
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50214
    result = ((wxFileCtrlEvent const *)arg1)->GetFiles();
 
50215
    wxPyEndAllowThreads(__tstate);
 
50216
    if (PyErr_Occurred()) SWIG_fail;
 
50217
  }
 
50218
  {
 
50219
    resultobj = wxArrayString2PyList_helper(result);
 
50220
  }
 
50221
  return resultobj;
 
50222
fail:
 
50223
  return NULL;
 
50224
}
 
50225
 
 
50226
 
 
50227
SWIGINTERN PyObject *_wrap_FileCtrlEvent_GetDirectory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50228
  PyObject *resultobj = 0;
 
50229
  wxFileCtrlEvent *arg1 = (wxFileCtrlEvent *) 0 ;
 
50230
  wxString result;
 
50231
  void *argp1 = 0 ;
 
50232
  int res1 = 0 ;
 
50233
  PyObject *swig_obj[1] ;
 
50234
  
 
50235
  if (!args) SWIG_fail;
 
50236
  swig_obj[0] = args;
 
50237
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrlEvent, 0 |  0 );
 
50238
  if (!SWIG_IsOK(res1)) {
 
50239
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrlEvent_GetDirectory" "', expected argument " "1"" of type '" "wxFileCtrlEvent const *""'"); 
 
50240
  }
 
50241
  arg1 = reinterpret_cast< wxFileCtrlEvent * >(argp1);
 
50242
  {
 
50243
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50244
    result = ((wxFileCtrlEvent const *)arg1)->GetDirectory();
 
50245
    wxPyEndAllowThreads(__tstate);
 
50246
    if (PyErr_Occurred()) SWIG_fail;
 
50247
  }
 
50248
  {
 
50249
#if wxUSE_UNICODE
 
50250
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
50251
#else
 
50252
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
50253
#endif
 
50254
  }
 
50255
  return resultobj;
 
50256
fail:
 
50257
  return NULL;
 
50258
}
 
50259
 
 
50260
 
 
50261
SWIGINTERN PyObject *_wrap_FileCtrlEvent_GetFilterIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50262
  PyObject *resultobj = 0;
 
50263
  wxFileCtrlEvent *arg1 = (wxFileCtrlEvent *) 0 ;
 
50264
  int result;
 
50265
  void *argp1 = 0 ;
 
50266
  int res1 = 0 ;
 
50267
  PyObject *swig_obj[1] ;
 
50268
  
 
50269
  if (!args) SWIG_fail;
 
50270
  swig_obj[0] = args;
 
50271
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrlEvent, 0 |  0 );
 
50272
  if (!SWIG_IsOK(res1)) {
 
50273
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrlEvent_GetFilterIndex" "', expected argument " "1"" of type '" "wxFileCtrlEvent const *""'"); 
 
50274
  }
 
50275
  arg1 = reinterpret_cast< wxFileCtrlEvent * >(argp1);
 
50276
  {
 
50277
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50278
    result = (int)((wxFileCtrlEvent const *)arg1)->GetFilterIndex();
 
50279
    wxPyEndAllowThreads(__tstate);
 
50280
    if (PyErr_Occurred()) SWIG_fail;
 
50281
  }
 
50282
  resultobj = SWIG_From_int(static_cast< int >(result));
 
50283
  return resultobj;
 
50284
fail:
 
50285
  return NULL;
 
50286
}
 
50287
 
 
50288
 
 
50289
SWIGINTERN PyObject *_wrap_FileCtrlEvent_GetFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50290
  PyObject *resultobj = 0;
 
50291
  wxFileCtrlEvent *arg1 = (wxFileCtrlEvent *) 0 ;
 
50292
  wxString result;
 
50293
  void *argp1 = 0 ;
 
50294
  int res1 = 0 ;
 
50295
  PyObject *swig_obj[1] ;
 
50296
  
 
50297
  if (!args) SWIG_fail;
 
50298
  swig_obj[0] = args;
 
50299
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileCtrlEvent, 0 |  0 );
 
50300
  if (!SWIG_IsOK(res1)) {
 
50301
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileCtrlEvent_GetFile" "', expected argument " "1"" of type '" "wxFileCtrlEvent const *""'"); 
 
50302
  }
 
50303
  arg1 = reinterpret_cast< wxFileCtrlEvent * >(argp1);
 
50304
  {
 
50305
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50306
    result = ((wxFileCtrlEvent const *)arg1)->GetFile();
 
50307
    wxPyEndAllowThreads(__tstate);
 
50308
    if (PyErr_Occurred()) SWIG_fail;
 
50309
  }
 
50310
  {
 
50311
#if wxUSE_UNICODE
 
50312
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
50313
#else
 
50314
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
50315
#endif
 
50316
  }
 
50317
  return resultobj;
 
50318
fail:
 
50319
  return NULL;
 
50320
}
 
50321
 
 
50322
 
 
50323
SWIGINTERN PyObject *FileCtrlEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50324
  PyObject *obj;
 
50325
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
50326
  SWIG_TypeNewClientData(SWIGTYPE_p_wxFileCtrlEvent, SWIG_NewClientData(obj));
 
50327
  return SWIG_Py_Void();
 
50328
}
 
50329
 
 
50330
SWIGINTERN PyObject *FileCtrlEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50331
  return SWIG_Python_InitShadowInstance(args);
 
50332
}
 
50333
 
 
50334
SWIGINTERN PyObject *_wrap_new_InfoBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50335
  PyObject *resultobj = 0;
 
50336
  wxWindow *arg1 = (wxWindow *) 0 ;
 
50337
  int arg2 = (int) wxID_ANY ;
 
50338
  wxInfoBar *result = 0 ;
 
50339
  void *argp1 = 0 ;
 
50340
  int res1 = 0 ;
 
50341
  int val2 ;
 
50342
  int ecode2 = 0 ;
 
50343
  PyObject * obj0 = 0 ;
 
50344
  PyObject * obj1 = 0 ;
 
50345
  char *  kwnames[] = {
 
50346
    (char *) "parent",(char *) "winid", NULL 
 
50347
  };
 
50348
  
 
50349
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_InfoBar",kwnames,&obj0,&obj1)) SWIG_fail;
 
50350
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
50351
  if (!SWIG_IsOK(res1)) {
 
50352
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InfoBar" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
50353
  }
 
50354
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
50355
  if (obj1) {
 
50356
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
50357
    if (!SWIG_IsOK(ecode2)) {
 
50358
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InfoBar" "', expected argument " "2"" of type '" "int""'");
 
50359
    } 
 
50360
    arg2 = static_cast< int >(val2);
 
50361
  }
 
50362
  {
 
50363
    if (!wxPyCheckForApp()) SWIG_fail;
 
50364
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50365
    result = (wxInfoBar *)new wxInfoBar(arg1,arg2);
 
50366
    wxPyEndAllowThreads(__tstate);
 
50367
    if (PyErr_Occurred()) SWIG_fail;
 
50368
  }
 
50369
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInfoBar, SWIG_POINTER_NEW |  0 );
 
50370
  return resultobj;
 
50371
fail:
 
50372
  return NULL;
 
50373
}
 
50374
 
 
50375
 
 
50376
SWIGINTERN PyObject *_wrap_new_PreInfoBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50377
  PyObject *resultobj = 0;
 
50378
  wxInfoBar *result = 0 ;
 
50379
  
 
50380
  if (!SWIG_Python_UnpackTuple(args,"new_PreInfoBar",0,0,0)) SWIG_fail;
 
50381
  {
 
50382
    if (!wxPyCheckForApp()) SWIG_fail;
 
50383
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50384
    result = (wxInfoBar *)new wxInfoBar();
 
50385
    wxPyEndAllowThreads(__tstate);
 
50386
    if (PyErr_Occurred()) SWIG_fail;
 
50387
  }
 
50388
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInfoBar, SWIG_POINTER_OWN |  0 );
 
50389
  return resultobj;
 
50390
fail:
 
50391
  return NULL;
 
50392
}
 
50393
 
 
50394
 
 
50395
SWIGINTERN PyObject *_wrap_InfoBar_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50396
  PyObject *resultobj = 0;
 
50397
  wxInfoBar *arg1 = (wxInfoBar *) 0 ;
 
50398
  wxWindow *arg2 = (wxWindow *) 0 ;
 
50399
  int arg3 = (int) wxID_ANY ;
 
50400
  bool result;
 
50401
  void *argp1 = 0 ;
 
50402
  int res1 = 0 ;
 
50403
  void *argp2 = 0 ;
 
50404
  int res2 = 0 ;
 
50405
  int val3 ;
 
50406
  int ecode3 = 0 ;
 
50407
  PyObject * obj0 = 0 ;
 
50408
  PyObject * obj1 = 0 ;
 
50409
  PyObject * obj2 = 0 ;
 
50410
  char *  kwnames[] = {
 
50411
    (char *) "self",(char *) "parent",(char *) "winid", NULL 
 
50412
  };
 
50413
  
 
50414
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InfoBar_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
50415
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInfoBar, 0 |  0 );
 
50416
  if (!SWIG_IsOK(res1)) {
 
50417
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBar_Create" "', expected argument " "1"" of type '" "wxInfoBar *""'"); 
 
50418
  }
 
50419
  arg1 = reinterpret_cast< wxInfoBar * >(argp1);
 
50420
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
50421
  if (!SWIG_IsOK(res2)) {
 
50422
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InfoBar_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
50423
  }
 
50424
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
50425
  if (obj2) {
 
50426
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
50427
    if (!SWIG_IsOK(ecode3)) {
 
50428
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InfoBar_Create" "', expected argument " "3"" of type '" "int""'");
 
50429
    } 
 
50430
    arg3 = static_cast< int >(val3);
 
50431
  }
 
50432
  {
 
50433
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50434
    result = (bool)(arg1)->Create(arg2,arg3);
 
50435
    wxPyEndAllowThreads(__tstate);
 
50436
    if (PyErr_Occurred()) SWIG_fail;
 
50437
  }
 
50438
  {
 
50439
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
50440
  }
 
50441
  return resultobj;
 
50442
fail:
 
50443
  return NULL;
 
50444
}
 
50445
 
 
50446
 
 
50447
SWIGINTERN PyObject *_wrap_InfoBar_ShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50448
  PyObject *resultobj = 0;
 
50449
  wxInfoBar *arg1 = (wxInfoBar *) 0 ;
 
50450
  wxString *arg2 = 0 ;
 
50451
  int arg3 = (int) wxICON_INFORMATION ;
 
50452
  void *argp1 = 0 ;
 
50453
  int res1 = 0 ;
 
50454
  bool temp2 = false ;
 
50455
  int val3 ;
 
50456
  int ecode3 = 0 ;
 
50457
  PyObject * obj0 = 0 ;
 
50458
  PyObject * obj1 = 0 ;
 
50459
  PyObject * obj2 = 0 ;
 
50460
  char *  kwnames[] = {
 
50461
    (char *) "self",(char *) "msg",(char *) "flags", NULL 
 
50462
  };
 
50463
  
 
50464
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InfoBar_ShowMessage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
50465
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInfoBar, 0 |  0 );
 
50466
  if (!SWIG_IsOK(res1)) {
 
50467
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBar_ShowMessage" "', expected argument " "1"" of type '" "wxInfoBar *""'"); 
 
50468
  }
 
50469
  arg1 = reinterpret_cast< wxInfoBar * >(argp1);
 
50470
  {
 
50471
    arg2 = wxString_in_helper(obj1);
 
50472
    if (arg2 == NULL) SWIG_fail;
 
50473
    temp2 = true;
 
50474
  }
 
50475
  if (obj2) {
 
50476
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
50477
    if (!SWIG_IsOK(ecode3)) {
 
50478
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InfoBar_ShowMessage" "', expected argument " "3"" of type '" "int""'");
 
50479
    } 
 
50480
    arg3 = static_cast< int >(val3);
 
50481
  }
 
50482
  {
 
50483
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50484
    (arg1)->ShowMessage((wxString const &)*arg2,arg3);
 
50485
    wxPyEndAllowThreads(__tstate);
 
50486
    if (PyErr_Occurred()) SWIG_fail;
 
50487
  }
 
50488
  resultobj = SWIG_Py_Void();
 
50489
  {
 
50490
    if (temp2)
 
50491
    delete arg2;
 
50492
  }
 
50493
  return resultobj;
 
50494
fail:
 
50495
  {
 
50496
    if (temp2)
 
50497
    delete arg2;
 
50498
  }
 
50499
  return NULL;
 
50500
}
 
50501
 
 
50502
 
 
50503
SWIGINTERN PyObject *_wrap_InfoBar_Dismiss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50504
  PyObject *resultobj = 0;
 
50505
  wxInfoBar *arg1 = (wxInfoBar *) 0 ;
 
50506
  void *argp1 = 0 ;
 
50507
  int res1 = 0 ;
 
50508
  PyObject *swig_obj[1] ;
 
50509
  
 
50510
  if (!args) SWIG_fail;
 
50511
  swig_obj[0] = args;
 
50512
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxInfoBar, 0 |  0 );
 
50513
  if (!SWIG_IsOK(res1)) {
 
50514
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBar_Dismiss" "', expected argument " "1"" of type '" "wxInfoBar *""'"); 
 
50515
  }
 
50516
  arg1 = reinterpret_cast< wxInfoBar * >(argp1);
 
50517
  {
 
50518
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50519
    (arg1)->Dismiss();
 
50520
    wxPyEndAllowThreads(__tstate);
 
50521
    if (PyErr_Occurred()) SWIG_fail;
 
50522
  }
 
50523
  resultobj = SWIG_Py_Void();
 
50524
  return resultobj;
 
50525
fail:
 
50526
  return NULL;
 
50527
}
 
50528
 
 
50529
 
 
50530
SWIGINTERN PyObject *_wrap_InfoBar_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50531
  PyObject *resultobj = 0;
 
50532
  wxInfoBar *arg1 = (wxInfoBar *) 0 ;
 
50533
  int arg2 ;
 
50534
  wxString const &arg3_defvalue = wxEmptyString ;
 
50535
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
50536
  void *argp1 = 0 ;
 
50537
  int res1 = 0 ;
 
50538
  int val2 ;
 
50539
  int ecode2 = 0 ;
 
50540
  bool temp3 = false ;
 
50541
  PyObject * obj0 = 0 ;
 
50542
  PyObject * obj1 = 0 ;
 
50543
  PyObject * obj2 = 0 ;
 
50544
  char *  kwnames[] = {
 
50545
    (char *) "self",(char *) "btnid",(char *) "label", NULL 
 
50546
  };
 
50547
  
 
50548
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InfoBar_AddButton",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
50549
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInfoBar, 0 |  0 );
 
50550
  if (!SWIG_IsOK(res1)) {
 
50551
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBar_AddButton" "', expected argument " "1"" of type '" "wxInfoBar *""'"); 
 
50552
  }
 
50553
  arg1 = reinterpret_cast< wxInfoBar * >(argp1);
 
50554
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
50555
  if (!SWIG_IsOK(ecode2)) {
 
50556
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfoBar_AddButton" "', expected argument " "2"" of type '" "int""'");
 
50557
  } 
 
50558
  arg2 = static_cast< int >(val2);
 
50559
  if (obj2) {
 
50560
    {
 
50561
      arg3 = wxString_in_helper(obj2);
 
50562
      if (arg3 == NULL) SWIG_fail;
 
50563
      temp3 = true;
 
50564
    }
 
50565
  }
 
50566
  {
 
50567
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50568
    (arg1)->AddButton(arg2,(wxString const &)*arg3);
 
50569
    wxPyEndAllowThreads(__tstate);
 
50570
    if (PyErr_Occurred()) SWIG_fail;
 
50571
  }
 
50572
  resultobj = SWIG_Py_Void();
 
50573
  {
 
50574
    if (temp3)
 
50575
    delete arg3;
 
50576
  }
 
50577
  return resultobj;
 
50578
fail:
 
50579
  {
 
50580
    if (temp3)
 
50581
    delete arg3;
 
50582
  }
 
50583
  return NULL;
 
50584
}
 
50585
 
 
50586
 
 
50587
SWIGINTERN PyObject *_wrap_InfoBar_RemoveButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50588
  PyObject *resultobj = 0;
 
50589
  wxInfoBar *arg1 = (wxInfoBar *) 0 ;
 
50590
  int arg2 ;
 
50591
  void *argp1 = 0 ;
 
50592
  int res1 = 0 ;
 
50593
  int val2 ;
 
50594
  int ecode2 = 0 ;
 
50595
  PyObject * obj0 = 0 ;
 
50596
  PyObject * obj1 = 0 ;
 
50597
  char *  kwnames[] = {
 
50598
    (char *) "self",(char *) "btnid", NULL 
 
50599
  };
 
50600
  
 
50601
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InfoBar_RemoveButton",kwnames,&obj0,&obj1)) SWIG_fail;
 
50602
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInfoBar, 0 |  0 );
 
50603
  if (!SWIG_IsOK(res1)) {
 
50604
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBar_RemoveButton" "', expected argument " "1"" of type '" "wxInfoBar *""'"); 
 
50605
  }
 
50606
  arg1 = reinterpret_cast< wxInfoBar * >(argp1);
 
50607
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
50608
  if (!SWIG_IsOK(ecode2)) {
 
50609
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfoBar_RemoveButton" "', expected argument " "2"" of type '" "int""'");
 
50610
  } 
 
50611
  arg2 = static_cast< int >(val2);
 
50612
  {
 
50613
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50614
    (arg1)->RemoveButton(arg2);
 
50615
    wxPyEndAllowThreads(__tstate);
 
50616
    if (PyErr_Occurred()) SWIG_fail;
 
50617
  }
 
50618
  resultobj = SWIG_Py_Void();
 
50619
  return resultobj;
 
50620
fail:
 
50621
  return NULL;
 
50622
}
 
50623
 
 
50624
 
 
50625
SWIGINTERN PyObject *_wrap_InfoBar_SetShowHideEffects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50626
  PyObject *resultobj = 0;
 
50627
  wxInfoBar *arg1 = (wxInfoBar *) 0 ;
 
50628
  wxShowEffect arg2 ;
 
50629
  wxShowEffect arg3 ;
 
50630
  void *argp1 = 0 ;
 
50631
  int res1 = 0 ;
 
50632
  int val2 ;
 
50633
  int ecode2 = 0 ;
 
50634
  int val3 ;
 
50635
  int ecode3 = 0 ;
 
50636
  PyObject * obj0 = 0 ;
 
50637
  PyObject * obj1 = 0 ;
 
50638
  PyObject * obj2 = 0 ;
 
50639
  char *  kwnames[] = {
 
50640
    (char *) "self",(char *) "showEffect",(char *) "hideEffect", NULL 
 
50641
  };
 
50642
  
 
50643
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InfoBar_SetShowHideEffects",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
50644
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInfoBar, 0 |  0 );
 
50645
  if (!SWIG_IsOK(res1)) {
 
50646
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBar_SetShowHideEffects" "', expected argument " "1"" of type '" "wxInfoBar *""'"); 
 
50647
  }
 
50648
  arg1 = reinterpret_cast< wxInfoBar * >(argp1);
 
50649
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
50650
  if (!SWIG_IsOK(ecode2)) {
 
50651
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfoBar_SetShowHideEffects" "', expected argument " "2"" of type '" "wxShowEffect""'");
 
50652
  } 
 
50653
  arg2 = static_cast< wxShowEffect >(val2);
 
50654
  ecode3 = SWIG_AsVal_int(obj2, &val3);
 
50655
  if (!SWIG_IsOK(ecode3)) {
 
50656
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InfoBar_SetShowHideEffects" "', expected argument " "3"" of type '" "wxShowEffect""'");
 
50657
  } 
 
50658
  arg3 = static_cast< wxShowEffect >(val3);
 
50659
  {
 
50660
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50661
    (arg1)->SetShowHideEffects(arg2,arg3);
 
50662
    wxPyEndAllowThreads(__tstate);
 
50663
    if (PyErr_Occurred()) SWIG_fail;
 
50664
  }
 
50665
  resultobj = SWIG_Py_Void();
 
50666
  return resultobj;
 
50667
fail:
 
50668
  return NULL;
 
50669
}
 
50670
 
 
50671
 
 
50672
SWIGINTERN PyObject *_wrap_InfoBar_GetShowEffect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50673
  PyObject *resultobj = 0;
 
50674
  wxInfoBar *arg1 = (wxInfoBar *) 0 ;
 
50675
  wxShowEffect result;
 
50676
  void *argp1 = 0 ;
 
50677
  int res1 = 0 ;
 
50678
  PyObject *swig_obj[1] ;
 
50679
  
 
50680
  if (!args) SWIG_fail;
 
50681
  swig_obj[0] = args;
 
50682
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxInfoBar, 0 |  0 );
 
50683
  if (!SWIG_IsOK(res1)) {
 
50684
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBar_GetShowEffect" "', expected argument " "1"" of type '" "wxInfoBar const *""'"); 
 
50685
  }
 
50686
  arg1 = reinterpret_cast< wxInfoBar * >(argp1);
 
50687
  {
 
50688
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50689
    result = (wxShowEffect)((wxInfoBar const *)arg1)->GetShowEffect();
 
50690
    wxPyEndAllowThreads(__tstate);
 
50691
    if (PyErr_Occurred()) SWIG_fail;
 
50692
  }
 
50693
  resultobj = SWIG_From_int(static_cast< int >(result));
 
50694
  return resultobj;
 
50695
fail:
 
50696
  return NULL;
 
50697
}
 
50698
 
 
50699
 
 
50700
SWIGINTERN PyObject *_wrap_InfoBar_GetHideEffect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50701
  PyObject *resultobj = 0;
 
50702
  wxInfoBar *arg1 = (wxInfoBar *) 0 ;
 
50703
  wxShowEffect result;
 
50704
  void *argp1 = 0 ;
 
50705
  int res1 = 0 ;
 
50706
  PyObject *swig_obj[1] ;
 
50707
  
 
50708
  if (!args) SWIG_fail;
 
50709
  swig_obj[0] = args;
 
50710
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxInfoBar, 0 |  0 );
 
50711
  if (!SWIG_IsOK(res1)) {
 
50712
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBar_GetHideEffect" "', expected argument " "1"" of type '" "wxInfoBar const *""'"); 
 
50713
  }
 
50714
  arg1 = reinterpret_cast< wxInfoBar * >(argp1);
 
50715
  {
 
50716
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50717
    result = (wxShowEffect)((wxInfoBar const *)arg1)->GetHideEffect();
 
50718
    wxPyEndAllowThreads(__tstate);
 
50719
    if (PyErr_Occurred()) SWIG_fail;
 
50720
  }
 
50721
  resultobj = SWIG_From_int(static_cast< int >(result));
 
50722
  return resultobj;
 
50723
fail:
 
50724
  return NULL;
 
50725
}
 
50726
 
 
50727
 
 
50728
SWIGINTERN PyObject *_wrap_InfoBar_SetEffectDuration(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50729
  PyObject *resultobj = 0;
 
50730
  wxInfoBar *arg1 = (wxInfoBar *) 0 ;
 
50731
  int arg2 ;
 
50732
  void *argp1 = 0 ;
 
50733
  int res1 = 0 ;
 
50734
  int val2 ;
 
50735
  int ecode2 = 0 ;
 
50736
  PyObject * obj0 = 0 ;
 
50737
  PyObject * obj1 = 0 ;
 
50738
  char *  kwnames[] = {
 
50739
    (char *) "self",(char *) "duration", NULL 
 
50740
  };
 
50741
  
 
50742
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InfoBar_SetEffectDuration",kwnames,&obj0,&obj1)) SWIG_fail;
 
50743
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInfoBar, 0 |  0 );
 
50744
  if (!SWIG_IsOK(res1)) {
 
50745
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBar_SetEffectDuration" "', expected argument " "1"" of type '" "wxInfoBar *""'"); 
 
50746
  }
 
50747
  arg1 = reinterpret_cast< wxInfoBar * >(argp1);
 
50748
  ecode2 = SWIG_AsVal_int(obj1, &val2);
 
50749
  if (!SWIG_IsOK(ecode2)) {
 
50750
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InfoBar_SetEffectDuration" "', expected argument " "2"" of type '" "int""'");
 
50751
  } 
 
50752
  arg2 = static_cast< int >(val2);
 
50753
  {
 
50754
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50755
    (arg1)->SetEffectDuration(arg2);
 
50756
    wxPyEndAllowThreads(__tstate);
 
50757
    if (PyErr_Occurred()) SWIG_fail;
 
50758
  }
 
50759
  resultobj = SWIG_Py_Void();
 
50760
  return resultobj;
 
50761
fail:
 
50762
  return NULL;
 
50763
}
 
50764
 
 
50765
 
 
50766
SWIGINTERN PyObject *_wrap_InfoBar_GetEffectDuration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50767
  PyObject *resultobj = 0;
 
50768
  wxInfoBar *arg1 = (wxInfoBar *) 0 ;
 
50769
  int result;
 
50770
  void *argp1 = 0 ;
 
50771
  int res1 = 0 ;
 
50772
  PyObject *swig_obj[1] ;
 
50773
  
 
50774
  if (!args) SWIG_fail;
 
50775
  swig_obj[0] = args;
 
50776
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxInfoBar, 0 |  0 );
 
50777
  if (!SWIG_IsOK(res1)) {
 
50778
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoBar_GetEffectDuration" "', expected argument " "1"" of type '" "wxInfoBar const *""'"); 
 
50779
  }
 
50780
  arg1 = reinterpret_cast< wxInfoBar * >(argp1);
 
50781
  {
 
50782
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50783
    result = (int)((wxInfoBar const *)arg1)->GetEffectDuration();
 
50784
    wxPyEndAllowThreads(__tstate);
 
50785
    if (PyErr_Occurred()) SWIG_fail;
 
50786
  }
 
50787
  resultobj = SWIG_From_int(static_cast< int >(result));
 
50788
  return resultobj;
 
50789
fail:
 
50790
  return NULL;
 
50791
}
 
50792
 
 
50793
 
 
50794
SWIGINTERN PyObject *InfoBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50795
  PyObject *obj;
 
50796
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
50797
  SWIG_TypeNewClientData(SWIGTYPE_p_wxInfoBar, SWIG_NewClientData(obj));
 
50798
  return SWIG_Py_Void();
 
50799
}
 
50800
 
 
50801
SWIGINTERN PyObject *InfoBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50802
  return SWIG_Python_InitShadowInstance(args);
 
50803
}
 
50804
 
 
50805
SWIGINTERN PyObject *_wrap_new_CommandLinkButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50806
  PyObject *resultobj = 0;
 
50807
  wxWindow *arg1 = (wxWindow *) 0 ;
 
50808
  int arg2 = (int) -1 ;
 
50809
  wxString const &arg3_defvalue = wxEmptyString ;
 
50810
  wxString *arg3 = (wxString *) &arg3_defvalue ;
 
50811
  wxString const &arg4_defvalue = wxEmptyString ;
 
50812
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
50813
  wxPoint const &arg5_defvalue = wxDefaultPosition ;
 
50814
  wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;
 
50815
  wxSize const &arg6_defvalue = wxDefaultSize ;
 
50816
  wxSize *arg6 = (wxSize *) &arg6_defvalue ;
 
50817
  long arg7 = (long) 0 ;
 
50818
  wxValidator const &arg8_defvalue = wxDefaultValidator ;
 
50819
  wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;
 
50820
  wxString const &arg9_defvalue = wxButtonNameStr ;
 
50821
  wxString *arg9 = (wxString *) &arg9_defvalue ;
 
50822
  wxCommandLinkButton *result = 0 ;
 
50823
  void *argp1 = 0 ;
 
50824
  int res1 = 0 ;
 
50825
  int val2 ;
 
50826
  int ecode2 = 0 ;
 
50827
  bool temp3 = false ;
 
50828
  bool temp4 = false ;
 
50829
  wxPoint temp5 ;
 
50830
  wxSize temp6 ;
 
50831
  long val7 ;
 
50832
  int ecode7 = 0 ;
 
50833
  void *argp8 = 0 ;
 
50834
  int res8 = 0 ;
 
50835
  bool temp9 = false ;
 
50836
  PyObject * obj0 = 0 ;
 
50837
  PyObject * obj1 = 0 ;
 
50838
  PyObject * obj2 = 0 ;
 
50839
  PyObject * obj3 = 0 ;
 
50840
  PyObject * obj4 = 0 ;
 
50841
  PyObject * obj5 = 0 ;
 
50842
  PyObject * obj6 = 0 ;
 
50843
  PyObject * obj7 = 0 ;
 
50844
  PyObject * obj8 = 0 ;
 
50845
  char *  kwnames[] = {
 
50846
    (char *) "parent",(char *) "id",(char *) "mainLabel",(char *) "note",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
50847
  };
 
50848
  
 
50849
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_CommandLinkButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
 
50850
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 |  0 );
 
50851
  if (!SWIG_IsOK(res1)) {
 
50852
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CommandLinkButton" "', expected argument " "1"" of type '" "wxWindow *""'"); 
 
50853
  }
 
50854
  arg1 = reinterpret_cast< wxWindow * >(argp1);
 
50855
  if (obj1) {
 
50856
    ecode2 = SWIG_AsVal_int(obj1, &val2);
 
50857
    if (!SWIG_IsOK(ecode2)) {
 
50858
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandLinkButton" "', expected argument " "2"" of type '" "int""'");
 
50859
    } 
 
50860
    arg2 = static_cast< int >(val2);
 
50861
  }
 
50862
  if (obj2) {
 
50863
    {
 
50864
      arg3 = wxString_in_helper(obj2);
 
50865
      if (arg3 == NULL) SWIG_fail;
 
50866
      temp3 = true;
 
50867
    }
 
50868
  }
 
50869
  if (obj3) {
 
50870
    {
 
50871
      arg4 = wxString_in_helper(obj3);
 
50872
      if (arg4 == NULL) SWIG_fail;
 
50873
      temp4 = true;
 
50874
    }
 
50875
  }
 
50876
  if (obj4) {
 
50877
    {
 
50878
      arg5 = &temp5;
 
50879
      if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
 
50880
    }
 
50881
  }
 
50882
  if (obj5) {
 
50883
    {
 
50884
      arg6 = &temp6;
 
50885
      if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
 
50886
    }
 
50887
  }
 
50888
  if (obj6) {
 
50889
    ecode7 = SWIG_AsVal_long(obj6, &val7);
 
50890
    if (!SWIG_IsOK(ecode7)) {
 
50891
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CommandLinkButton" "', expected argument " "7"" of type '" "long""'");
 
50892
    } 
 
50893
    arg7 = static_cast< long >(val7);
 
50894
  }
 
50895
  if (obj7) {
 
50896
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator,  0  | 0);
 
50897
    if (!SWIG_IsOK(res8)) {
 
50898
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CommandLinkButton" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
50899
    }
 
50900
    if (!argp8) {
 
50901
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CommandLinkButton" "', expected argument " "8"" of type '" "wxValidator const &""'"); 
 
50902
    }
 
50903
    arg8 = reinterpret_cast< wxValidator * >(argp8);
 
50904
  }
 
50905
  if (obj8) {
 
50906
    {
 
50907
      arg9 = wxString_in_helper(obj8);
 
50908
      if (arg9 == NULL) SWIG_fail;
 
50909
      temp9 = true;
 
50910
    }
 
50911
  }
 
50912
  {
 
50913
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50914
    result = (wxCommandLinkButton *)new wxCommandLinkButton(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);
 
50915
    wxPyEndAllowThreads(__tstate);
 
50916
    if (PyErr_Occurred()) SWIG_fail;
 
50917
  }
 
50918
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandLinkButton, SWIG_POINTER_NEW |  0 );
 
50919
  {
 
50920
    if (temp3)
 
50921
    delete arg3;
 
50922
  }
 
50923
  {
 
50924
    if (temp4)
 
50925
    delete arg4;
 
50926
  }
 
50927
  {
 
50928
    if (temp9)
 
50929
    delete arg9;
 
50930
  }
 
50931
  return resultobj;
 
50932
fail:
 
50933
  {
 
50934
    if (temp3)
 
50935
    delete arg3;
 
50936
  }
 
50937
  {
 
50938
    if (temp4)
 
50939
    delete arg4;
 
50940
  }
 
50941
  {
 
50942
    if (temp9)
 
50943
    delete arg9;
 
50944
  }
 
50945
  return NULL;
 
50946
}
 
50947
 
 
50948
 
 
50949
SWIGINTERN PyObject *_wrap_new_PreCommandLinkButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
50950
  PyObject *resultobj = 0;
 
50951
  wxCommandLinkButton *result = 0 ;
 
50952
  
 
50953
  if (!SWIG_Python_UnpackTuple(args,"new_PreCommandLinkButton",0,0,0)) SWIG_fail;
 
50954
  {
 
50955
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
50956
    result = (wxCommandLinkButton *)new wxCommandLinkButton();
 
50957
    wxPyEndAllowThreads(__tstate);
 
50958
    if (PyErr_Occurred()) SWIG_fail;
 
50959
  }
 
50960
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandLinkButton, SWIG_POINTER_OWN |  0 );
 
50961
  return resultobj;
 
50962
fail:
 
50963
  return NULL;
 
50964
}
 
50965
 
 
50966
 
 
50967
SWIGINTERN PyObject *_wrap_CommandLinkButton_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
50968
  PyObject *resultobj = 0;
 
50969
  wxCommandLinkButton *arg1 = (wxCommandLinkButton *) 0 ;
 
50970
  wxWindow *arg2 = (wxWindow *) 0 ;
 
50971
  int arg3 = (int) -1 ;
 
50972
  wxString const &arg4_defvalue = wxEmptyString ;
 
50973
  wxString *arg4 = (wxString *) &arg4_defvalue ;
 
50974
  wxString const &arg5_defvalue = wxEmptyString ;
 
50975
  wxString *arg5 = (wxString *) &arg5_defvalue ;
 
50976
  wxPoint const &arg6_defvalue = wxDefaultPosition ;
 
50977
  wxPoint *arg6 = (wxPoint *) &arg6_defvalue ;
 
50978
  wxSize const &arg7_defvalue = wxDefaultSize ;
 
50979
  wxSize *arg7 = (wxSize *) &arg7_defvalue ;
 
50980
  long arg8 = (long) 0 ;
 
50981
  wxValidator const &arg9_defvalue = wxDefaultValidator ;
 
50982
  wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;
 
50983
  wxString const &arg10_defvalue = wxButtonNameStr ;
 
50984
  wxString *arg10 = (wxString *) &arg10_defvalue ;
 
50985
  bool result;
 
50986
  void *argp1 = 0 ;
 
50987
  int res1 = 0 ;
 
50988
  void *argp2 = 0 ;
 
50989
  int res2 = 0 ;
 
50990
  int val3 ;
 
50991
  int ecode3 = 0 ;
 
50992
  bool temp4 = false ;
 
50993
  bool temp5 = false ;
 
50994
  wxPoint temp6 ;
 
50995
  wxSize temp7 ;
 
50996
  long val8 ;
 
50997
  int ecode8 = 0 ;
 
50998
  void *argp9 = 0 ;
 
50999
  int res9 = 0 ;
 
51000
  bool temp10 = false ;
 
51001
  PyObject * obj0 = 0 ;
 
51002
  PyObject * obj1 = 0 ;
 
51003
  PyObject * obj2 = 0 ;
 
51004
  PyObject * obj3 = 0 ;
 
51005
  PyObject * obj4 = 0 ;
 
51006
  PyObject * obj5 = 0 ;
 
51007
  PyObject * obj6 = 0 ;
 
51008
  PyObject * obj7 = 0 ;
 
51009
  PyObject * obj8 = 0 ;
 
51010
  PyObject * obj9 = 0 ;
 
51011
  char *  kwnames[] = {
 
51012
    (char *) "self",(char *) "parent",(char *) "id",(char *) "mainLabel",(char *) "note",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL 
 
51013
  };
 
51014
  
 
51015
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:CommandLinkButton_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
 
51016
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandLinkButton, 0 |  0 );
 
51017
  if (!SWIG_IsOK(res1)) {
 
51018
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandLinkButton_Create" "', expected argument " "1"" of type '" "wxCommandLinkButton *""'"); 
 
51019
  }
 
51020
  arg1 = reinterpret_cast< wxCommandLinkButton * >(argp1);
 
51021
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 |  0 );
 
51022
  if (!SWIG_IsOK(res2)) {
 
51023
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CommandLinkButton_Create" "', expected argument " "2"" of type '" "wxWindow *""'"); 
 
51024
  }
 
51025
  arg2 = reinterpret_cast< wxWindow * >(argp2);
 
51026
  if (obj2) {
 
51027
    ecode3 = SWIG_AsVal_int(obj2, &val3);
 
51028
    if (!SWIG_IsOK(ecode3)) {
 
51029
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CommandLinkButton_Create" "', expected argument " "3"" of type '" "int""'");
 
51030
    } 
 
51031
    arg3 = static_cast< int >(val3);
 
51032
  }
 
51033
  if (obj3) {
 
51034
    {
 
51035
      arg4 = wxString_in_helper(obj3);
 
51036
      if (arg4 == NULL) SWIG_fail;
 
51037
      temp4 = true;
 
51038
    }
 
51039
  }
 
51040
  if (obj4) {
 
51041
    {
 
51042
      arg5 = wxString_in_helper(obj4);
 
51043
      if (arg5 == NULL) SWIG_fail;
 
51044
      temp5 = true;
 
51045
    }
 
51046
  }
 
51047
  if (obj5) {
 
51048
    {
 
51049
      arg6 = &temp6;
 
51050
      if ( ! wxPoint_helper(obj5, &arg6)) SWIG_fail;
 
51051
    }
 
51052
  }
 
51053
  if (obj6) {
 
51054
    {
 
51055
      arg7 = &temp7;
 
51056
      if ( ! wxSize_helper(obj6, &arg7)) SWIG_fail;
 
51057
    }
 
51058
  }
 
51059
  if (obj7) {
 
51060
    ecode8 = SWIG_AsVal_long(obj7, &val8);
 
51061
    if (!SWIG_IsOK(ecode8)) {
 
51062
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CommandLinkButton_Create" "', expected argument " "8"" of type '" "long""'");
 
51063
    } 
 
51064
    arg8 = static_cast< long >(val8);
 
51065
  }
 
51066
  if (obj8) {
 
51067
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_wxValidator,  0  | 0);
 
51068
    if (!SWIG_IsOK(res9)) {
 
51069
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CommandLinkButton_Create" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
51070
    }
 
51071
    if (!argp9) {
 
51072
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CommandLinkButton_Create" "', expected argument " "9"" of type '" "wxValidator const &""'"); 
 
51073
    }
 
51074
    arg9 = reinterpret_cast< wxValidator * >(argp9);
 
51075
  }
 
51076
  if (obj9) {
 
51077
    {
 
51078
      arg10 = wxString_in_helper(obj9);
 
51079
      if (arg10 == NULL) SWIG_fail;
 
51080
      temp10 = true;
 
51081
    }
 
51082
  }
 
51083
  {
 
51084
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
51085
    result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxPoint const &)*arg6,(wxSize const &)*arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);
 
51086
    wxPyEndAllowThreads(__tstate);
 
51087
    if (PyErr_Occurred()) SWIG_fail;
 
51088
  }
 
51089
  {
 
51090
    resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
 
51091
  }
 
51092
  {
 
51093
    if (temp4)
 
51094
    delete arg4;
 
51095
  }
 
51096
  {
 
51097
    if (temp5)
 
51098
    delete arg5;
 
51099
  }
 
51100
  {
 
51101
    if (temp10)
 
51102
    delete arg10;
 
51103
  }
 
51104
  return resultobj;
 
51105
fail:
 
51106
  {
 
51107
    if (temp4)
 
51108
    delete arg4;
 
51109
  }
 
51110
  {
 
51111
    if (temp5)
 
51112
    delete arg5;
 
51113
  }
 
51114
  {
 
51115
    if (temp10)
 
51116
    delete arg10;
 
51117
  }
 
51118
  return NULL;
 
51119
}
 
51120
 
 
51121
 
 
51122
SWIGINTERN PyObject *_wrap_CommandLinkButton_SetMainLabelAndNote(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
51123
  PyObject *resultobj = 0;
 
51124
  wxCommandLinkButton *arg1 = (wxCommandLinkButton *) 0 ;
 
51125
  wxString *arg2 = 0 ;
 
51126
  wxString *arg3 = 0 ;
 
51127
  void *argp1 = 0 ;
 
51128
  int res1 = 0 ;
 
51129
  bool temp2 = false ;
 
51130
  bool temp3 = false ;
 
51131
  PyObject * obj0 = 0 ;
 
51132
  PyObject * obj1 = 0 ;
 
51133
  PyObject * obj2 = 0 ;
 
51134
  char *  kwnames[] = {
 
51135
    (char *) "self",(char *) "mainLabel",(char *) "note", NULL 
 
51136
  };
 
51137
  
 
51138
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:CommandLinkButton_SetMainLabelAndNote",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
 
51139
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandLinkButton, 0 |  0 );
 
51140
  if (!SWIG_IsOK(res1)) {
 
51141
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandLinkButton_SetMainLabelAndNote" "', expected argument " "1"" of type '" "wxCommandLinkButton *""'"); 
 
51142
  }
 
51143
  arg1 = reinterpret_cast< wxCommandLinkButton * >(argp1);
 
51144
  {
 
51145
    arg2 = wxString_in_helper(obj1);
 
51146
    if (arg2 == NULL) SWIG_fail;
 
51147
    temp2 = true;
 
51148
  }
 
51149
  {
 
51150
    arg3 = wxString_in_helper(obj2);
 
51151
    if (arg3 == NULL) SWIG_fail;
 
51152
    temp3 = true;
 
51153
  }
 
51154
  {
 
51155
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
51156
    (arg1)->SetMainLabelAndNote((wxString const &)*arg2,(wxString const &)*arg3);
 
51157
    wxPyEndAllowThreads(__tstate);
 
51158
    if (PyErr_Occurred()) SWIG_fail;
 
51159
  }
 
51160
  resultobj = SWIG_Py_Void();
 
51161
  {
 
51162
    if (temp2)
 
51163
    delete arg2;
 
51164
  }
 
51165
  {
 
51166
    if (temp3)
 
51167
    delete arg3;
 
51168
  }
 
51169
  return resultobj;
 
51170
fail:
 
51171
  {
 
51172
    if (temp2)
 
51173
    delete arg2;
 
51174
  }
 
51175
  {
 
51176
    if (temp3)
 
51177
    delete arg3;
 
51178
  }
 
51179
  return NULL;
 
51180
}
 
51181
 
 
51182
 
 
51183
SWIGINTERN PyObject *_wrap_CommandLinkButton_SetMainLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
51184
  PyObject *resultobj = 0;
 
51185
  wxCommandLinkButton *arg1 = (wxCommandLinkButton *) 0 ;
 
51186
  wxString *arg2 = 0 ;
 
51187
  void *argp1 = 0 ;
 
51188
  int res1 = 0 ;
 
51189
  bool temp2 = false ;
 
51190
  PyObject * obj0 = 0 ;
 
51191
  PyObject * obj1 = 0 ;
 
51192
  char *  kwnames[] = {
 
51193
    (char *) "self",(char *) "mainLabel", NULL 
 
51194
  };
 
51195
  
 
51196
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandLinkButton_SetMainLabel",kwnames,&obj0,&obj1)) SWIG_fail;
 
51197
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandLinkButton, 0 |  0 );
 
51198
  if (!SWIG_IsOK(res1)) {
 
51199
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandLinkButton_SetMainLabel" "', expected argument " "1"" of type '" "wxCommandLinkButton *""'"); 
 
51200
  }
 
51201
  arg1 = reinterpret_cast< wxCommandLinkButton * >(argp1);
 
51202
  {
 
51203
    arg2 = wxString_in_helper(obj1);
 
51204
    if (arg2 == NULL) SWIG_fail;
 
51205
    temp2 = true;
 
51206
  }
 
51207
  {
 
51208
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
51209
    (arg1)->SetMainLabel((wxString const &)*arg2);
 
51210
    wxPyEndAllowThreads(__tstate);
 
51211
    if (PyErr_Occurred()) SWIG_fail;
 
51212
  }
 
51213
  resultobj = SWIG_Py_Void();
 
51214
  {
 
51215
    if (temp2)
 
51216
    delete arg2;
 
51217
  }
 
51218
  return resultobj;
 
51219
fail:
 
51220
  {
 
51221
    if (temp2)
 
51222
    delete arg2;
 
51223
  }
 
51224
  return NULL;
 
51225
}
 
51226
 
 
51227
 
 
51228
SWIGINTERN PyObject *_wrap_CommandLinkButton_SetNote(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
 
51229
  PyObject *resultobj = 0;
 
51230
  wxCommandLinkButton *arg1 = (wxCommandLinkButton *) 0 ;
 
51231
  wxString *arg2 = 0 ;
 
51232
  void *argp1 = 0 ;
 
51233
  int res1 = 0 ;
 
51234
  bool temp2 = false ;
 
51235
  PyObject * obj0 = 0 ;
 
51236
  PyObject * obj1 = 0 ;
 
51237
  char *  kwnames[] = {
 
51238
    (char *) "self",(char *) "note", NULL 
 
51239
  };
 
51240
  
 
51241
  if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandLinkButton_SetNote",kwnames,&obj0,&obj1)) SWIG_fail;
 
51242
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandLinkButton, 0 |  0 );
 
51243
  if (!SWIG_IsOK(res1)) {
 
51244
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandLinkButton_SetNote" "', expected argument " "1"" of type '" "wxCommandLinkButton *""'"); 
 
51245
  }
 
51246
  arg1 = reinterpret_cast< wxCommandLinkButton * >(argp1);
 
51247
  {
 
51248
    arg2 = wxString_in_helper(obj1);
 
51249
    if (arg2 == NULL) SWIG_fail;
 
51250
    temp2 = true;
 
51251
  }
 
51252
  {
 
51253
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
51254
    (arg1)->SetNote((wxString const &)*arg2);
 
51255
    wxPyEndAllowThreads(__tstate);
 
51256
    if (PyErr_Occurred()) SWIG_fail;
 
51257
  }
 
51258
  resultobj = SWIG_Py_Void();
 
51259
  {
 
51260
    if (temp2)
 
51261
    delete arg2;
 
51262
  }
 
51263
  return resultobj;
 
51264
fail:
 
51265
  {
 
51266
    if (temp2)
 
51267
    delete arg2;
 
51268
  }
 
51269
  return NULL;
 
51270
}
 
51271
 
 
51272
 
 
51273
SWIGINTERN PyObject *_wrap_CommandLinkButton_GetMainLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
51274
  PyObject *resultobj = 0;
 
51275
  wxCommandLinkButton *arg1 = (wxCommandLinkButton *) 0 ;
 
51276
  wxString result;
 
51277
  void *argp1 = 0 ;
 
51278
  int res1 = 0 ;
 
51279
  PyObject *swig_obj[1] ;
 
51280
  
 
51281
  if (!args) SWIG_fail;
 
51282
  swig_obj[0] = args;
 
51283
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandLinkButton, 0 |  0 );
 
51284
  if (!SWIG_IsOK(res1)) {
 
51285
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandLinkButton_GetMainLabel" "', expected argument " "1"" of type '" "wxCommandLinkButton const *""'"); 
 
51286
  }
 
51287
  arg1 = reinterpret_cast< wxCommandLinkButton * >(argp1);
 
51288
  {
 
51289
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
51290
    result = ((wxCommandLinkButton const *)arg1)->GetMainLabel();
 
51291
    wxPyEndAllowThreads(__tstate);
 
51292
    if (PyErr_Occurred()) SWIG_fail;
 
51293
  }
 
51294
  {
 
51295
#if wxUSE_UNICODE
 
51296
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
51297
#else
 
51298
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
51299
#endif
 
51300
  }
 
51301
  return resultobj;
 
51302
fail:
 
51303
  return NULL;
 
51304
}
 
51305
 
 
51306
 
 
51307
SWIGINTERN PyObject *_wrap_CommandLinkButton_GetNote(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
51308
  PyObject *resultobj = 0;
 
51309
  wxCommandLinkButton *arg1 = (wxCommandLinkButton *) 0 ;
 
51310
  wxString result;
 
51311
  void *argp1 = 0 ;
 
51312
  int res1 = 0 ;
 
51313
  PyObject *swig_obj[1] ;
 
51314
  
 
51315
  if (!args) SWIG_fail;
 
51316
  swig_obj[0] = args;
 
51317
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandLinkButton, 0 |  0 );
 
51318
  if (!SWIG_IsOK(res1)) {
 
51319
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandLinkButton_GetNote" "', expected argument " "1"" of type '" "wxCommandLinkButton const *""'"); 
 
51320
  }
 
51321
  arg1 = reinterpret_cast< wxCommandLinkButton * >(argp1);
 
51322
  {
 
51323
    PyThreadState* __tstate = wxPyBeginAllowThreads();
 
51324
    result = ((wxCommandLinkButton const *)arg1)->GetNote();
 
51325
    wxPyEndAllowThreads(__tstate);
 
51326
    if (PyErr_Occurred()) SWIG_fail;
 
51327
  }
 
51328
  {
 
51329
#if wxUSE_UNICODE
 
51330
    resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
 
51331
#else
 
51332
    resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
 
51333
#endif
 
51334
  }
 
51335
  return resultobj;
 
51336
fail:
 
51337
  return NULL;
 
51338
}
 
51339
 
 
51340
 
 
51341
SWIGINTERN PyObject *CommandLinkButton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
51342
  PyObject *obj;
 
51343
  if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
 
51344
  SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandLinkButton, SWIG_NewClientData(obj));
 
51345
  return SWIG_Py_Void();
 
51346
}
 
51347
 
 
51348
SWIGINTERN PyObject *CommandLinkButton_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
 
51349
  return SWIG_Python_InitShadowInstance(args);
 
51350
}
 
51351
 
 
51352
static PyMethodDef SwigMethods[] = {
 
51353
         { (char *)"AnyButton_SetBitmap", (PyCFunction) _wrap_AnyButton_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
51354
         { (char *)"AnyButton_GetBitmap", (PyCFunction)_wrap_AnyButton_GetBitmap, METH_O, NULL},
 
51355
         { (char *)"AnyButton_SetBitmapLabel", (PyCFunction) _wrap_AnyButton_SetBitmapLabel, METH_VARARGS | METH_KEYWORDS, NULL},
 
51356
         { (char *)"AnyButton_SetBitmapPressed", (PyCFunction) _wrap_AnyButton_SetBitmapPressed, METH_VARARGS | METH_KEYWORDS, NULL},
 
51357
         { (char *)"AnyButton_SetBitmapDisabled", (PyCFunction) _wrap_AnyButton_SetBitmapDisabled, METH_VARARGS | METH_KEYWORDS, NULL},
 
51358
         { (char *)"AnyButton_SetBitmapCurrent", (PyCFunction) _wrap_AnyButton_SetBitmapCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
 
51359
         { (char *)"AnyButton_SetBitmapFocus", (PyCFunction) _wrap_AnyButton_SetBitmapFocus, METH_VARARGS | METH_KEYWORDS, NULL},
 
51360
         { (char *)"AnyButton_GetBitmapLabel", (PyCFunction)_wrap_AnyButton_GetBitmapLabel, METH_O, NULL},
 
51361
         { (char *)"AnyButton_GetBitmapPressed", (PyCFunction)_wrap_AnyButton_GetBitmapPressed, METH_O, NULL},
 
51362
         { (char *)"AnyButton_GetBitmapDisabled", (PyCFunction)_wrap_AnyButton_GetBitmapDisabled, METH_O, NULL},
 
51363
         { (char *)"AnyButton_GetBitmapCurrent", (PyCFunction)_wrap_AnyButton_GetBitmapCurrent, METH_O, NULL},
 
51364
         { (char *)"AnyButton_GetBitmapFocus", (PyCFunction)_wrap_AnyButton_GetBitmapFocus, METH_O, NULL},
 
51365
         { (char *)"AnyButton_GetBitmapSelected", (PyCFunction)_wrap_AnyButton_GetBitmapSelected, METH_O, NULL},
 
51366
         { (char *)"AnyButton_GetBitmapHover", (PyCFunction)_wrap_AnyButton_GetBitmapHover, METH_O, NULL},
 
51367
         { (char *)"AnyButton_SetBitmapSelected", (PyCFunction) _wrap_AnyButton_SetBitmapSelected, METH_VARARGS | METH_KEYWORDS, NULL},
 
51368
         { (char *)"AnyButton_SetBitmapHover", (PyCFunction) _wrap_AnyButton_SetBitmapHover, METH_VARARGS | METH_KEYWORDS, NULL},
 
51369
         { (char *)"AnyButton_SetBitmapMargins", _wrap_AnyButton_SetBitmapMargins, METH_VARARGS, NULL},
 
51370
         { (char *)"AnyButton_GetBitmapMargins", (PyCFunction)_wrap_AnyButton_GetBitmapMargins, METH_O, NULL},
 
51371
         { (char *)"AnyButton_SetBitmapPosition", (PyCFunction) _wrap_AnyButton_SetBitmapPosition, METH_VARARGS | METH_KEYWORDS, NULL},
 
51372
         { (char *)"AnyButton_DontShowLabel", (PyCFunction)_wrap_AnyButton_DontShowLabel, METH_O, NULL},
 
51373
         { (char *)"AnyButton_ShowsLabel", (PyCFunction)_wrap_AnyButton_ShowsLabel, METH_O, NULL},
 
51374
         { (char *)"AnyButton_swigregister", AnyButton_swigregister, METH_VARARGS, NULL},
 
51375
         { (char *)"new_Button", (PyCFunction) _wrap_new_Button, METH_VARARGS | METH_KEYWORDS, NULL},
 
51376
         { (char *)"new_PreButton", (PyCFunction)_wrap_new_PreButton, METH_NOARGS, NULL},
 
51377
         { (char *)"Button_Create", (PyCFunction) _wrap_Button_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51378
         { (char *)"Button_SetAuthNeeded", (PyCFunction) _wrap_Button_SetAuthNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
 
51379
         { (char *)"Button_GetAuthNeeded", (PyCFunction)_wrap_Button_GetAuthNeeded, METH_O, NULL},
 
51380
         { (char *)"Button_SetDefault", (PyCFunction)_wrap_Button_SetDefault, METH_O, NULL},
 
51381
         { (char *)"Button_GetDefaultSize", (PyCFunction)_wrap_Button_GetDefaultSize, METH_NOARGS, NULL},
 
51382
         { (char *)"Button_GetClassDefaultAttributes", (PyCFunction) _wrap_Button_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51383
         { (char *)"Button_swigregister", Button_swigregister, METH_VARARGS, NULL},
 
51384
         { (char *)"Button_swiginit", Button_swiginit, METH_VARARGS, NULL},
 
51385
         { (char *)"new_BitmapButton", (PyCFunction) _wrap_new_BitmapButton, METH_VARARGS | METH_KEYWORDS, NULL},
 
51386
         { (char *)"new_PreBitmapButton", (PyCFunction)_wrap_new_PreBitmapButton, METH_NOARGS, NULL},
 
51387
         { (char *)"BitmapButton_Create", (PyCFunction) _wrap_BitmapButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51388
         { (char *)"BitmapButton_swigregister", BitmapButton_swigregister, METH_VARARGS, NULL},
 
51389
         { (char *)"BitmapButton_swiginit", BitmapButton_swiginit, METH_VARARGS, NULL},
 
51390
         { (char *)"new_CheckBox", (PyCFunction) _wrap_new_CheckBox, METH_VARARGS | METH_KEYWORDS, NULL},
 
51391
         { (char *)"new_PreCheckBox", (PyCFunction)_wrap_new_PreCheckBox, METH_NOARGS, NULL},
 
51392
         { (char *)"CheckBox_Create", (PyCFunction) _wrap_CheckBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51393
         { (char *)"CheckBox_GetValue", (PyCFunction)_wrap_CheckBox_GetValue, METH_O, NULL},
 
51394
         { (char *)"CheckBox_IsChecked", (PyCFunction)_wrap_CheckBox_IsChecked, METH_O, NULL},
 
51395
         { (char *)"CheckBox_SetValue", (PyCFunction) _wrap_CheckBox_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51396
         { (char *)"CheckBox_Get3StateValue", (PyCFunction)_wrap_CheckBox_Get3StateValue, METH_O, NULL},
 
51397
         { (char *)"CheckBox_Set3StateValue", (PyCFunction) _wrap_CheckBox_Set3StateValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51398
         { (char *)"CheckBox_Is3State", (PyCFunction)_wrap_CheckBox_Is3State, METH_O, NULL},
 
51399
         { (char *)"CheckBox_Is3rdStateAllowedForUser", (PyCFunction)_wrap_CheckBox_Is3rdStateAllowedForUser, METH_O, NULL},
 
51400
         { (char *)"CheckBox_GetClassDefaultAttributes", (PyCFunction) _wrap_CheckBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51401
         { (char *)"CheckBox_swigregister", CheckBox_swigregister, METH_VARARGS, NULL},
 
51402
         { (char *)"CheckBox_swiginit", CheckBox_swiginit, METH_VARARGS, NULL},
 
51403
         { (char *)"new_Choice", (PyCFunction) _wrap_new_Choice, METH_VARARGS | METH_KEYWORDS, NULL},
 
51404
         { (char *)"new_PreChoice", (PyCFunction)_wrap_new_PreChoice, METH_NOARGS, NULL},
 
51405
         { (char *)"Choice_Create", (PyCFunction) _wrap_Choice_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51406
         { (char *)"Choice_GetCurrentSelection", (PyCFunction)_wrap_Choice_GetCurrentSelection, METH_O, NULL},
 
51407
         { (char *)"Choice_GetClassDefaultAttributes", (PyCFunction) _wrap_Choice_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51408
         { (char *)"Choice_swigregister", Choice_swigregister, METH_VARARGS, NULL},
 
51409
         { (char *)"Choice_swiginit", Choice_swiginit, METH_VARARGS, NULL},
 
51410
         { (char *)"new_ComboBox", (PyCFunction) _wrap_new_ComboBox, METH_VARARGS | METH_KEYWORDS, NULL},
 
51411
         { (char *)"new_PreComboBox", (PyCFunction)_wrap_new_PreComboBox, METH_NOARGS, NULL},
 
51412
         { (char *)"ComboBox_Create", (PyCFunction) _wrap_ComboBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51413
         { (char *)"ComboBox_SetMark", (PyCFunction) _wrap_ComboBox_SetMark, METH_VARARGS | METH_KEYWORDS, NULL},
 
51414
         { (char *)"ComboBox_GetMark", (PyCFunction)_wrap_ComboBox_GetMark, METH_O, NULL},
 
51415
         { (char *)"ComboBox_IsEmpty", (PyCFunction)_wrap_ComboBox_IsEmpty, METH_O, NULL},
 
51416
         { (char *)"ComboBox_IsListEmpty", (PyCFunction)_wrap_ComboBox_IsListEmpty, METH_O, NULL},
 
51417
         { (char *)"ComboBox_IsTextEmpty", (PyCFunction)_wrap_ComboBox_IsTextEmpty, METH_O, NULL},
 
51418
         { (char *)"ComboBox_Popup", (PyCFunction)_wrap_ComboBox_Popup, METH_O, NULL},
 
51419
         { (char *)"ComboBox_Dismiss", (PyCFunction)_wrap_ComboBox_Dismiss, METH_O, NULL},
 
51420
         { (char *)"ComboBox_GetCurrentSelection", (PyCFunction)_wrap_ComboBox_GetCurrentSelection, METH_O, NULL},
 
51421
         { (char *)"ComboBox_SetStringSelection", (PyCFunction) _wrap_ComboBox_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
 
51422
         { (char *)"ComboBox_GetClassDefaultAttributes", (PyCFunction) _wrap_ComboBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51423
         { (char *)"ComboBox_swigregister", ComboBox_swigregister, METH_VARARGS, NULL},
 
51424
         { (char *)"ComboBox_swiginit", ComboBox_swiginit, METH_VARARGS, NULL},
 
51425
         { (char *)"new_Gauge", (PyCFunction) _wrap_new_Gauge, METH_VARARGS | METH_KEYWORDS, NULL},
 
51426
         { (char *)"new_PreGauge", (PyCFunction)_wrap_new_PreGauge, METH_NOARGS, NULL},
 
51427
         { (char *)"Gauge_Create", (PyCFunction) _wrap_Gauge_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51428
         { (char *)"Gauge_SetRange", (PyCFunction) _wrap_Gauge_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
 
51429
         { (char *)"Gauge_GetRange", (PyCFunction)_wrap_Gauge_GetRange, METH_O, NULL},
 
51430
         { (char *)"Gauge_SetValue", (PyCFunction) _wrap_Gauge_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51431
         { (char *)"Gauge_GetValue", (PyCFunction)_wrap_Gauge_GetValue, METH_O, NULL},
 
51432
         { (char *)"Gauge_Pulse", (PyCFunction)_wrap_Gauge_Pulse, METH_O, NULL},
 
51433
         { (char *)"Gauge_IsVertical", (PyCFunction)_wrap_Gauge_IsVertical, METH_O, NULL},
 
51434
         { (char *)"Gauge_SetShadowWidth", (PyCFunction) _wrap_Gauge_SetShadowWidth, METH_VARARGS | METH_KEYWORDS, NULL},
 
51435
         { (char *)"Gauge_GetShadowWidth", (PyCFunction)_wrap_Gauge_GetShadowWidth, METH_O, NULL},
 
51436
         { (char *)"Gauge_SetBezelFace", (PyCFunction) _wrap_Gauge_SetBezelFace, METH_VARARGS | METH_KEYWORDS, NULL},
 
51437
         { (char *)"Gauge_GetBezelFace", (PyCFunction)_wrap_Gauge_GetBezelFace, METH_O, NULL},
 
51438
         { (char *)"Gauge_GetClassDefaultAttributes", (PyCFunction) _wrap_Gauge_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51439
         { (char *)"Gauge_swigregister", Gauge_swigregister, METH_VARARGS, NULL},
 
51440
         { (char *)"Gauge_swiginit", Gauge_swiginit, METH_VARARGS, NULL},
 
51441
         { (char *)"new_StaticBox", (PyCFunction) _wrap_new_StaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
 
51442
         { (char *)"new_PreStaticBox", (PyCFunction)_wrap_new_PreStaticBox, METH_NOARGS, NULL},
 
51443
         { (char *)"StaticBox_Create", (PyCFunction) _wrap_StaticBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51444
         { (char *)"StaticBox_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51445
         { (char *)"StaticBox_swigregister", StaticBox_swigregister, METH_VARARGS, NULL},
 
51446
         { (char *)"StaticBox_swiginit", StaticBox_swiginit, METH_VARARGS, NULL},
 
51447
         { (char *)"new_StaticLine", (PyCFunction) _wrap_new_StaticLine, METH_VARARGS | METH_KEYWORDS, NULL},
 
51448
         { (char *)"new_PreStaticLine", (PyCFunction)_wrap_new_PreStaticLine, METH_NOARGS, NULL},
 
51449
         { (char *)"StaticLine_Create", (PyCFunction) _wrap_StaticLine_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51450
         { (char *)"StaticLine_IsVertical", (PyCFunction)_wrap_StaticLine_IsVertical, METH_O, NULL},
 
51451
         { (char *)"StaticLine_GetDefaultSize", (PyCFunction)_wrap_StaticLine_GetDefaultSize, METH_NOARGS, NULL},
 
51452
         { (char *)"StaticLine_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticLine_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51453
         { (char *)"StaticLine_swigregister", StaticLine_swigregister, METH_VARARGS, NULL},
 
51454
         { (char *)"StaticLine_swiginit", StaticLine_swiginit, METH_VARARGS, NULL},
 
51455
         { (char *)"new_StaticText", (PyCFunction) _wrap_new_StaticText, METH_VARARGS | METH_KEYWORDS, NULL},
 
51456
         { (char *)"new_PreStaticText", (PyCFunction)_wrap_new_PreStaticText, METH_NOARGS, NULL},
 
51457
         { (char *)"StaticText_Create", (PyCFunction) _wrap_StaticText_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51458
         { (char *)"StaticText_Wrap", (PyCFunction) _wrap_StaticText_Wrap, METH_VARARGS | METH_KEYWORDS, NULL},
 
51459
         { (char *)"StaticText_IsEllipsized", (PyCFunction)_wrap_StaticText_IsEllipsized, METH_O, NULL},
 
51460
         { (char *)"StaticText_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticText_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51461
         { (char *)"StaticText_swigregister", StaticText_swigregister, METH_VARARGS, NULL},
 
51462
         { (char *)"StaticText_swiginit", StaticText_swiginit, METH_VARARGS, NULL},
 
51463
         { (char *)"new_StaticBitmap", (PyCFunction) _wrap_new_StaticBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
51464
         { (char *)"new_PreStaticBitmap", (PyCFunction)_wrap_new_PreStaticBitmap, METH_NOARGS, NULL},
 
51465
         { (char *)"StaticBitmap_Create", (PyCFunction) _wrap_StaticBitmap_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51466
         { (char *)"StaticBitmap_GetBitmap", (PyCFunction)_wrap_StaticBitmap_GetBitmap, METH_O, NULL},
 
51467
         { (char *)"StaticBitmap_SetBitmap", (PyCFunction) _wrap_StaticBitmap_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
51468
         { (char *)"StaticBitmap_SetIcon", (PyCFunction) _wrap_StaticBitmap_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
 
51469
         { (char *)"StaticBitmap_GetClassDefaultAttributes", (PyCFunction) _wrap_StaticBitmap_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51470
         { (char *)"StaticBitmap_swigregister", StaticBitmap_swigregister, METH_VARARGS, NULL},
 
51471
         { (char *)"StaticBitmap_swiginit", StaticBitmap_swiginit, METH_VARARGS, NULL},
 
51472
         { (char *)"new_ListBox", (PyCFunction) _wrap_new_ListBox, METH_VARARGS | METH_KEYWORDS, NULL},
 
51473
         { (char *)"new_PreListBox", (PyCFunction)_wrap_new_PreListBox, METH_NOARGS, NULL},
 
51474
         { (char *)"ListBox_Create", (PyCFunction) _wrap_ListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51475
         { (char *)"ListBox_Insert", (PyCFunction) _wrap_ListBox_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
 
51476
         { (char *)"ListBox_InsertItems", (PyCFunction) _wrap_ListBox_InsertItems, METH_VARARGS | METH_KEYWORDS, NULL},
 
51477
         { (char *)"ListBox_Set", (PyCFunction) _wrap_ListBox_Set, METH_VARARGS | METH_KEYWORDS, NULL},
 
51478
         { (char *)"ListBox_IsSelected", (PyCFunction) _wrap_ListBox_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
 
51479
         { (char *)"ListBox_SetSelection", (PyCFunction) _wrap_ListBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
 
51480
         { (char *)"ListBox_Select", (PyCFunction) _wrap_ListBox_Select, METH_VARARGS | METH_KEYWORDS, NULL},
 
51481
         { (char *)"ListBox_Deselect", (PyCFunction) _wrap_ListBox_Deselect, METH_VARARGS | METH_KEYWORDS, NULL},
 
51482
         { (char *)"ListBox_DeselectAll", (PyCFunction) _wrap_ListBox_DeselectAll, METH_VARARGS | METH_KEYWORDS, NULL},
 
51483
         { (char *)"ListBox_SetStringSelection", (PyCFunction) _wrap_ListBox_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
 
51484
         { (char *)"ListBox_GetSelections", (PyCFunction)_wrap_ListBox_GetSelections, METH_O, NULL},
 
51485
         { (char *)"ListBox_SetFirstItem", (PyCFunction) _wrap_ListBox_SetFirstItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
51486
         { (char *)"ListBox_SetFirstItemStr", (PyCFunction) _wrap_ListBox_SetFirstItemStr, METH_VARARGS | METH_KEYWORDS, NULL},
 
51487
         { (char *)"ListBox_EnsureVisible", (PyCFunction) _wrap_ListBox_EnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
 
51488
         { (char *)"ListBox_AppendAndEnsureVisible", (PyCFunction) _wrap_ListBox_AppendAndEnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
 
51489
         { (char *)"ListBox_HitTest", (PyCFunction) _wrap_ListBox_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
 
51490
         { (char *)"ListBox_SetItemForegroundColour", (PyCFunction) _wrap_ListBox_SetItemForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
51491
         { (char *)"ListBox_SetItemBackgroundColour", (PyCFunction) _wrap_ListBox_SetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
51492
         { (char *)"ListBox_SetItemFont", (PyCFunction) _wrap_ListBox_SetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
51493
         { (char *)"ListBox_GetClassDefaultAttributes", (PyCFunction) _wrap_ListBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51494
         { (char *)"ListBox_swigregister", ListBox_swigregister, METH_VARARGS, NULL},
 
51495
         { (char *)"ListBox_swiginit", ListBox_swiginit, METH_VARARGS, NULL},
 
51496
         { (char *)"new_CheckListBox", (PyCFunction) _wrap_new_CheckListBox, METH_VARARGS | METH_KEYWORDS, NULL},
 
51497
         { (char *)"new_PreCheckListBox", (PyCFunction)_wrap_new_PreCheckListBox, METH_NOARGS, NULL},
 
51498
         { (char *)"CheckListBox_Create", (PyCFunction) _wrap_CheckListBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51499
         { (char *)"CheckListBox_IsChecked", (PyCFunction) _wrap_CheckListBox_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
 
51500
         { (char *)"CheckListBox_Check", (PyCFunction) _wrap_CheckListBox_Check, METH_VARARGS | METH_KEYWORDS, NULL},
 
51501
         { (char *)"CheckListBox_swigregister", CheckListBox_swigregister, METH_VARARGS, NULL},
 
51502
         { (char *)"CheckListBox_swiginit", CheckListBox_swiginit, METH_VARARGS, NULL},
 
51503
         { (char *)"new_TextAttr", (PyCFunction) _wrap_new_TextAttr, METH_VARARGS | METH_KEYWORDS, NULL},
 
51504
         { (char *)"delete_TextAttr", (PyCFunction)_wrap_delete_TextAttr, METH_O, NULL},
 
51505
         { (char *)"TextAttr_Init", (PyCFunction)_wrap_TextAttr_Init, METH_O, NULL},
 
51506
         { (char *)"TextAttr_Copy", (PyCFunction) _wrap_TextAttr_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
 
51507
         { (char *)"TextAttr_EqPartial", (PyCFunction) _wrap_TextAttr_EqPartial, METH_VARARGS | METH_KEYWORDS, NULL},
 
51508
         { (char *)"TextAttr_GetFontAttributes", (PyCFunction) _wrap_TextAttr_GetFontAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51509
         { (char *)"TextAttr_SetTextColour", (PyCFunction) _wrap_TextAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
51510
         { (char *)"TextAttr_SetBackgroundColour", (PyCFunction) _wrap_TextAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
51511
         { (char *)"TextAttr_SetAlignment", (PyCFunction) _wrap_TextAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
 
51512
         { (char *)"TextAttr_SetTabs", (PyCFunction) _wrap_TextAttr_SetTabs, METH_VARARGS | METH_KEYWORDS, NULL},
 
51513
         { (char *)"TextAttr_SetLeftIndent", (PyCFunction) _wrap_TextAttr_SetLeftIndent, METH_VARARGS | METH_KEYWORDS, NULL},
 
51514
         { (char *)"TextAttr_SetRightIndent", (PyCFunction) _wrap_TextAttr_SetRightIndent, METH_VARARGS | METH_KEYWORDS, NULL},
 
51515
         { (char *)"TextAttr_SetFontSize", (PyCFunction) _wrap_TextAttr_SetFontSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
51516
         { (char *)"TextAttr_SetFontStyle", (PyCFunction) _wrap_TextAttr_SetFontStyle, METH_VARARGS | METH_KEYWORDS, NULL},
 
51517
         { (char *)"TextAttr_SetFontWeight", (PyCFunction) _wrap_TextAttr_SetFontWeight, METH_VARARGS | METH_KEYWORDS, NULL},
 
51518
         { (char *)"TextAttr_SetFontFaceName", (PyCFunction) _wrap_TextAttr_SetFontFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
 
51519
         { (char *)"TextAttr_SetFontUnderlined", (PyCFunction) _wrap_TextAttr_SetFontUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
 
51520
         { (char *)"TextAttr_SetFontStrikethrough", (PyCFunction) _wrap_TextAttr_SetFontStrikethrough, METH_VARARGS | METH_KEYWORDS, NULL},
 
51521
         { (char *)"TextAttr_SetFontEncoding", (PyCFunction) _wrap_TextAttr_SetFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
 
51522
         { (char *)"TextAttr_SetFontFamily", (PyCFunction) _wrap_TextAttr_SetFontFamily, METH_VARARGS | METH_KEYWORDS, NULL},
 
51523
         { (char *)"TextAttr_SetFont", (PyCFunction) _wrap_TextAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
51524
         { (char *)"TextAttr_SetFlags", (PyCFunction) _wrap_TextAttr_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
 
51525
         { (char *)"TextAttr_SetCharacterStyleName", (PyCFunction) _wrap_TextAttr_SetCharacterStyleName, METH_VARARGS | METH_KEYWORDS, NULL},
 
51526
         { (char *)"TextAttr_SetParagraphStyleName", (PyCFunction) _wrap_TextAttr_SetParagraphStyleName, METH_VARARGS | METH_KEYWORDS, NULL},
 
51527
         { (char *)"TextAttr_SetListStyleName", (PyCFunction) _wrap_TextAttr_SetListStyleName, METH_VARARGS | METH_KEYWORDS, NULL},
 
51528
         { (char *)"TextAttr_SetParagraphSpacingAfter", (PyCFunction) _wrap_TextAttr_SetParagraphSpacingAfter, METH_VARARGS | METH_KEYWORDS, NULL},
 
51529
         { (char *)"TextAttr_SetParagraphSpacingBefore", (PyCFunction) _wrap_TextAttr_SetParagraphSpacingBefore, METH_VARARGS | METH_KEYWORDS, NULL},
 
51530
         { (char *)"TextAttr_SetLineSpacing", (PyCFunction) _wrap_TextAttr_SetLineSpacing, METH_VARARGS | METH_KEYWORDS, NULL},
 
51531
         { (char *)"TextAttr_SetBulletStyle", (PyCFunction) _wrap_TextAttr_SetBulletStyle, METH_VARARGS | METH_KEYWORDS, NULL},
 
51532
         { (char *)"TextAttr_SetBulletNumber", (PyCFunction) _wrap_TextAttr_SetBulletNumber, METH_VARARGS | METH_KEYWORDS, NULL},
 
51533
         { (char *)"TextAttr_SetBulletText", (PyCFunction) _wrap_TextAttr_SetBulletText, METH_VARARGS | METH_KEYWORDS, NULL},
 
51534
         { (char *)"TextAttr_SetBulletFont", (PyCFunction) _wrap_TextAttr_SetBulletFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
51535
         { (char *)"TextAttr_SetBulletName", (PyCFunction) _wrap_TextAttr_SetBulletName, METH_VARARGS | METH_KEYWORDS, NULL},
 
51536
         { (char *)"TextAttr_SetURL", (PyCFunction) _wrap_TextAttr_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
 
51537
         { (char *)"TextAttr_SetPageBreak", (PyCFunction) _wrap_TextAttr_SetPageBreak, METH_VARARGS | METH_KEYWORDS, NULL},
 
51538
         { (char *)"TextAttr_SetTextEffects", (PyCFunction) _wrap_TextAttr_SetTextEffects, METH_VARARGS | METH_KEYWORDS, NULL},
 
51539
         { (char *)"TextAttr_SetTextEffectFlags", (PyCFunction) _wrap_TextAttr_SetTextEffectFlags, METH_VARARGS | METH_KEYWORDS, NULL},
 
51540
         { (char *)"TextAttr_SetOutlineLevel", (PyCFunction) _wrap_TextAttr_SetOutlineLevel, METH_VARARGS | METH_KEYWORDS, NULL},
 
51541
         { (char *)"TextAttr_GetTextColour", (PyCFunction)_wrap_TextAttr_GetTextColour, METH_O, NULL},
 
51542
         { (char *)"TextAttr_GetBackgroundColour", (PyCFunction)_wrap_TextAttr_GetBackgroundColour, METH_O, NULL},
 
51543
         { (char *)"TextAttr_GetAlignment", (PyCFunction)_wrap_TextAttr_GetAlignment, METH_O, NULL},
 
51544
         { (char *)"TextAttr_GetTabs", (PyCFunction)_wrap_TextAttr_GetTabs, METH_O, NULL},
 
51545
         { (char *)"TextAttr_GetLeftIndent", (PyCFunction)_wrap_TextAttr_GetLeftIndent, METH_O, NULL},
 
51546
         { (char *)"TextAttr_GetLeftSubIndent", (PyCFunction)_wrap_TextAttr_GetLeftSubIndent, METH_O, NULL},
 
51547
         { (char *)"TextAttr_GetRightIndent", (PyCFunction)_wrap_TextAttr_GetRightIndent, METH_O, NULL},
 
51548
         { (char *)"TextAttr_GetFlags", (PyCFunction)_wrap_TextAttr_GetFlags, METH_O, NULL},
 
51549
         { (char *)"TextAttr_GetFontSize", (PyCFunction)_wrap_TextAttr_GetFontSize, METH_O, NULL},
 
51550
         { (char *)"TextAttr_GetFontStyle", (PyCFunction)_wrap_TextAttr_GetFontStyle, METH_O, NULL},
 
51551
         { (char *)"TextAttr_GetFontWeight", (PyCFunction)_wrap_TextAttr_GetFontWeight, METH_O, NULL},
 
51552
         { (char *)"TextAttr_GetFontUnderlined", (PyCFunction)_wrap_TextAttr_GetFontUnderlined, METH_O, NULL},
 
51553
         { (char *)"TextAttr_GetFontStrikethrough", (PyCFunction)_wrap_TextAttr_GetFontStrikethrough, METH_O, NULL},
 
51554
         { (char *)"TextAttr_GetFontFaceName", (PyCFunction)_wrap_TextAttr_GetFontFaceName, METH_O, NULL},
 
51555
         { (char *)"TextAttr_GetFontEncoding", (PyCFunction)_wrap_TextAttr_GetFontEncoding, METH_O, NULL},
 
51556
         { (char *)"TextAttr_GetFontFamily", (PyCFunction)_wrap_TextAttr_GetFontFamily, METH_O, NULL},
 
51557
         { (char *)"TextAttr_GetFont", (PyCFunction)_wrap_TextAttr_GetFont, METH_O, NULL},
 
51558
         { (char *)"TextAttr_GetCharacterStyleName", (PyCFunction)_wrap_TextAttr_GetCharacterStyleName, METH_O, NULL},
 
51559
         { (char *)"TextAttr_GetParagraphStyleName", (PyCFunction)_wrap_TextAttr_GetParagraphStyleName, METH_O, NULL},
 
51560
         { (char *)"TextAttr_GetListStyleName", (PyCFunction)_wrap_TextAttr_GetListStyleName, METH_O, NULL},
 
51561
         { (char *)"TextAttr_GetParagraphSpacingAfter", (PyCFunction)_wrap_TextAttr_GetParagraphSpacingAfter, METH_O, NULL},
 
51562
         { (char *)"TextAttr_GetParagraphSpacingBefore", (PyCFunction)_wrap_TextAttr_GetParagraphSpacingBefore, METH_O, NULL},
 
51563
         { (char *)"TextAttr_GetLineSpacing", (PyCFunction)_wrap_TextAttr_GetLineSpacing, METH_O, NULL},
 
51564
         { (char *)"TextAttr_GetBulletStyle", (PyCFunction)_wrap_TextAttr_GetBulletStyle, METH_O, NULL},
 
51565
         { (char *)"TextAttr_GetBulletNumber", (PyCFunction)_wrap_TextAttr_GetBulletNumber, METH_O, NULL},
 
51566
         { (char *)"TextAttr_GetBulletText", (PyCFunction)_wrap_TextAttr_GetBulletText, METH_O, NULL},
 
51567
         { (char *)"TextAttr_GetBulletFont", (PyCFunction)_wrap_TextAttr_GetBulletFont, METH_O, NULL},
 
51568
         { (char *)"TextAttr_GetBulletName", (PyCFunction)_wrap_TextAttr_GetBulletName, METH_O, NULL},
 
51569
         { (char *)"TextAttr_GetURL", (PyCFunction)_wrap_TextAttr_GetURL, METH_O, NULL},
 
51570
         { (char *)"TextAttr_GetTextEffects", (PyCFunction)_wrap_TextAttr_GetTextEffects, METH_O, NULL},
 
51571
         { (char *)"TextAttr_GetTextEffectFlags", (PyCFunction)_wrap_TextAttr_GetTextEffectFlags, METH_O, NULL},
 
51572
         { (char *)"TextAttr_GetOutlineLevel", (PyCFunction)_wrap_TextAttr_GetOutlineLevel, METH_O, NULL},
 
51573
         { (char *)"TextAttr_HasTextColour", (PyCFunction)_wrap_TextAttr_HasTextColour, METH_O, NULL},
 
51574
         { (char *)"TextAttr_HasBackgroundColour", (PyCFunction)_wrap_TextAttr_HasBackgroundColour, METH_O, NULL},
 
51575
         { (char *)"TextAttr_HasAlignment", (PyCFunction)_wrap_TextAttr_HasAlignment, METH_O, NULL},
 
51576
         { (char *)"TextAttr_HasTabs", (PyCFunction)_wrap_TextAttr_HasTabs, METH_O, NULL},
 
51577
         { (char *)"TextAttr_HasLeftIndent", (PyCFunction)_wrap_TextAttr_HasLeftIndent, METH_O, NULL},
 
51578
         { (char *)"TextAttr_HasRightIndent", (PyCFunction)_wrap_TextAttr_HasRightIndent, METH_O, NULL},
 
51579
         { (char *)"TextAttr_HasFontWeight", (PyCFunction)_wrap_TextAttr_HasFontWeight, METH_O, NULL},
 
51580
         { (char *)"TextAttr_HasFontSize", (PyCFunction)_wrap_TextAttr_HasFontSize, METH_O, NULL},
 
51581
         { (char *)"TextAttr_HasFontItalic", (PyCFunction)_wrap_TextAttr_HasFontItalic, METH_O, NULL},
 
51582
         { (char *)"TextAttr_HasFontUnderlined", (PyCFunction)_wrap_TextAttr_HasFontUnderlined, METH_O, NULL},
 
51583
         { (char *)"TextAttr_HasFontStrikethrough", (PyCFunction)_wrap_TextAttr_HasFontStrikethrough, METH_O, NULL},
 
51584
         { (char *)"TextAttr_HasFontFaceName", (PyCFunction)_wrap_TextAttr_HasFontFaceName, METH_O, NULL},
 
51585
         { (char *)"TextAttr_HasFontEncoding", (PyCFunction)_wrap_TextAttr_HasFontEncoding, METH_O, NULL},
 
51586
         { (char *)"TextAttr_HasFontFamily", (PyCFunction)_wrap_TextAttr_HasFontFamily, METH_O, NULL},
 
51587
         { (char *)"TextAttr_HasFont", (PyCFunction)_wrap_TextAttr_HasFont, METH_O, NULL},
 
51588
         { (char *)"TextAttr_HasParagraphSpacingAfter", (PyCFunction)_wrap_TextAttr_HasParagraphSpacingAfter, METH_O, NULL},
 
51589
         { (char *)"TextAttr_HasParagraphSpacingBefore", (PyCFunction)_wrap_TextAttr_HasParagraphSpacingBefore, METH_O, NULL},
 
51590
         { (char *)"TextAttr_HasLineSpacing", (PyCFunction)_wrap_TextAttr_HasLineSpacing, METH_O, NULL},
 
51591
         { (char *)"TextAttr_HasCharacterStyleName", (PyCFunction)_wrap_TextAttr_HasCharacterStyleName, METH_O, NULL},
 
51592
         { (char *)"TextAttr_HasParagraphStyleName", (PyCFunction)_wrap_TextAttr_HasParagraphStyleName, METH_O, NULL},
 
51593
         { (char *)"TextAttr_HasListStyleName", (PyCFunction)_wrap_TextAttr_HasListStyleName, METH_O, NULL},
 
51594
         { (char *)"TextAttr_HasBulletStyle", (PyCFunction)_wrap_TextAttr_HasBulletStyle, METH_O, NULL},
 
51595
         { (char *)"TextAttr_HasBulletNumber", (PyCFunction)_wrap_TextAttr_HasBulletNumber, METH_O, NULL},
 
51596
         { (char *)"TextAttr_HasBulletText", (PyCFunction)_wrap_TextAttr_HasBulletText, METH_O, NULL},
 
51597
         { (char *)"TextAttr_HasBulletName", (PyCFunction)_wrap_TextAttr_HasBulletName, METH_O, NULL},
 
51598
         { (char *)"TextAttr_HasURL", (PyCFunction)_wrap_TextAttr_HasURL, METH_O, NULL},
 
51599
         { (char *)"TextAttr_HasPageBreak", (PyCFunction)_wrap_TextAttr_HasPageBreak, METH_O, NULL},
 
51600
         { (char *)"TextAttr_HasTextEffects", (PyCFunction)_wrap_TextAttr_HasTextEffects, METH_O, NULL},
 
51601
         { (char *)"TextAttr_HasTextEffect", (PyCFunction) _wrap_TextAttr_HasTextEffect, METH_VARARGS | METH_KEYWORDS, NULL},
 
51602
         { (char *)"TextAttr_HasOutlineLevel", (PyCFunction)_wrap_TextAttr_HasOutlineLevel, METH_O, NULL},
 
51603
         { (char *)"TextAttr_HasFlag", (PyCFunction) _wrap_TextAttr_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
 
51604
         { (char *)"TextAttr_RemoveFlag", (PyCFunction) _wrap_TextAttr_RemoveFlag, METH_VARARGS | METH_KEYWORDS, NULL},
 
51605
         { (char *)"TextAttr_AddFlag", (PyCFunction) _wrap_TextAttr_AddFlag, METH_VARARGS | METH_KEYWORDS, NULL},
 
51606
         { (char *)"TextAttr_IsCharacterStyle", (PyCFunction)_wrap_TextAttr_IsCharacterStyle, METH_O, NULL},
 
51607
         { (char *)"TextAttr_IsParagraphStyle", (PyCFunction)_wrap_TextAttr_IsParagraphStyle, METH_O, NULL},
 
51608
         { (char *)"TextAttr_IsDefault", (PyCFunction)_wrap_TextAttr_IsDefault, METH_O, NULL},
 
51609
         { (char *)"TextAttr_Apply", (PyCFunction) _wrap_TextAttr_Apply, METH_VARARGS | METH_KEYWORDS, NULL},
 
51610
         { (char *)"TextAttr_Merge", (PyCFunction) _wrap_TextAttr_Merge, METH_VARARGS | METH_KEYWORDS, NULL},
 
51611
         { (char *)"TextAttr_Combine", (PyCFunction) _wrap_TextAttr_Combine, METH_VARARGS | METH_KEYWORDS, NULL},
 
51612
         { (char *)"TextAttr_TabsEq", (PyCFunction) _wrap_TextAttr_TabsEq, METH_VARARGS | METH_KEYWORDS, NULL},
 
51613
         { (char *)"TextAttr_RemoveStyle", (PyCFunction) _wrap_TextAttr_RemoveStyle, METH_VARARGS | METH_KEYWORDS, NULL},
 
51614
         { (char *)"TextAttr_CombineBitlists", (PyCFunction) _wrap_TextAttr_CombineBitlists, METH_VARARGS | METH_KEYWORDS, NULL},
 
51615
         { (char *)"TextAttr_BitlistsEqPartial", (PyCFunction) _wrap_TextAttr_BitlistsEqPartial, METH_VARARGS | METH_KEYWORDS, NULL},
 
51616
         { (char *)"TextAttr_SplitParaCharStyles", (PyCFunction) _wrap_TextAttr_SplitParaCharStyles, METH_VARARGS | METH_KEYWORDS, NULL},
 
51617
         { (char *)"TextAttr_swigregister", TextAttr_swigregister, METH_VARARGS, NULL},
 
51618
         { (char *)"TextAttr_swiginit", TextAttr_swiginit, METH_VARARGS, NULL},
 
51619
         { (char *)"new_TextCtrl", (PyCFunction) _wrap_new_TextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
51620
         { (char *)"new_PreTextCtrl", (PyCFunction)_wrap_new_PreTextCtrl, METH_NOARGS, NULL},
 
51621
         { (char *)"TextCtrl_Create", (PyCFunction) _wrap_TextCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51622
         { (char *)"TextCtrl_IsSingleLine", (PyCFunction)_wrap_TextCtrl_IsSingleLine, METH_O, NULL},
 
51623
         { (char *)"TextCtrl_IsMultiLine", (PyCFunction)_wrap_TextCtrl_IsMultiLine, METH_O, NULL},
 
51624
         { (char *)"TextCtrl_EmulateKeyPress", (PyCFunction) _wrap_TextCtrl_EmulateKeyPress, METH_VARARGS | METH_KEYWORDS, NULL},
 
51625
         { (char *)"TextCtrl_MacCheckSpelling", (PyCFunction) _wrap_TextCtrl_MacCheckSpelling, METH_VARARGS | METH_KEYWORDS, NULL},
 
51626
         { (char *)"TextCtrl_SendTextUpdatedEvent", (PyCFunction)_wrap_TextCtrl_SendTextUpdatedEvent, METH_O, NULL},
 
51627
         { (char *)"TextCtrl_write", (PyCFunction) _wrap_TextCtrl_write, METH_VARARGS | METH_KEYWORDS, NULL},
 
51628
         { (char *)"TextCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_TextCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51629
         { (char *)"TextCtrl_swigregister", TextCtrl_swigregister, METH_VARARGS, NULL},
 
51630
         { (char *)"TextCtrl_swiginit", TextCtrl_swiginit, METH_VARARGS, NULL},
 
51631
         { (char *)"new_TextUrlEvent", (PyCFunction) _wrap_new_TextUrlEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
51632
         { (char *)"TextUrlEvent_GetMouseEvent", (PyCFunction)_wrap_TextUrlEvent_GetMouseEvent, METH_O, NULL},
 
51633
         { (char *)"TextUrlEvent_GetURLStart", (PyCFunction)_wrap_TextUrlEvent_GetURLStart, METH_O, NULL},
 
51634
         { (char *)"TextUrlEvent_GetURLEnd", (PyCFunction)_wrap_TextUrlEvent_GetURLEnd, METH_O, NULL},
 
51635
         { (char *)"TextUrlEvent_swigregister", TextUrlEvent_swigregister, METH_VARARGS, NULL},
 
51636
         { (char *)"TextUrlEvent_swiginit", TextUrlEvent_swiginit, METH_VARARGS, NULL},
 
51637
         { (char *)"new_ScrollBar", (PyCFunction) _wrap_new_ScrollBar, METH_VARARGS | METH_KEYWORDS, NULL},
 
51638
         { (char *)"new_PreScrollBar", (PyCFunction)_wrap_new_PreScrollBar, METH_NOARGS, NULL},
 
51639
         { (char *)"ScrollBar_Create", (PyCFunction) _wrap_ScrollBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51640
         { (char *)"ScrollBar_GetThumbPosition", (PyCFunction)_wrap_ScrollBar_GetThumbPosition, METH_O, NULL},
 
51641
         { (char *)"ScrollBar_GetThumbSize", (PyCFunction)_wrap_ScrollBar_GetThumbSize, METH_O, NULL},
 
51642
         { (char *)"ScrollBar_GetPageSize", (PyCFunction)_wrap_ScrollBar_GetPageSize, METH_O, NULL},
 
51643
         { (char *)"ScrollBar_GetRange", (PyCFunction)_wrap_ScrollBar_GetRange, METH_O, NULL},
 
51644
         { (char *)"ScrollBar_IsVertical", (PyCFunction)_wrap_ScrollBar_IsVertical, METH_O, NULL},
 
51645
         { (char *)"ScrollBar_SetThumbPosition", (PyCFunction) _wrap_ScrollBar_SetThumbPosition, METH_VARARGS | METH_KEYWORDS, NULL},
 
51646
         { (char *)"ScrollBar_GetClassDefaultAttributes", (PyCFunction) _wrap_ScrollBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51647
         { (char *)"ScrollBar_swigregister", ScrollBar_swigregister, METH_VARARGS, NULL},
 
51648
         { (char *)"ScrollBar_swiginit", ScrollBar_swiginit, METH_VARARGS, NULL},
 
51649
         { (char *)"new_SpinButton", (PyCFunction) _wrap_new_SpinButton, METH_VARARGS | METH_KEYWORDS, NULL},
 
51650
         { (char *)"new_PreSpinButton", (PyCFunction)_wrap_new_PreSpinButton, METH_NOARGS, NULL},
 
51651
         { (char *)"SpinButton_Create", (PyCFunction) _wrap_SpinButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51652
         { (char *)"SpinButton_GetValue", (PyCFunction)_wrap_SpinButton_GetValue, METH_O, NULL},
 
51653
         { (char *)"SpinButton_GetMin", (PyCFunction)_wrap_SpinButton_GetMin, METH_O, NULL},
 
51654
         { (char *)"SpinButton_GetMax", (PyCFunction)_wrap_SpinButton_GetMax, METH_O, NULL},
 
51655
         { (char *)"SpinButton_SetValue", (PyCFunction) _wrap_SpinButton_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51656
         { (char *)"SpinButton_SetMin", (PyCFunction) _wrap_SpinButton_SetMin, METH_VARARGS | METH_KEYWORDS, NULL},
 
51657
         { (char *)"SpinButton_SetMax", (PyCFunction) _wrap_SpinButton_SetMax, METH_VARARGS | METH_KEYWORDS, NULL},
 
51658
         { (char *)"SpinButton_SetRange", (PyCFunction) _wrap_SpinButton_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
 
51659
         { (char *)"SpinButton_IsVertical", (PyCFunction)_wrap_SpinButton_IsVertical, METH_O, NULL},
 
51660
         { (char *)"SpinButton_GetClassDefaultAttributes", (PyCFunction) _wrap_SpinButton_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51661
         { (char *)"SpinButton_swigregister", SpinButton_swigregister, METH_VARARGS, NULL},
 
51662
         { (char *)"SpinButton_swiginit", SpinButton_swiginit, METH_VARARGS, NULL},
 
51663
         { (char *)"new_SpinCtrl", (PyCFunction) _wrap_new_SpinCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
51664
         { (char *)"new_PreSpinCtrl", (PyCFunction)_wrap_new_PreSpinCtrl, METH_NOARGS, NULL},
 
51665
         { (char *)"SpinCtrl_Create", (PyCFunction) _wrap_SpinCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51666
         { (char *)"SpinCtrl_GetValue", (PyCFunction)_wrap_SpinCtrl_GetValue, METH_O, NULL},
 
51667
         { (char *)"SpinCtrl_SetValue", (PyCFunction) _wrap_SpinCtrl_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51668
         { (char *)"SpinCtrl_SetValueString", (PyCFunction) _wrap_SpinCtrl_SetValueString, METH_VARARGS | METH_KEYWORDS, NULL},
 
51669
         { (char *)"SpinCtrl_SetRange", (PyCFunction) _wrap_SpinCtrl_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
 
51670
         { (char *)"SpinCtrl_GetMin", (PyCFunction)_wrap_SpinCtrl_GetMin, METH_O, NULL},
 
51671
         { (char *)"SpinCtrl_GetMax", (PyCFunction)_wrap_SpinCtrl_GetMax, METH_O, NULL},
 
51672
         { (char *)"SpinCtrl_SetSelection", (PyCFunction) _wrap_SpinCtrl_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
 
51673
         { (char *)"SpinCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_SpinCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51674
         { (char *)"SpinCtrl_swigregister", SpinCtrl_swigregister, METH_VARARGS, NULL},
 
51675
         { (char *)"SpinCtrl_swiginit", SpinCtrl_swiginit, METH_VARARGS, NULL},
 
51676
         { (char *)"new_SpinEvent", (PyCFunction) _wrap_new_SpinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
51677
         { (char *)"SpinEvent_GetPosition", (PyCFunction)_wrap_SpinEvent_GetPosition, METH_O, NULL},
 
51678
         { (char *)"SpinEvent_SetPosition", (PyCFunction) _wrap_SpinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
 
51679
         { (char *)"SpinEvent_GetValue", (PyCFunction)_wrap_SpinEvent_GetValue, METH_O, NULL},
 
51680
         { (char *)"SpinEvent_SetValue", (PyCFunction) _wrap_SpinEvent_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51681
         { (char *)"SpinEvent_swigregister", SpinEvent_swigregister, METH_VARARGS, NULL},
 
51682
         { (char *)"SpinEvent_swiginit", SpinEvent_swiginit, METH_VARARGS, NULL},
 
51683
         { (char *)"new_SpinCtrlDouble", (PyCFunction) _wrap_new_SpinCtrlDouble, METH_VARARGS | METH_KEYWORDS, NULL},
 
51684
         { (char *)"new_PreSpinCtrlDouble", (PyCFunction)_wrap_new_PreSpinCtrlDouble, METH_NOARGS, NULL},
 
51685
         { (char *)"SpinCtrlDouble_Create", (PyCFunction) _wrap_SpinCtrlDouble_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51686
         { (char *)"SpinCtrlDouble_GetValue", (PyCFunction)_wrap_SpinCtrlDouble_GetValue, METH_O, NULL},
 
51687
         { (char *)"SpinCtrlDouble_GetMin", (PyCFunction)_wrap_SpinCtrlDouble_GetMin, METH_O, NULL},
 
51688
         { (char *)"SpinCtrlDouble_GetMax", (PyCFunction)_wrap_SpinCtrlDouble_GetMax, METH_O, NULL},
 
51689
         { (char *)"SpinCtrlDouble_GetIncrement", (PyCFunction)_wrap_SpinCtrlDouble_GetIncrement, METH_O, NULL},
 
51690
         { (char *)"SpinCtrlDouble_GetDigits", (PyCFunction)_wrap_SpinCtrlDouble_GetDigits, METH_O, NULL},
 
51691
         { (char *)"SpinCtrlDouble_SetValue", (PyCFunction) _wrap_SpinCtrlDouble_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51692
         { (char *)"SpinCtrlDouble_SetRange", (PyCFunction) _wrap_SpinCtrlDouble_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
 
51693
         { (char *)"SpinCtrlDouble_SetIncrement", (PyCFunction) _wrap_SpinCtrlDouble_SetIncrement, METH_VARARGS | METH_KEYWORDS, NULL},
 
51694
         { (char *)"SpinCtrlDouble_SetDigits", (PyCFunction) _wrap_SpinCtrlDouble_SetDigits, METH_VARARGS | METH_KEYWORDS, NULL},
 
51695
         { (char *)"SpinCtrlDouble_swigregister", SpinCtrlDouble_swigregister, METH_VARARGS, NULL},
 
51696
         { (char *)"SpinCtrlDouble_swiginit", SpinCtrlDouble_swiginit, METH_VARARGS, NULL},
 
51697
         { (char *)"new_SpinDoubleEvent", (PyCFunction) _wrap_new_SpinDoubleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
51698
         { (char *)"SpinDoubleEvent_GetValue", (PyCFunction)_wrap_SpinDoubleEvent_GetValue, METH_O, NULL},
 
51699
         { (char *)"SpinDoubleEvent_SetValue", (PyCFunction) _wrap_SpinDoubleEvent_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51700
         { (char *)"SpinDoubleEvent_swigregister", SpinDoubleEvent_swigregister, METH_VARARGS, NULL},
 
51701
         { (char *)"SpinDoubleEvent_swiginit", SpinDoubleEvent_swiginit, METH_VARARGS, NULL},
 
51702
         { (char *)"new_RadioBox", (PyCFunction) _wrap_new_RadioBox, METH_VARARGS | METH_KEYWORDS, NULL},
 
51703
         { (char *)"new_PreRadioBox", (PyCFunction)_wrap_new_PreRadioBox, METH_NOARGS, NULL},
 
51704
         { (char *)"RadioBox_Create", (PyCFunction) _wrap_RadioBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51705
         { (char *)"RadioBox_SetSelection", (PyCFunction) _wrap_RadioBox_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
 
51706
         { (char *)"RadioBox_GetSelection", (PyCFunction)_wrap_RadioBox_GetSelection, METH_O, NULL},
 
51707
         { (char *)"RadioBox_GetStringSelection", (PyCFunction)_wrap_RadioBox_GetStringSelection, METH_O, NULL},
 
51708
         { (char *)"RadioBox_SetStringSelection", (PyCFunction) _wrap_RadioBox_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
 
51709
         { (char *)"RadioBox_GetCount", (PyCFunction)_wrap_RadioBox_GetCount, METH_O, NULL},
 
51710
         { (char *)"RadioBox_FindString", (PyCFunction) _wrap_RadioBox_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
 
51711
         { (char *)"RadioBox_GetString", (PyCFunction) _wrap_RadioBox_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
 
51712
         { (char *)"RadioBox_SetString", (PyCFunction) _wrap_RadioBox_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
 
51713
         { (char *)"RadioBox_EnableItem", (PyCFunction) _wrap_RadioBox_EnableItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
51714
         { (char *)"RadioBox_ShowItem", (PyCFunction) _wrap_RadioBox_ShowItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
51715
         { (char *)"RadioBox_IsItemEnabled", (PyCFunction) _wrap_RadioBox_IsItemEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
 
51716
         { (char *)"RadioBox_IsItemShown", (PyCFunction) _wrap_RadioBox_IsItemShown, METH_VARARGS | METH_KEYWORDS, NULL},
 
51717
         { (char *)"RadioBox_GetColumnCount", (PyCFunction)_wrap_RadioBox_GetColumnCount, METH_O, NULL},
 
51718
         { (char *)"RadioBox_GetRowCount", (PyCFunction)_wrap_RadioBox_GetRowCount, METH_O, NULL},
 
51719
         { (char *)"RadioBox_GetNextItem", (PyCFunction) _wrap_RadioBox_GetNextItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
51720
         { (char *)"RadioBox_SetItemToolTip", (PyCFunction) _wrap_RadioBox_SetItemToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
 
51721
         { (char *)"RadioBox_GetItemToolTip", (PyCFunction) _wrap_RadioBox_GetItemToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
 
51722
         { (char *)"RadioBox_SetItemHelpText", (PyCFunction) _wrap_RadioBox_SetItemHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
 
51723
         { (char *)"RadioBox_GetItemHelpText", (PyCFunction) _wrap_RadioBox_GetItemHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
 
51724
         { (char *)"RadioBox_GetClassDefaultAttributes", (PyCFunction) _wrap_RadioBox_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51725
         { (char *)"RadioBox_swigregister", RadioBox_swigregister, METH_VARARGS, NULL},
 
51726
         { (char *)"RadioBox_swiginit", RadioBox_swiginit, METH_VARARGS, NULL},
 
51727
         { (char *)"new_RadioButton", (PyCFunction) _wrap_new_RadioButton, METH_VARARGS | METH_KEYWORDS, NULL},
 
51728
         { (char *)"new_PreRadioButton", (PyCFunction)_wrap_new_PreRadioButton, METH_NOARGS, NULL},
 
51729
         { (char *)"RadioButton_Create", (PyCFunction) _wrap_RadioButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51730
         { (char *)"RadioButton_GetValue", (PyCFunction)_wrap_RadioButton_GetValue, METH_O, NULL},
 
51731
         { (char *)"RadioButton_SetValue", (PyCFunction) _wrap_RadioButton_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51732
         { (char *)"RadioButton_GetClassDefaultAttributes", (PyCFunction) _wrap_RadioButton_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51733
         { (char *)"RadioButton_swigregister", RadioButton_swigregister, METH_VARARGS, NULL},
 
51734
         { (char *)"RadioButton_swiginit", RadioButton_swiginit, METH_VARARGS, NULL},
 
51735
         { (char *)"new_Slider", (PyCFunction) _wrap_new_Slider, METH_VARARGS | METH_KEYWORDS, NULL},
 
51736
         { (char *)"new_PreSlider", (PyCFunction)_wrap_new_PreSlider, METH_NOARGS, NULL},
 
51737
         { (char *)"Slider_Create", (PyCFunction) _wrap_Slider_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51738
         { (char *)"Slider_GetValue", (PyCFunction)_wrap_Slider_GetValue, METH_O, NULL},
 
51739
         { (char *)"Slider_SetValue", (PyCFunction) _wrap_Slider_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51740
         { (char *)"Slider_GetMin", (PyCFunction)_wrap_Slider_GetMin, METH_O, NULL},
 
51741
         { (char *)"Slider_GetMax", (PyCFunction)_wrap_Slider_GetMax, METH_O, NULL},
 
51742
         { (char *)"Slider_SetMin", (PyCFunction) _wrap_Slider_SetMin, METH_VARARGS | METH_KEYWORDS, NULL},
 
51743
         { (char *)"Slider_SetMax", (PyCFunction) _wrap_Slider_SetMax, METH_VARARGS | METH_KEYWORDS, NULL},
 
51744
         { (char *)"Slider_SetRange", (PyCFunction) _wrap_Slider_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
 
51745
         { (char *)"Slider_SetLineSize", (PyCFunction) _wrap_Slider_SetLineSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
51746
         { (char *)"Slider_SetPageSize", (PyCFunction) _wrap_Slider_SetPageSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
51747
         { (char *)"Slider_GetLineSize", (PyCFunction)_wrap_Slider_GetLineSize, METH_O, NULL},
 
51748
         { (char *)"Slider_GetPageSize", (PyCFunction)_wrap_Slider_GetPageSize, METH_O, NULL},
 
51749
         { (char *)"Slider_SetThumbLength", (PyCFunction) _wrap_Slider_SetThumbLength, METH_VARARGS | METH_KEYWORDS, NULL},
 
51750
         { (char *)"Slider_GetThumbLength", (PyCFunction)_wrap_Slider_GetThumbLength, METH_O, NULL},
 
51751
         { (char *)"Slider_SetTickFreq", (PyCFunction) _wrap_Slider_SetTickFreq, METH_VARARGS | METH_KEYWORDS, NULL},
 
51752
         { (char *)"Slider_GetTickFreq", (PyCFunction)_wrap_Slider_GetTickFreq, METH_O, NULL},
 
51753
         { (char *)"Slider_ClearTicks", (PyCFunction)_wrap_Slider_ClearTicks, METH_O, NULL},
 
51754
         { (char *)"Slider_SetTick", (PyCFunction) _wrap_Slider_SetTick, METH_VARARGS | METH_KEYWORDS, NULL},
 
51755
         { (char *)"Slider_ClearSel", (PyCFunction)_wrap_Slider_ClearSel, METH_O, NULL},
 
51756
         { (char *)"Slider_GetSelEnd", (PyCFunction)_wrap_Slider_GetSelEnd, METH_O, NULL},
 
51757
         { (char *)"Slider_GetSelStart", (PyCFunction)_wrap_Slider_GetSelStart, METH_O, NULL},
 
51758
         { (char *)"Slider_SetSelection", (PyCFunction) _wrap_Slider_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
 
51759
         { (char *)"Slider_GetClassDefaultAttributes", (PyCFunction) _wrap_Slider_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51760
         { (char *)"Slider_swigregister", Slider_swigregister, METH_VARARGS, NULL},
 
51761
         { (char *)"Slider_swiginit", Slider_swiginit, METH_VARARGS, NULL},
 
51762
         { (char *)"new_ToggleButton", (PyCFunction) _wrap_new_ToggleButton, METH_VARARGS | METH_KEYWORDS, NULL},
 
51763
         { (char *)"new_PreToggleButton", (PyCFunction)_wrap_new_PreToggleButton, METH_NOARGS, NULL},
 
51764
         { (char *)"ToggleButton_Create", (PyCFunction) _wrap_ToggleButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51765
         { (char *)"ToggleButton_SetValue", (PyCFunction) _wrap_ToggleButton_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
51766
         { (char *)"ToggleButton_GetValue", (PyCFunction)_wrap_ToggleButton_GetValue, METH_O, NULL},
 
51767
         { (char *)"ToggleButton_GetClassDefaultAttributes", (PyCFunction) _wrap_ToggleButton_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51768
         { (char *)"ToggleButton_swigregister", ToggleButton_swigregister, METH_VARARGS, NULL},
 
51769
         { (char *)"ToggleButton_swiginit", ToggleButton_swiginit, METH_VARARGS, NULL},
 
51770
         { (char *)"new_Notebook", (PyCFunction) _wrap_new_Notebook, METH_VARARGS | METH_KEYWORDS, NULL},
 
51771
         { (char *)"new_PreNotebook", (PyCFunction)_wrap_new_PreNotebook, METH_NOARGS, NULL},
 
51772
         { (char *)"Notebook_Create", (PyCFunction) _wrap_Notebook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51773
         { (char *)"Notebook_GetRowCount", (PyCFunction)_wrap_Notebook_GetRowCount, METH_O, NULL},
 
51774
         { (char *)"Notebook_SetPadding", (PyCFunction) _wrap_Notebook_SetPadding, METH_VARARGS | METH_KEYWORDS, NULL},
 
51775
         { (char *)"Notebook_SetTabSize", (PyCFunction) _wrap_Notebook_SetTabSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
51776
         { (char *)"Notebook_GetThemeBackgroundColour", (PyCFunction)_wrap_Notebook_GetThemeBackgroundColour, METH_O, NULL},
 
51777
         { (char *)"Notebook_GetClassDefaultAttributes", (PyCFunction) _wrap_Notebook_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51778
         { (char *)"Notebook_SendPageChangingEvent", (PyCFunction) _wrap_Notebook_SendPageChangingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
51779
         { (char *)"Notebook_SendPageChangedEvent", (PyCFunction) _wrap_Notebook_SendPageChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
51780
         { (char *)"Notebook_swigregister", Notebook_swigregister, METH_VARARGS, NULL},
 
51781
         { (char *)"Notebook_swiginit", Notebook_swiginit, METH_VARARGS, NULL},
 
51782
         { (char *)"new_Listbook", (PyCFunction) _wrap_new_Listbook, METH_VARARGS | METH_KEYWORDS, NULL},
 
51783
         { (char *)"new_PreListbook", (PyCFunction)_wrap_new_PreListbook, METH_NOARGS, NULL},
 
51784
         { (char *)"Listbook_Create", (PyCFunction) _wrap_Listbook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51785
         { (char *)"Listbook_GetListView", (PyCFunction)_wrap_Listbook_GetListView, METH_O, NULL},
 
51786
         { (char *)"Listbook_swigregister", Listbook_swigregister, METH_VARARGS, NULL},
 
51787
         { (char *)"Listbook_swiginit", Listbook_swiginit, METH_VARARGS, NULL},
 
51788
         { (char *)"new_Choicebook", (PyCFunction) _wrap_new_Choicebook, METH_VARARGS | METH_KEYWORDS, NULL},
 
51789
         { (char *)"new_PreChoicebook", (PyCFunction)_wrap_new_PreChoicebook, METH_NOARGS, NULL},
 
51790
         { (char *)"Choicebook_Create", (PyCFunction) _wrap_Choicebook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51791
         { (char *)"Choicebook_GetChoiceCtrl", (PyCFunction)_wrap_Choicebook_GetChoiceCtrl, METH_O, NULL},
 
51792
         { (char *)"Choicebook_swigregister", Choicebook_swigregister, METH_VARARGS, NULL},
 
51793
         { (char *)"Choicebook_swiginit", Choicebook_swiginit, METH_VARARGS, NULL},
 
51794
         { (char *)"new_Treebook", (PyCFunction) _wrap_new_Treebook, METH_VARARGS | METH_KEYWORDS, NULL},
 
51795
         { (char *)"new_PreTreebook", (PyCFunction)_wrap_new_PreTreebook, METH_NOARGS, NULL},
 
51796
         { (char *)"Treebook_Create", (PyCFunction) _wrap_Treebook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51797
         { (char *)"Treebook_InsertSubPage", (PyCFunction) _wrap_Treebook_InsertSubPage, METH_VARARGS | METH_KEYWORDS, NULL},
 
51798
         { (char *)"Treebook_AddSubPage", (PyCFunction) _wrap_Treebook_AddSubPage, METH_VARARGS | METH_KEYWORDS, NULL},
 
51799
         { (char *)"Treebook_IsNodeExpanded", (PyCFunction) _wrap_Treebook_IsNodeExpanded, METH_VARARGS | METH_KEYWORDS, NULL},
 
51800
         { (char *)"Treebook_ExpandNode", (PyCFunction) _wrap_Treebook_ExpandNode, METH_VARARGS | METH_KEYWORDS, NULL},
 
51801
         { (char *)"Treebook_CollapseNode", (PyCFunction) _wrap_Treebook_CollapseNode, METH_VARARGS | METH_KEYWORDS, NULL},
 
51802
         { (char *)"Treebook_GetPageParent", (PyCFunction) _wrap_Treebook_GetPageParent, METH_VARARGS | METH_KEYWORDS, NULL},
 
51803
         { (char *)"Treebook_GetTreeCtrl", (PyCFunction)_wrap_Treebook_GetTreeCtrl, METH_O, NULL},
 
51804
         { (char *)"Treebook_swigregister", Treebook_swigregister, METH_VARARGS, NULL},
 
51805
         { (char *)"Treebook_swiginit", Treebook_swiginit, METH_VARARGS, NULL},
 
51806
         { (char *)"new_Toolbook", (PyCFunction) _wrap_new_Toolbook, METH_VARARGS | METH_KEYWORDS, NULL},
 
51807
         { (char *)"new_PreToolbook", (PyCFunction)_wrap_new_PreToolbook, METH_NOARGS, NULL},
 
51808
         { (char *)"Toolbook_Create", (PyCFunction) _wrap_Toolbook_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51809
         { (char *)"Toolbook_GetToolBar", (PyCFunction)_wrap_Toolbook_GetToolBar, METH_O, NULL},
 
51810
         { (char *)"Toolbook_Realize", (PyCFunction)_wrap_Toolbook_Realize, METH_O, NULL},
 
51811
         { (char *)"Toolbook_swigregister", Toolbook_swigregister, METH_VARARGS, NULL},
 
51812
         { (char *)"Toolbook_swiginit", Toolbook_swiginit, METH_VARARGS, NULL},
 
51813
         { (char *)"ToolBarToolBase_GetId", (PyCFunction)_wrap_ToolBarToolBase_GetId, METH_O, NULL},
 
51814
         { (char *)"ToolBarToolBase_GetControl", (PyCFunction)_wrap_ToolBarToolBase_GetControl, METH_O, NULL},
 
51815
         { (char *)"ToolBarToolBase_GetToolBar", (PyCFunction)_wrap_ToolBarToolBase_GetToolBar, METH_O, NULL},
 
51816
         { (char *)"ToolBarToolBase_IsStretchable", (PyCFunction)_wrap_ToolBarToolBase_IsStretchable, METH_O, NULL},
 
51817
         { (char *)"ToolBarToolBase_IsButton", (PyCFunction)_wrap_ToolBarToolBase_IsButton, METH_O, NULL},
 
51818
         { (char *)"ToolBarToolBase_IsControl", (PyCFunction)_wrap_ToolBarToolBase_IsControl, METH_O, NULL},
 
51819
         { (char *)"ToolBarToolBase_IsSeparator", (PyCFunction)_wrap_ToolBarToolBase_IsSeparator, METH_O, NULL},
 
51820
         { (char *)"ToolBarToolBase_IsStretchableSpace", (PyCFunction)_wrap_ToolBarToolBase_IsStretchableSpace, METH_O, NULL},
 
51821
         { (char *)"ToolBarToolBase_GetStyle", (PyCFunction)_wrap_ToolBarToolBase_GetStyle, METH_O, NULL},
 
51822
         { (char *)"ToolBarToolBase_GetKind", (PyCFunction)_wrap_ToolBarToolBase_GetKind, METH_O, NULL},
 
51823
         { (char *)"ToolBarToolBase_MakeStretchable", (PyCFunction)_wrap_ToolBarToolBase_MakeStretchable, METH_O, NULL},
 
51824
         { (char *)"ToolBarToolBase_IsEnabled", (PyCFunction)_wrap_ToolBarToolBase_IsEnabled, METH_O, NULL},
 
51825
         { (char *)"ToolBarToolBase_IsToggled", (PyCFunction)_wrap_ToolBarToolBase_IsToggled, METH_O, NULL},
 
51826
         { (char *)"ToolBarToolBase_CanBeToggled", (PyCFunction)_wrap_ToolBarToolBase_CanBeToggled, METH_O, NULL},
 
51827
         { (char *)"ToolBarToolBase_GetNormalBitmap", (PyCFunction)_wrap_ToolBarToolBase_GetNormalBitmap, METH_O, NULL},
 
51828
         { (char *)"ToolBarToolBase_GetDisabledBitmap", (PyCFunction)_wrap_ToolBarToolBase_GetDisabledBitmap, METH_O, NULL},
 
51829
         { (char *)"ToolBarToolBase_GetBitmap", (PyCFunction)_wrap_ToolBarToolBase_GetBitmap, METH_O, NULL},
 
51830
         { (char *)"ToolBarToolBase_GetLabel", (PyCFunction)_wrap_ToolBarToolBase_GetLabel, METH_O, NULL},
 
51831
         { (char *)"ToolBarToolBase_GetShortHelp", (PyCFunction)_wrap_ToolBarToolBase_GetShortHelp, METH_O, NULL},
 
51832
         { (char *)"ToolBarToolBase_GetLongHelp", (PyCFunction)_wrap_ToolBarToolBase_GetLongHelp, METH_O, NULL},
 
51833
         { (char *)"ToolBarToolBase_Enable", (PyCFunction) _wrap_ToolBarToolBase_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
 
51834
         { (char *)"ToolBarToolBase_Toggle", (PyCFunction)_wrap_ToolBarToolBase_Toggle, METH_O, NULL},
 
51835
         { (char *)"ToolBarToolBase_SetToggle", (PyCFunction) _wrap_ToolBarToolBase_SetToggle, METH_VARARGS | METH_KEYWORDS, NULL},
 
51836
         { (char *)"ToolBarToolBase_SetShortHelp", (PyCFunction) _wrap_ToolBarToolBase_SetShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
51837
         { (char *)"ToolBarToolBase_SetLongHelp", (PyCFunction) _wrap_ToolBarToolBase_SetLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
51838
         { (char *)"ToolBarToolBase_SetNormalBitmap", (PyCFunction) _wrap_ToolBarToolBase_SetNormalBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
51839
         { (char *)"ToolBarToolBase_SetDisabledBitmap", (PyCFunction) _wrap_ToolBarToolBase_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
51840
         { (char *)"ToolBarToolBase_SetLabel", (PyCFunction) _wrap_ToolBarToolBase_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
 
51841
         { (char *)"ToolBarToolBase_Detach", (PyCFunction)_wrap_ToolBarToolBase_Detach, METH_O, NULL},
 
51842
         { (char *)"ToolBarToolBase_Attach", (PyCFunction) _wrap_ToolBarToolBase_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
 
51843
         { (char *)"ToolBarToolBase_SetDropdownMenu", (PyCFunction) _wrap_ToolBarToolBase_SetDropdownMenu, METH_VARARGS | METH_KEYWORDS, NULL},
 
51844
         { (char *)"ToolBarToolBase_GetDropdownMenu", (PyCFunction)_wrap_ToolBarToolBase_GetDropdownMenu, METH_O, NULL},
 
51845
         { (char *)"ToolBarToolBase_GetClientData", (PyCFunction)_wrap_ToolBarToolBase_GetClientData, METH_O, NULL},
 
51846
         { (char *)"ToolBarToolBase_SetClientData", (PyCFunction) _wrap_ToolBarToolBase_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
 
51847
         { (char *)"ToolBarToolBase_swigregister", ToolBarToolBase_swigregister, METH_VARARGS, NULL},
 
51848
         { (char *)"ToolBarBase_DoAddTool", (PyCFunction) _wrap_ToolBarBase_DoAddTool, METH_VARARGS | METH_KEYWORDS, NULL},
 
51849
         { (char *)"ToolBarBase_DoInsertTool", (PyCFunction) _wrap_ToolBarBase_DoInsertTool, METH_VARARGS | METH_KEYWORDS, NULL},
 
51850
         { (char *)"ToolBarBase_AddToolItem", (PyCFunction) _wrap_ToolBarBase_AddToolItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
51851
         { (char *)"ToolBarBase_InsertToolItem", (PyCFunction) _wrap_ToolBarBase_InsertToolItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
51852
         { (char *)"ToolBarBase_AddControl", (PyCFunction) _wrap_ToolBarBase_AddControl, METH_VARARGS | METH_KEYWORDS, NULL},
 
51853
         { (char *)"ToolBarBase_InsertControl", (PyCFunction) _wrap_ToolBarBase_InsertControl, METH_VARARGS | METH_KEYWORDS, NULL},
 
51854
         { (char *)"ToolBarBase_FindControl", (PyCFunction) _wrap_ToolBarBase_FindControl, METH_VARARGS | METH_KEYWORDS, NULL},
 
51855
         { (char *)"ToolBarBase_AddSeparator", (PyCFunction)_wrap_ToolBarBase_AddSeparator, METH_O, NULL},
 
51856
         { (char *)"ToolBarBase_InsertSeparator", (PyCFunction) _wrap_ToolBarBase_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
 
51857
         { (char *)"ToolBarBase_AddStretchableSpace", (PyCFunction)_wrap_ToolBarBase_AddStretchableSpace, METH_O, NULL},
 
51858
         { (char *)"ToolBarBase_InsertStretchableSpace", (PyCFunction) _wrap_ToolBarBase_InsertStretchableSpace, METH_VARARGS | METH_KEYWORDS, NULL},
 
51859
         { (char *)"ToolBarBase_RemoveTool", (PyCFunction) _wrap_ToolBarBase_RemoveTool, METH_VARARGS | METH_KEYWORDS, NULL},
 
51860
         { (char *)"ToolBarBase_DeleteToolByPos", (PyCFunction) _wrap_ToolBarBase_DeleteToolByPos, METH_VARARGS | METH_KEYWORDS, NULL},
 
51861
         { (char *)"ToolBarBase_DeleteTool", (PyCFunction) _wrap_ToolBarBase_DeleteTool, METH_VARARGS | METH_KEYWORDS, NULL},
 
51862
         { (char *)"ToolBarBase_ClearTools", (PyCFunction)_wrap_ToolBarBase_ClearTools, METH_O, NULL},
 
51863
         { (char *)"ToolBarBase_Realize", (PyCFunction)_wrap_ToolBarBase_Realize, METH_O, NULL},
 
51864
         { (char *)"ToolBarBase_EnableTool", (PyCFunction) _wrap_ToolBarBase_EnableTool, METH_VARARGS | METH_KEYWORDS, NULL},
 
51865
         { (char *)"ToolBarBase_ToggleTool", (PyCFunction) _wrap_ToolBarBase_ToggleTool, METH_VARARGS | METH_KEYWORDS, NULL},
 
51866
         { (char *)"ToolBarBase_SetToggle", (PyCFunction) _wrap_ToolBarBase_SetToggle, METH_VARARGS | METH_KEYWORDS, NULL},
 
51867
         { (char *)"ToolBarBase_GetToolClientData", (PyCFunction) _wrap_ToolBarBase_GetToolClientData, METH_VARARGS | METH_KEYWORDS, NULL},
 
51868
         { (char *)"ToolBarBase_SetToolClientData", (PyCFunction) _wrap_ToolBarBase_SetToolClientData, METH_VARARGS | METH_KEYWORDS, NULL},
 
51869
         { (char *)"ToolBarBase_GetToolPos", (PyCFunction) _wrap_ToolBarBase_GetToolPos, METH_VARARGS | METH_KEYWORDS, NULL},
 
51870
         { (char *)"ToolBarBase_GetToolState", (PyCFunction) _wrap_ToolBarBase_GetToolState, METH_VARARGS | METH_KEYWORDS, NULL},
 
51871
         { (char *)"ToolBarBase_GetToolEnabled", (PyCFunction) _wrap_ToolBarBase_GetToolEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
 
51872
         { (char *)"ToolBarBase_SetToolShortHelp", (PyCFunction) _wrap_ToolBarBase_SetToolShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
51873
         { (char *)"ToolBarBase_GetToolShortHelp", (PyCFunction) _wrap_ToolBarBase_GetToolShortHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
51874
         { (char *)"ToolBarBase_SetToolLongHelp", (PyCFunction) _wrap_ToolBarBase_SetToolLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
51875
         { (char *)"ToolBarBase_GetToolLongHelp", (PyCFunction) _wrap_ToolBarBase_GetToolLongHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
51876
         { (char *)"ToolBarBase_SetMarginsXY", (PyCFunction) _wrap_ToolBarBase_SetMarginsXY, METH_VARARGS | METH_KEYWORDS, NULL},
 
51877
         { (char *)"ToolBarBase_SetMargins", (PyCFunction) _wrap_ToolBarBase_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
 
51878
         { (char *)"ToolBarBase_SetToolPacking", (PyCFunction) _wrap_ToolBarBase_SetToolPacking, METH_VARARGS | METH_KEYWORDS, NULL},
 
51879
         { (char *)"ToolBarBase_SetToolSeparation", (PyCFunction) _wrap_ToolBarBase_SetToolSeparation, METH_VARARGS | METH_KEYWORDS, NULL},
 
51880
         { (char *)"ToolBarBase_GetToolMargins", (PyCFunction)_wrap_ToolBarBase_GetToolMargins, METH_O, NULL},
 
51881
         { (char *)"ToolBarBase_GetMargins", (PyCFunction)_wrap_ToolBarBase_GetMargins, METH_O, NULL},
 
51882
         { (char *)"ToolBarBase_GetToolPacking", (PyCFunction)_wrap_ToolBarBase_GetToolPacking, METH_O, NULL},
 
51883
         { (char *)"ToolBarBase_GetToolSeparation", (PyCFunction)_wrap_ToolBarBase_GetToolSeparation, METH_O, NULL},
 
51884
         { (char *)"ToolBarBase_SetRows", (PyCFunction) _wrap_ToolBarBase_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
 
51885
         { (char *)"ToolBarBase_SetMaxRowsCols", (PyCFunction) _wrap_ToolBarBase_SetMaxRowsCols, METH_VARARGS | METH_KEYWORDS, NULL},
 
51886
         { (char *)"ToolBarBase_GetMaxRows", (PyCFunction)_wrap_ToolBarBase_GetMaxRows, METH_O, NULL},
 
51887
         { (char *)"ToolBarBase_GetMaxCols", (PyCFunction)_wrap_ToolBarBase_GetMaxCols, METH_O, NULL},
 
51888
         { (char *)"ToolBarBase_SetToolBitmapSize", (PyCFunction) _wrap_ToolBarBase_SetToolBitmapSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
51889
         { (char *)"ToolBarBase_GetToolBitmapSize", (PyCFunction)_wrap_ToolBarBase_GetToolBitmapSize, METH_O, NULL},
 
51890
         { (char *)"ToolBarBase_GetToolSize", (PyCFunction)_wrap_ToolBarBase_GetToolSize, METH_O, NULL},
 
51891
         { (char *)"ToolBarBase_FindToolForPosition", (PyCFunction) _wrap_ToolBarBase_FindToolForPosition, METH_VARARGS | METH_KEYWORDS, NULL},
 
51892
         { (char *)"ToolBarBase_FindById", (PyCFunction) _wrap_ToolBarBase_FindById, METH_VARARGS | METH_KEYWORDS, NULL},
 
51893
         { (char *)"ToolBarBase_IsVertical", (PyCFunction)_wrap_ToolBarBase_IsVertical, METH_O, NULL},
 
51894
         { (char *)"ToolBarBase_GetToolsCount", (PyCFunction)_wrap_ToolBarBase_GetToolsCount, METH_O, NULL},
 
51895
         { (char *)"ToolBarBase_GetToolByPos", (PyCFunction) _wrap_ToolBarBase_GetToolByPos, METH_VARARGS | METH_KEYWORDS, NULL},
 
51896
         { (char *)"ToolBarBase_SetDropdownMenu", (PyCFunction) _wrap_ToolBarBase_SetDropdownMenu, METH_VARARGS | METH_KEYWORDS, NULL},
 
51897
         { (char *)"ToolBarBase_swigregister", ToolBarBase_swigregister, METH_VARARGS, NULL},
 
51898
         { (char *)"new_ToolBar", (PyCFunction) _wrap_new_ToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
 
51899
         { (char *)"new_PreToolBar", (PyCFunction)_wrap_new_PreToolBar, METH_NOARGS, NULL},
 
51900
         { (char *)"ToolBar_Create", (PyCFunction) _wrap_ToolBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
51901
         { (char *)"ToolBar_SetToolNormalBitmap", (PyCFunction) _wrap_ToolBar_SetToolNormalBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
51902
         { (char *)"ToolBar_SetToolDisabledBitmap", (PyCFunction) _wrap_ToolBar_SetToolDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
51903
         { (char *)"ToolBar_GetClassDefaultAttributes", (PyCFunction) _wrap_ToolBar_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
51904
         { (char *)"ToolBar_swigregister", ToolBar_swigregister, METH_VARARGS, NULL},
 
51905
         { (char *)"ToolBar_swiginit", ToolBar_swiginit, METH_VARARGS, NULL},
 
51906
         { (char *)"new_ListItemAttr", (PyCFunction) _wrap_new_ListItemAttr, METH_VARARGS | METH_KEYWORDS, NULL},
 
51907
         { (char *)"delete_ListItemAttr", (PyCFunction)_wrap_delete_ListItemAttr, METH_O, NULL},
 
51908
         { (char *)"ListItemAttr_SetTextColour", (PyCFunction) _wrap_ListItemAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
51909
         { (char *)"ListItemAttr_SetBackgroundColour", (PyCFunction) _wrap_ListItemAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
51910
         { (char *)"ListItemAttr_SetFont", (PyCFunction) _wrap_ListItemAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
51911
         { (char *)"ListItemAttr_HasTextColour", (PyCFunction)_wrap_ListItemAttr_HasTextColour, METH_O, NULL},
 
51912
         { (char *)"ListItemAttr_HasBackgroundColour", (PyCFunction)_wrap_ListItemAttr_HasBackgroundColour, METH_O, NULL},
 
51913
         { (char *)"ListItemAttr_HasFont", (PyCFunction)_wrap_ListItemAttr_HasFont, METH_O, NULL},
 
51914
         { (char *)"ListItemAttr_GetTextColour", (PyCFunction)_wrap_ListItemAttr_GetTextColour, METH_O, NULL},
 
51915
         { (char *)"ListItemAttr_GetBackgroundColour", (PyCFunction)_wrap_ListItemAttr_GetBackgroundColour, METH_O, NULL},
 
51916
         { (char *)"ListItemAttr_GetFont", (PyCFunction)_wrap_ListItemAttr_GetFont, METH_O, NULL},
 
51917
         { (char *)"ListItemAttr_AssignFrom", (PyCFunction) _wrap_ListItemAttr_AssignFrom, METH_VARARGS | METH_KEYWORDS, NULL},
 
51918
         { (char *)"ListItemAttr_Destroy", (PyCFunction)_wrap_ListItemAttr_Destroy, METH_O, NULL},
 
51919
         { (char *)"ListItemAttr_swigregister", ListItemAttr_swigregister, METH_VARARGS, NULL},
 
51920
         { (char *)"ListItemAttr_swiginit", ListItemAttr_swiginit, METH_VARARGS, NULL},
 
51921
         { (char *)"new_ListItem", (PyCFunction)_wrap_new_ListItem, METH_NOARGS, NULL},
 
51922
         { (char *)"delete_ListItem", (PyCFunction)_wrap_delete_ListItem, METH_O, NULL},
 
51923
         { (char *)"ListItem_Clear", (PyCFunction)_wrap_ListItem_Clear, METH_O, NULL},
 
51924
         { (char *)"ListItem_ClearAttributes", (PyCFunction)_wrap_ListItem_ClearAttributes, METH_O, NULL},
 
51925
         { (char *)"ListItem_SetMask", (PyCFunction) _wrap_ListItem_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
 
51926
         { (char *)"ListItem_SetId", (PyCFunction) _wrap_ListItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
 
51927
         { (char *)"ListItem_SetColumn", (PyCFunction) _wrap_ListItem_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
 
51928
         { (char *)"ListItem_SetState", (PyCFunction) _wrap_ListItem_SetState, METH_VARARGS | METH_KEYWORDS, NULL},
 
51929
         { (char *)"ListItem_SetStateMask", (PyCFunction) _wrap_ListItem_SetStateMask, METH_VARARGS | METH_KEYWORDS, NULL},
 
51930
         { (char *)"ListItem_SetText", (PyCFunction) _wrap_ListItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
 
51931
         { (char *)"ListItem_SetImage", (PyCFunction) _wrap_ListItem_SetImage, METH_VARARGS | METH_KEYWORDS, NULL},
 
51932
         { (char *)"ListItem_SetData", (PyCFunction) _wrap_ListItem_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
 
51933
         { (char *)"ListItem_SetWidth", (PyCFunction) _wrap_ListItem_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
 
51934
         { (char *)"ListItem_SetAlign", (PyCFunction) _wrap_ListItem_SetAlign, METH_VARARGS | METH_KEYWORDS, NULL},
 
51935
         { (char *)"ListItem_SetTextColour", (PyCFunction) _wrap_ListItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
51936
         { (char *)"ListItem_SetBackgroundColour", (PyCFunction) _wrap_ListItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
51937
         { (char *)"ListItem_SetFont", (PyCFunction) _wrap_ListItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
51938
         { (char *)"ListItem_GetMask", (PyCFunction)_wrap_ListItem_GetMask, METH_O, NULL},
 
51939
         { (char *)"ListItem_GetId", (PyCFunction)_wrap_ListItem_GetId, METH_O, NULL},
 
51940
         { (char *)"ListItem_GetColumn", (PyCFunction)_wrap_ListItem_GetColumn, METH_O, NULL},
 
51941
         { (char *)"ListItem_GetState", (PyCFunction)_wrap_ListItem_GetState, METH_O, NULL},
 
51942
         { (char *)"ListItem_GetText", (PyCFunction)_wrap_ListItem_GetText, METH_O, NULL},
 
51943
         { (char *)"ListItem_GetImage", (PyCFunction)_wrap_ListItem_GetImage, METH_O, NULL},
 
51944
         { (char *)"ListItem_GetData", (PyCFunction)_wrap_ListItem_GetData, METH_O, NULL},
 
51945
         { (char *)"ListItem_GetWidth", (PyCFunction)_wrap_ListItem_GetWidth, METH_O, NULL},
 
51946
         { (char *)"ListItem_GetAlign", (PyCFunction)_wrap_ListItem_GetAlign, METH_O, NULL},
 
51947
         { (char *)"ListItem_GetAttributes", (PyCFunction)_wrap_ListItem_GetAttributes, METH_O, NULL},
 
51948
         { (char *)"ListItem_HasAttributes", (PyCFunction)_wrap_ListItem_HasAttributes, METH_O, NULL},
 
51949
         { (char *)"ListItem_GetTextColour", (PyCFunction)_wrap_ListItem_GetTextColour, METH_O, NULL},
 
51950
         { (char *)"ListItem_GetBackgroundColour", (PyCFunction)_wrap_ListItem_GetBackgroundColour, METH_O, NULL},
 
51951
         { (char *)"ListItem_GetFont", (PyCFunction)_wrap_ListItem_GetFont, METH_O, NULL},
 
51952
         { (char *)"ListItem_m_mask_set", _wrap_ListItem_m_mask_set, METH_VARARGS, NULL},
 
51953
         { (char *)"ListItem_m_mask_get", (PyCFunction)_wrap_ListItem_m_mask_get, METH_O, NULL},
 
51954
         { (char *)"ListItem_m_itemId_set", _wrap_ListItem_m_itemId_set, METH_VARARGS, NULL},
 
51955
         { (char *)"ListItem_m_itemId_get", (PyCFunction)_wrap_ListItem_m_itemId_get, METH_O, NULL},
 
51956
         { (char *)"ListItem_m_col_set", _wrap_ListItem_m_col_set, METH_VARARGS, NULL},
 
51957
         { (char *)"ListItem_m_col_get", (PyCFunction)_wrap_ListItem_m_col_get, METH_O, NULL},
 
51958
         { (char *)"ListItem_m_state_set", _wrap_ListItem_m_state_set, METH_VARARGS, NULL},
 
51959
         { (char *)"ListItem_m_state_get", (PyCFunction)_wrap_ListItem_m_state_get, METH_O, NULL},
 
51960
         { (char *)"ListItem_m_stateMask_set", _wrap_ListItem_m_stateMask_set, METH_VARARGS, NULL},
 
51961
         { (char *)"ListItem_m_stateMask_get", (PyCFunction)_wrap_ListItem_m_stateMask_get, METH_O, NULL},
 
51962
         { (char *)"ListItem_m_text_set", _wrap_ListItem_m_text_set, METH_VARARGS, NULL},
 
51963
         { (char *)"ListItem_m_text_get", (PyCFunction)_wrap_ListItem_m_text_get, METH_O, NULL},
 
51964
         { (char *)"ListItem_m_image_set", _wrap_ListItem_m_image_set, METH_VARARGS, NULL},
 
51965
         { (char *)"ListItem_m_image_get", (PyCFunction)_wrap_ListItem_m_image_get, METH_O, NULL},
 
51966
         { (char *)"ListItem_m_data_set", _wrap_ListItem_m_data_set, METH_VARARGS, NULL},
 
51967
         { (char *)"ListItem_m_data_get", (PyCFunction)_wrap_ListItem_m_data_get, METH_O, NULL},
 
51968
         { (char *)"ListItem_m_format_set", _wrap_ListItem_m_format_set, METH_VARARGS, NULL},
 
51969
         { (char *)"ListItem_m_format_get", (PyCFunction)_wrap_ListItem_m_format_get, METH_O, NULL},
 
51970
         { (char *)"ListItem_m_width_set", _wrap_ListItem_m_width_set, METH_VARARGS, NULL},
 
51971
         { (char *)"ListItem_m_width_get", (PyCFunction)_wrap_ListItem_m_width_get, METH_O, NULL},
 
51972
         { (char *)"ListItem_swigregister", ListItem_swigregister, METH_VARARGS, NULL},
 
51973
         { (char *)"ListItem_swiginit", ListItem_swiginit, METH_VARARGS, NULL},
 
51974
         { (char *)"new_ListEvent", (PyCFunction) _wrap_new_ListEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
51975
         { (char *)"ListEvent_m_code_set", _wrap_ListEvent_m_code_set, METH_VARARGS, NULL},
 
51976
         { (char *)"ListEvent_m_code_get", (PyCFunction)_wrap_ListEvent_m_code_get, METH_O, NULL},
 
51977
         { (char *)"ListEvent_m_oldItemIndex_set", _wrap_ListEvent_m_oldItemIndex_set, METH_VARARGS, NULL},
 
51978
         { (char *)"ListEvent_m_oldItemIndex_get", (PyCFunction)_wrap_ListEvent_m_oldItemIndex_get, METH_O, NULL},
 
51979
         { (char *)"ListEvent_m_itemIndex_set", _wrap_ListEvent_m_itemIndex_set, METH_VARARGS, NULL},
 
51980
         { (char *)"ListEvent_m_itemIndex_get", (PyCFunction)_wrap_ListEvent_m_itemIndex_get, METH_O, NULL},
 
51981
         { (char *)"ListEvent_m_col_set", _wrap_ListEvent_m_col_set, METH_VARARGS, NULL},
 
51982
         { (char *)"ListEvent_m_col_get", (PyCFunction)_wrap_ListEvent_m_col_get, METH_O, NULL},
 
51983
         { (char *)"ListEvent_m_pointDrag_set", _wrap_ListEvent_m_pointDrag_set, METH_VARARGS, NULL},
 
51984
         { (char *)"ListEvent_m_pointDrag_get", (PyCFunction)_wrap_ListEvent_m_pointDrag_get, METH_O, NULL},
 
51985
         { (char *)"ListEvent_m_item_get", (PyCFunction)_wrap_ListEvent_m_item_get, METH_O, NULL},
 
51986
         { (char *)"ListEvent_GetKeyCode", (PyCFunction)_wrap_ListEvent_GetKeyCode, METH_O, NULL},
 
51987
         { (char *)"ListEvent_GetIndex", (PyCFunction)_wrap_ListEvent_GetIndex, METH_O, NULL},
 
51988
         { (char *)"ListEvent_GetColumn", (PyCFunction)_wrap_ListEvent_GetColumn, METH_O, NULL},
 
51989
         { (char *)"ListEvent_GetPoint", (PyCFunction)_wrap_ListEvent_GetPoint, METH_O, NULL},
 
51990
         { (char *)"ListEvent_GetLabel", (PyCFunction)_wrap_ListEvent_GetLabel, METH_O, NULL},
 
51991
         { (char *)"ListEvent_GetText", (PyCFunction)_wrap_ListEvent_GetText, METH_O, NULL},
 
51992
         { (char *)"ListEvent_GetImage", (PyCFunction)_wrap_ListEvent_GetImage, METH_O, NULL},
 
51993
         { (char *)"ListEvent_GetData", (PyCFunction)_wrap_ListEvent_GetData, METH_O, NULL},
 
51994
         { (char *)"ListEvent_GetMask", (PyCFunction)_wrap_ListEvent_GetMask, METH_O, NULL},
 
51995
         { (char *)"ListEvent_GetItem", (PyCFunction)_wrap_ListEvent_GetItem, METH_O, NULL},
 
51996
         { (char *)"ListEvent_GetCacheFrom", (PyCFunction)_wrap_ListEvent_GetCacheFrom, METH_O, NULL},
 
51997
         { (char *)"ListEvent_GetCacheTo", (PyCFunction)_wrap_ListEvent_GetCacheTo, METH_O, NULL},
 
51998
         { (char *)"ListEvent_IsEditCancelled", (PyCFunction)_wrap_ListEvent_IsEditCancelled, METH_O, NULL},
 
51999
         { (char *)"ListEvent_SetEditCanceled", (PyCFunction) _wrap_ListEvent_SetEditCanceled, METH_VARARGS | METH_KEYWORDS, NULL},
 
52000
         { (char *)"ListEvent_swigregister", ListEvent_swigregister, METH_VARARGS, NULL},
 
52001
         { (char *)"ListEvent_swiginit", ListEvent_swiginit, METH_VARARGS, NULL},
 
52002
         { (char *)"new_ListCtrl", (PyCFunction) _wrap_new_ListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52003
         { (char *)"new_PreListCtrl", (PyCFunction)_wrap_new_PreListCtrl, METH_NOARGS, NULL},
 
52004
         { (char *)"ListCtrl_Create", (PyCFunction) _wrap_ListCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52005
         { (char *)"ListCtrl__setCallbackInfo", (PyCFunction) _wrap_ListCtrl__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
 
52006
         { (char *)"ListCtrl_GetColumn", (PyCFunction) _wrap_ListCtrl_GetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
 
52007
         { (char *)"ListCtrl_SetColumn", (PyCFunction) _wrap_ListCtrl_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
 
52008
         { (char *)"ListCtrl_GetColumnWidth", (PyCFunction) _wrap_ListCtrl_GetColumnWidth, METH_VARARGS | METH_KEYWORDS, NULL},
 
52009
         { (char *)"ListCtrl_SetColumnWidth", (PyCFunction) _wrap_ListCtrl_SetColumnWidth, METH_VARARGS | METH_KEYWORDS, NULL},
 
52010
         { (char *)"ListCtrl_HasColumnOrderSupport", (PyCFunction)_wrap_ListCtrl_HasColumnOrderSupport, METH_NOARGS, NULL},
 
52011
         { (char *)"ListCtrl_GetColumnOrder", (PyCFunction) _wrap_ListCtrl_GetColumnOrder, METH_VARARGS | METH_KEYWORDS, NULL},
 
52012
         { (char *)"ListCtrl_GetColumnIndexFromOrder", (PyCFunction) _wrap_ListCtrl_GetColumnIndexFromOrder, METH_VARARGS | METH_KEYWORDS, NULL},
 
52013
         { (char *)"ListCtrl_GetColumnsOrder", (PyCFunction)_wrap_ListCtrl_GetColumnsOrder, METH_O, NULL},
 
52014
         { (char *)"ListCtrl_SetColumnsOrder", (PyCFunction) _wrap_ListCtrl_SetColumnsOrder, METH_VARARGS | METH_KEYWORDS, NULL},
 
52015
         { (char *)"ListCtrl_GetCountPerPage", (PyCFunction)_wrap_ListCtrl_GetCountPerPage, METH_O, NULL},
 
52016
         { (char *)"ListCtrl_GetViewRect", (PyCFunction)_wrap_ListCtrl_GetViewRect, METH_O, NULL},
 
52017
         { (char *)"ListCtrl_GetEditControl", (PyCFunction)_wrap_ListCtrl_GetEditControl, METH_O, NULL},
 
52018
         { (char *)"ListCtrl_GetItem", (PyCFunction) _wrap_ListCtrl_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52019
         { (char *)"ListCtrl_SetItem", (PyCFunction) _wrap_ListCtrl_SetItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52020
         { (char *)"ListCtrl_SetStringItem", (PyCFunction) _wrap_ListCtrl_SetStringItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52021
         { (char *)"ListCtrl_GetItemState", (PyCFunction) _wrap_ListCtrl_GetItemState, METH_VARARGS | METH_KEYWORDS, NULL},
 
52022
         { (char *)"ListCtrl_SetItemState", (PyCFunction) _wrap_ListCtrl_SetItemState, METH_VARARGS | METH_KEYWORDS, NULL},
 
52023
         { (char *)"ListCtrl_SetItemImage", (PyCFunction) _wrap_ListCtrl_SetItemImage, METH_VARARGS | METH_KEYWORDS, NULL},
 
52024
         { (char *)"ListCtrl_SetItemColumnImage", (PyCFunction) _wrap_ListCtrl_SetItemColumnImage, METH_VARARGS | METH_KEYWORDS, NULL},
 
52025
         { (char *)"ListCtrl_GetItemText", (PyCFunction) _wrap_ListCtrl_GetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
 
52026
         { (char *)"ListCtrl_SetItemText", (PyCFunction) _wrap_ListCtrl_SetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
 
52027
         { (char *)"ListCtrl_GetItemData", (PyCFunction) _wrap_ListCtrl_GetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
 
52028
         { (char *)"ListCtrl_SetItemData", (PyCFunction) _wrap_ListCtrl_SetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
 
52029
         { (char *)"ListCtrl_GetItemPosition", (PyCFunction) _wrap_ListCtrl_GetItemPosition, METH_VARARGS | METH_KEYWORDS, NULL},
 
52030
         { (char *)"ListCtrl_GetItemRect", (PyCFunction) _wrap_ListCtrl_GetItemRect, METH_VARARGS | METH_KEYWORDS, NULL},
 
52031
         { (char *)"ListCtrl_SetItemPosition", (PyCFunction) _wrap_ListCtrl_SetItemPosition, METH_VARARGS | METH_KEYWORDS, NULL},
 
52032
         { (char *)"ListCtrl_GetItemCount", (PyCFunction)_wrap_ListCtrl_GetItemCount, METH_O, NULL},
 
52033
         { (char *)"ListCtrl_GetColumnCount", (PyCFunction)_wrap_ListCtrl_GetColumnCount, METH_O, NULL},
 
52034
         { (char *)"ListCtrl_GetItemSpacing", (PyCFunction)_wrap_ListCtrl_GetItemSpacing, METH_O, NULL},
 
52035
         { (char *)"ListCtrl_SetItemSpacing", (PyCFunction) _wrap_ListCtrl_SetItemSpacing, METH_VARARGS | METH_KEYWORDS, NULL},
 
52036
         { (char *)"ListCtrl_GetSelectedItemCount", (PyCFunction)_wrap_ListCtrl_GetSelectedItemCount, METH_O, NULL},
 
52037
         { (char *)"ListCtrl_GetTextColour", (PyCFunction)_wrap_ListCtrl_GetTextColour, METH_O, NULL},
 
52038
         { (char *)"ListCtrl_SetTextColour", (PyCFunction) _wrap_ListCtrl_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52039
         { (char *)"ListCtrl_GetTopItem", (PyCFunction)_wrap_ListCtrl_GetTopItem, METH_O, NULL},
 
52040
         { (char *)"ListCtrl_SetSingleStyle", (PyCFunction) _wrap_ListCtrl_SetSingleStyle, METH_VARARGS | METH_KEYWORDS, NULL},
 
52041
         { (char *)"ListCtrl_GetNextItem", (PyCFunction) _wrap_ListCtrl_GetNextItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52042
         { (char *)"ListCtrl_GetImageList", (PyCFunction) _wrap_ListCtrl_GetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
 
52043
         { (char *)"ListCtrl_SetImageList", (PyCFunction) _wrap_ListCtrl_SetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
 
52044
         { (char *)"ListCtrl_AssignImageList", (PyCFunction) _wrap_ListCtrl_AssignImageList, METH_VARARGS | METH_KEYWORDS, NULL},
 
52045
         { (char *)"ListCtrl_InReportView", (PyCFunction)_wrap_ListCtrl_InReportView, METH_O, NULL},
 
52046
         { (char *)"ListCtrl_IsVirtual", (PyCFunction)_wrap_ListCtrl_IsVirtual, METH_O, NULL},
 
52047
         { (char *)"ListCtrl_RefreshItem", (PyCFunction) _wrap_ListCtrl_RefreshItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52048
         { (char *)"ListCtrl_RefreshItems", (PyCFunction) _wrap_ListCtrl_RefreshItems, METH_VARARGS | METH_KEYWORDS, NULL},
 
52049
         { (char *)"ListCtrl_Arrange", (PyCFunction) _wrap_ListCtrl_Arrange, METH_VARARGS | METH_KEYWORDS, NULL},
 
52050
         { (char *)"ListCtrl_DeleteItem", (PyCFunction) _wrap_ListCtrl_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52051
         { (char *)"ListCtrl_DeleteAllItems", (PyCFunction)_wrap_ListCtrl_DeleteAllItems, METH_O, NULL},
 
52052
         { (char *)"ListCtrl_DeleteColumn", (PyCFunction) _wrap_ListCtrl_DeleteColumn, METH_VARARGS | METH_KEYWORDS, NULL},
 
52053
         { (char *)"ListCtrl_DeleteAllColumns", (PyCFunction)_wrap_ListCtrl_DeleteAllColumns, METH_O, NULL},
 
52054
         { (char *)"ListCtrl_ClearAll", (PyCFunction)_wrap_ListCtrl_ClearAll, METH_O, NULL},
 
52055
         { (char *)"ListCtrl_EditLabel", (PyCFunction) _wrap_ListCtrl_EditLabel, METH_VARARGS | METH_KEYWORDS, NULL},
 
52056
         { (char *)"ListCtrl_EnsureVisible", (PyCFunction) _wrap_ListCtrl_EnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
 
52057
         { (char *)"ListCtrl_FindItem", (PyCFunction) _wrap_ListCtrl_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52058
         { (char *)"ListCtrl_FindItemData", (PyCFunction) _wrap_ListCtrl_FindItemData, METH_VARARGS | METH_KEYWORDS, NULL},
 
52059
         { (char *)"ListCtrl_FindItemAtPos", (PyCFunction) _wrap_ListCtrl_FindItemAtPos, METH_VARARGS | METH_KEYWORDS, NULL},
 
52060
         { (char *)"ListCtrl_HitTest", (PyCFunction) _wrap_ListCtrl_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
 
52061
         { (char *)"ListCtrl_HitTestSubItem", (PyCFunction) _wrap_ListCtrl_HitTestSubItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52062
         { (char *)"ListCtrl_InsertItem", (PyCFunction) _wrap_ListCtrl_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52063
         { (char *)"ListCtrl_InsertStringItem", (PyCFunction) _wrap_ListCtrl_InsertStringItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52064
         { (char *)"ListCtrl_InsertImageItem", (PyCFunction) _wrap_ListCtrl_InsertImageItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52065
         { (char *)"ListCtrl_InsertImageStringItem", (PyCFunction) _wrap_ListCtrl_InsertImageStringItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52066
         { (char *)"ListCtrl_InsertColumnItem", (PyCFunction) _wrap_ListCtrl_InsertColumnItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52067
         { (char *)"ListCtrl_InsertColumn", (PyCFunction) _wrap_ListCtrl_InsertColumn, METH_VARARGS | METH_KEYWORDS, NULL},
 
52068
         { (char *)"ListCtrl_SetItemCount", (PyCFunction) _wrap_ListCtrl_SetItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
 
52069
         { (char *)"ListCtrl_ScrollList", (PyCFunction) _wrap_ListCtrl_ScrollList, METH_VARARGS | METH_KEYWORDS, NULL},
 
52070
         { (char *)"ListCtrl_SetItemTextColour", (PyCFunction) _wrap_ListCtrl_SetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52071
         { (char *)"ListCtrl_GetItemTextColour", (PyCFunction) _wrap_ListCtrl_GetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52072
         { (char *)"ListCtrl_SetItemBackgroundColour", (PyCFunction) _wrap_ListCtrl_SetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52073
         { (char *)"ListCtrl_GetItemBackgroundColour", (PyCFunction) _wrap_ListCtrl_GetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52074
         { (char *)"ListCtrl_SetItemFont", (PyCFunction) _wrap_ListCtrl_SetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
52075
         { (char *)"ListCtrl_GetItemFont", (PyCFunction) _wrap_ListCtrl_GetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
52076
         { (char *)"ListCtrl_SortItems", (PyCFunction) _wrap_ListCtrl_SortItems, METH_VARARGS | METH_KEYWORDS, NULL},
 
52077
         { (char *)"ListCtrl_GetMainWindow", (PyCFunction)_wrap_ListCtrl_GetMainWindow, METH_O, NULL},
 
52078
         { (char *)"ListCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_ListCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
52079
         { (char *)"ListCtrl_swigregister", ListCtrl_swigregister, METH_VARARGS, NULL},
 
52080
         { (char *)"ListCtrl_swiginit", ListCtrl_swiginit, METH_VARARGS, NULL},
 
52081
         { (char *)"new_ListView", (PyCFunction) _wrap_new_ListView, METH_VARARGS | METH_KEYWORDS, NULL},
 
52082
         { (char *)"new_PreListView", (PyCFunction)_wrap_new_PreListView, METH_NOARGS, NULL},
 
52083
         { (char *)"ListView_Create", (PyCFunction) _wrap_ListView_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52084
         { (char *)"ListView_Select", (PyCFunction) _wrap_ListView_Select, METH_VARARGS | METH_KEYWORDS, NULL},
 
52085
         { (char *)"ListView_Focus", (PyCFunction) _wrap_ListView_Focus, METH_VARARGS | METH_KEYWORDS, NULL},
 
52086
         { (char *)"ListView_GetFocusedItem", (PyCFunction)_wrap_ListView_GetFocusedItem, METH_O, NULL},
 
52087
         { (char *)"ListView_GetNextSelected", (PyCFunction) _wrap_ListView_GetNextSelected, METH_VARARGS | METH_KEYWORDS, NULL},
 
52088
         { (char *)"ListView_GetFirstSelected", (PyCFunction)_wrap_ListView_GetFirstSelected, METH_O, NULL},
 
52089
         { (char *)"ListView_IsSelected", (PyCFunction) _wrap_ListView_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
 
52090
         { (char *)"ListView_SetColumnImage", (PyCFunction) _wrap_ListView_SetColumnImage, METH_VARARGS | METH_KEYWORDS, NULL},
 
52091
         { (char *)"ListView_ClearColumnImage", (PyCFunction) _wrap_ListView_ClearColumnImage, METH_VARARGS | METH_KEYWORDS, NULL},
 
52092
         { (char *)"ListView_swigregister", ListView_swigregister, METH_VARARGS, NULL},
 
52093
         { (char *)"ListView_swiginit", ListView_swiginit, METH_VARARGS, NULL},
 
52094
         { (char *)"new_TreeItemId", (PyCFunction)_wrap_new_TreeItemId, METH_NOARGS, NULL},
 
52095
         { (char *)"delete_TreeItemId", (PyCFunction)_wrap_delete_TreeItemId, METH_O, NULL},
 
52096
         { (char *)"TreeItemId_IsOk", (PyCFunction)_wrap_TreeItemId_IsOk, METH_O, NULL},
 
52097
         { (char *)"TreeItemId___eq__", (PyCFunction) _wrap_TreeItemId___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
 
52098
         { (char *)"TreeItemId___ne__", (PyCFunction) _wrap_TreeItemId___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
 
52099
         { (char *)"TreeItemId_m_pItem_set", _wrap_TreeItemId_m_pItem_set, METH_VARARGS, NULL},
 
52100
         { (char *)"TreeItemId_m_pItem_get", (PyCFunction)_wrap_TreeItemId_m_pItem_get, METH_O, NULL},
 
52101
         { (char *)"TreeItemId_swigregister", TreeItemId_swigregister, METH_VARARGS, NULL},
 
52102
         { (char *)"TreeItemId_swiginit", TreeItemId_swiginit, METH_VARARGS, NULL},
 
52103
         { (char *)"new_TreeItemData", (PyCFunction) _wrap_new_TreeItemData, METH_VARARGS | METH_KEYWORDS, NULL},
 
52104
         { (char *)"delete_TreeItemData", (PyCFunction)_wrap_delete_TreeItemData, METH_O, NULL},
 
52105
         { (char *)"TreeItemData_GetData", (PyCFunction)_wrap_TreeItemData_GetData, METH_O, NULL},
 
52106
         { (char *)"TreeItemData_SetData", (PyCFunction) _wrap_TreeItemData_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
 
52107
         { (char *)"TreeItemData_GetId", (PyCFunction)_wrap_TreeItemData_GetId, METH_O, NULL},
 
52108
         { (char *)"TreeItemData_SetId", (PyCFunction) _wrap_TreeItemData_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
 
52109
         { (char *)"TreeItemData_Destroy", (PyCFunction)_wrap_TreeItemData_Destroy, METH_O, NULL},
 
52110
         { (char *)"TreeItemData_swigregister", TreeItemData_swigregister, METH_VARARGS, NULL},
 
52111
         { (char *)"TreeItemData_swiginit", TreeItemData_swiginit, METH_VARARGS, NULL},
 
52112
         { (char *)"new_TreeEvent", _wrap_new_TreeEvent, METH_VARARGS, NULL},
 
52113
         { (char *)"TreeEvent_GetItem", (PyCFunction)_wrap_TreeEvent_GetItem, METH_O, NULL},
 
52114
         { (char *)"TreeEvent_SetItem", (PyCFunction) _wrap_TreeEvent_SetItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52115
         { (char *)"TreeEvent_GetOldItem", (PyCFunction)_wrap_TreeEvent_GetOldItem, METH_O, NULL},
 
52116
         { (char *)"TreeEvent_SetOldItem", (PyCFunction) _wrap_TreeEvent_SetOldItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52117
         { (char *)"TreeEvent_GetPoint", (PyCFunction)_wrap_TreeEvent_GetPoint, METH_O, NULL},
 
52118
         { (char *)"TreeEvent_SetPoint", (PyCFunction) _wrap_TreeEvent_SetPoint, METH_VARARGS | METH_KEYWORDS, NULL},
 
52119
         { (char *)"TreeEvent_GetKeyEvent", (PyCFunction)_wrap_TreeEvent_GetKeyEvent, METH_O, NULL},
 
52120
         { (char *)"TreeEvent_GetKeyCode", (PyCFunction)_wrap_TreeEvent_GetKeyCode, METH_O, NULL},
 
52121
         { (char *)"TreeEvent_SetKeyEvent", (PyCFunction) _wrap_TreeEvent_SetKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
52122
         { (char *)"TreeEvent_GetLabel", (PyCFunction)_wrap_TreeEvent_GetLabel, METH_O, NULL},
 
52123
         { (char *)"TreeEvent_SetLabel", (PyCFunction) _wrap_TreeEvent_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
 
52124
         { (char *)"TreeEvent_IsEditCancelled", (PyCFunction)_wrap_TreeEvent_IsEditCancelled, METH_O, NULL},
 
52125
         { (char *)"TreeEvent_SetEditCanceled", (PyCFunction) _wrap_TreeEvent_SetEditCanceled, METH_VARARGS | METH_KEYWORDS, NULL},
 
52126
         { (char *)"TreeEvent_SetToolTip", (PyCFunction) _wrap_TreeEvent_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
 
52127
         { (char *)"TreeEvent_GetToolTip", (PyCFunction)_wrap_TreeEvent_GetToolTip, METH_O, NULL},
 
52128
         { (char *)"TreeEvent_swigregister", TreeEvent_swigregister, METH_VARARGS, NULL},
 
52129
         { (char *)"TreeEvent_swiginit", TreeEvent_swiginit, METH_VARARGS, NULL},
 
52130
         { (char *)"new_TreeCtrl", (PyCFunction) _wrap_new_TreeCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52131
         { (char *)"new_PreTreeCtrl", (PyCFunction)_wrap_new_PreTreeCtrl, METH_NOARGS, NULL},
 
52132
         { (char *)"TreeCtrl_Create", (PyCFunction) _wrap_TreeCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52133
         { (char *)"TreeCtrl__setCallbackInfo", (PyCFunction) _wrap_TreeCtrl__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
 
52134
         { (char *)"TreeCtrl_GetCount", (PyCFunction)_wrap_TreeCtrl_GetCount, METH_O, NULL},
 
52135
         { (char *)"TreeCtrl_GetIndent", (PyCFunction)_wrap_TreeCtrl_GetIndent, METH_O, NULL},
 
52136
         { (char *)"TreeCtrl_SetIndent", (PyCFunction) _wrap_TreeCtrl_SetIndent, METH_VARARGS | METH_KEYWORDS, NULL},
 
52137
         { (char *)"TreeCtrl_GetSpacing", (PyCFunction)_wrap_TreeCtrl_GetSpacing, METH_O, NULL},
 
52138
         { (char *)"TreeCtrl_SetSpacing", (PyCFunction) _wrap_TreeCtrl_SetSpacing, METH_VARARGS | METH_KEYWORDS, NULL},
 
52139
         { (char *)"TreeCtrl_GetImageList", (PyCFunction)_wrap_TreeCtrl_GetImageList, METH_O, NULL},
 
52140
         { (char *)"TreeCtrl_GetStateImageList", (PyCFunction)_wrap_TreeCtrl_GetStateImageList, METH_O, NULL},
 
52141
         { (char *)"TreeCtrl_SetImageList", (PyCFunction) _wrap_TreeCtrl_SetImageList, METH_VARARGS | METH_KEYWORDS, NULL},
 
52142
         { (char *)"TreeCtrl_SetStateImageList", (PyCFunction) _wrap_TreeCtrl_SetStateImageList, METH_VARARGS | METH_KEYWORDS, NULL},
 
52143
         { (char *)"TreeCtrl_AssignImageList", (PyCFunction) _wrap_TreeCtrl_AssignImageList, METH_VARARGS | METH_KEYWORDS, NULL},
 
52144
         { (char *)"TreeCtrl_AssignStateImageList", (PyCFunction) _wrap_TreeCtrl_AssignStateImageList, METH_VARARGS | METH_KEYWORDS, NULL},
 
52145
         { (char *)"TreeCtrl_GetItemText", (PyCFunction) _wrap_TreeCtrl_GetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
 
52146
         { (char *)"TreeCtrl_GetItemImage", (PyCFunction) _wrap_TreeCtrl_GetItemImage, METH_VARARGS | METH_KEYWORDS, NULL},
 
52147
         { (char *)"TreeCtrl_GetItemData", (PyCFunction) _wrap_TreeCtrl_GetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
 
52148
         { (char *)"TreeCtrl_GetItemPyData", (PyCFunction) _wrap_TreeCtrl_GetItemPyData, METH_VARARGS | METH_KEYWORDS, NULL},
 
52149
         { (char *)"TreeCtrl_GetItemTextColour", (PyCFunction) _wrap_TreeCtrl_GetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52150
         { (char *)"TreeCtrl_GetItemBackgroundColour", (PyCFunction) _wrap_TreeCtrl_GetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52151
         { (char *)"TreeCtrl_GetItemFont", (PyCFunction) _wrap_TreeCtrl_GetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
52152
         { (char *)"TreeCtrl_GetItemState", (PyCFunction) _wrap_TreeCtrl_GetItemState, METH_VARARGS | METH_KEYWORDS, NULL},
 
52153
         { (char *)"TreeCtrl_SetItemText", (PyCFunction) _wrap_TreeCtrl_SetItemText, METH_VARARGS | METH_KEYWORDS, NULL},
 
52154
         { (char *)"TreeCtrl_SetItemImage", (PyCFunction) _wrap_TreeCtrl_SetItemImage, METH_VARARGS | METH_KEYWORDS, NULL},
 
52155
         { (char *)"TreeCtrl_SetItemData", (PyCFunction) _wrap_TreeCtrl_SetItemData, METH_VARARGS | METH_KEYWORDS, NULL},
 
52156
         { (char *)"TreeCtrl_SetItemPyData", (PyCFunction) _wrap_TreeCtrl_SetItemPyData, METH_VARARGS | METH_KEYWORDS, NULL},
 
52157
         { (char *)"TreeCtrl_SetItemHasChildren", (PyCFunction) _wrap_TreeCtrl_SetItemHasChildren, METH_VARARGS | METH_KEYWORDS, NULL},
 
52158
         { (char *)"TreeCtrl_SetItemBold", (PyCFunction) _wrap_TreeCtrl_SetItemBold, METH_VARARGS | METH_KEYWORDS, NULL},
 
52159
         { (char *)"TreeCtrl_SetItemDropHighlight", (PyCFunction) _wrap_TreeCtrl_SetItemDropHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
 
52160
         { (char *)"TreeCtrl_SetItemTextColour", (PyCFunction) _wrap_TreeCtrl_SetItemTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52161
         { (char *)"TreeCtrl_SetItemBackgroundColour", (PyCFunction) _wrap_TreeCtrl_SetItemBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52162
         { (char *)"TreeCtrl_SetItemFont", (PyCFunction) _wrap_TreeCtrl_SetItemFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
52163
         { (char *)"TreeCtrl_SetItemState", (PyCFunction) _wrap_TreeCtrl_SetItemState, METH_VARARGS | METH_KEYWORDS, NULL},
 
52164
         { (char *)"TreeCtrl_IsVisible", (PyCFunction) _wrap_TreeCtrl_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
 
52165
         { (char *)"TreeCtrl_ItemHasChildren", (PyCFunction) _wrap_TreeCtrl_ItemHasChildren, METH_VARARGS | METH_KEYWORDS, NULL},
 
52166
         { (char *)"TreeCtrl_IsExpanded", (PyCFunction) _wrap_TreeCtrl_IsExpanded, METH_VARARGS | METH_KEYWORDS, NULL},
 
52167
         { (char *)"TreeCtrl_IsSelected", (PyCFunction) _wrap_TreeCtrl_IsSelected, METH_VARARGS | METH_KEYWORDS, NULL},
 
52168
         { (char *)"TreeCtrl_IsBold", (PyCFunction) _wrap_TreeCtrl_IsBold, METH_VARARGS | METH_KEYWORDS, NULL},
 
52169
         { (char *)"TreeCtrl_IsEmpty", (PyCFunction)_wrap_TreeCtrl_IsEmpty, METH_O, NULL},
 
52170
         { (char *)"TreeCtrl_GetChildrenCount", (PyCFunction) _wrap_TreeCtrl_GetChildrenCount, METH_VARARGS | METH_KEYWORDS, NULL},
 
52171
         { (char *)"TreeCtrl_GetRootItem", (PyCFunction)_wrap_TreeCtrl_GetRootItem, METH_O, NULL},
 
52172
         { (char *)"TreeCtrl_GetSelection", (PyCFunction)_wrap_TreeCtrl_GetSelection, METH_O, NULL},
 
52173
         { (char *)"TreeCtrl_GetSelections", (PyCFunction)_wrap_TreeCtrl_GetSelections, METH_O, NULL},
 
52174
         { (char *)"TreeCtrl_GetFocusedItem", (PyCFunction)_wrap_TreeCtrl_GetFocusedItem, METH_O, NULL},
 
52175
         { (char *)"TreeCtrl_ClearFocusedItem", (PyCFunction)_wrap_TreeCtrl_ClearFocusedItem, METH_O, NULL},
 
52176
         { (char *)"TreeCtrl_SetFocusedItem", (PyCFunction) _wrap_TreeCtrl_SetFocusedItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52177
         { (char *)"TreeCtrl_GetItemParent", (PyCFunction) _wrap_TreeCtrl_GetItemParent, METH_VARARGS | METH_KEYWORDS, NULL},
 
52178
         { (char *)"TreeCtrl_GetFirstChild", (PyCFunction) _wrap_TreeCtrl_GetFirstChild, METH_VARARGS | METH_KEYWORDS, NULL},
 
52179
         { (char *)"TreeCtrl_GetNextChild", (PyCFunction) _wrap_TreeCtrl_GetNextChild, METH_VARARGS | METH_KEYWORDS, NULL},
 
52180
         { (char *)"TreeCtrl_GetLastChild", (PyCFunction) _wrap_TreeCtrl_GetLastChild, METH_VARARGS | METH_KEYWORDS, NULL},
 
52181
         { (char *)"TreeCtrl_GetNextSibling", (PyCFunction) _wrap_TreeCtrl_GetNextSibling, METH_VARARGS | METH_KEYWORDS, NULL},
 
52182
         { (char *)"TreeCtrl_GetPrevSibling", (PyCFunction) _wrap_TreeCtrl_GetPrevSibling, METH_VARARGS | METH_KEYWORDS, NULL},
 
52183
         { (char *)"TreeCtrl_GetFirstVisibleItem", (PyCFunction)_wrap_TreeCtrl_GetFirstVisibleItem, METH_O, NULL},
 
52184
         { (char *)"TreeCtrl_GetNextVisible", (PyCFunction) _wrap_TreeCtrl_GetNextVisible, METH_VARARGS | METH_KEYWORDS, NULL},
 
52185
         { (char *)"TreeCtrl_GetPrevVisible", (PyCFunction) _wrap_TreeCtrl_GetPrevVisible, METH_VARARGS | METH_KEYWORDS, NULL},
 
52186
         { (char *)"TreeCtrl_AddRoot", (PyCFunction) _wrap_TreeCtrl_AddRoot, METH_VARARGS | METH_KEYWORDS, NULL},
 
52187
         { (char *)"TreeCtrl_PrependItem", (PyCFunction) _wrap_TreeCtrl_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52188
         { (char *)"TreeCtrl_InsertItem", (PyCFunction) _wrap_TreeCtrl_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52189
         { (char *)"TreeCtrl_InsertItemBefore", (PyCFunction) _wrap_TreeCtrl_InsertItemBefore, METH_VARARGS | METH_KEYWORDS, NULL},
 
52190
         { (char *)"TreeCtrl_AppendItem", (PyCFunction) _wrap_TreeCtrl_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52191
         { (char *)"TreeCtrl_Delete", (PyCFunction) _wrap_TreeCtrl_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
 
52192
         { (char *)"TreeCtrl_DeleteChildren", (PyCFunction) _wrap_TreeCtrl_DeleteChildren, METH_VARARGS | METH_KEYWORDS, NULL},
 
52193
         { (char *)"TreeCtrl_DeleteAllItems", (PyCFunction)_wrap_TreeCtrl_DeleteAllItems, METH_O, NULL},
 
52194
         { (char *)"TreeCtrl_Expand", (PyCFunction) _wrap_TreeCtrl_Expand, METH_VARARGS | METH_KEYWORDS, NULL},
 
52195
         { (char *)"TreeCtrl_ExpandAllChildren", (PyCFunction) _wrap_TreeCtrl_ExpandAllChildren, METH_VARARGS | METH_KEYWORDS, NULL},
 
52196
         { (char *)"TreeCtrl_ExpandAll", (PyCFunction)_wrap_TreeCtrl_ExpandAll, METH_O, NULL},
 
52197
         { (char *)"TreeCtrl_Collapse", (PyCFunction) _wrap_TreeCtrl_Collapse, METH_VARARGS | METH_KEYWORDS, NULL},
 
52198
         { (char *)"TreeCtrl_CollapseAllChildren", (PyCFunction) _wrap_TreeCtrl_CollapseAllChildren, METH_VARARGS | METH_KEYWORDS, NULL},
 
52199
         { (char *)"TreeCtrl_CollapseAll", (PyCFunction)_wrap_TreeCtrl_CollapseAll, METH_O, NULL},
 
52200
         { (char *)"TreeCtrl_CollapseAndReset", (PyCFunction) _wrap_TreeCtrl_CollapseAndReset, METH_VARARGS | METH_KEYWORDS, NULL},
 
52201
         { (char *)"TreeCtrl_Toggle", (PyCFunction) _wrap_TreeCtrl_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
 
52202
         { (char *)"TreeCtrl_Unselect", (PyCFunction)_wrap_TreeCtrl_Unselect, METH_O, NULL},
 
52203
         { (char *)"TreeCtrl_UnselectItem", (PyCFunction) _wrap_TreeCtrl_UnselectItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52204
         { (char *)"TreeCtrl_UnselectAll", (PyCFunction)_wrap_TreeCtrl_UnselectAll, METH_O, NULL},
 
52205
         { (char *)"TreeCtrl_SelectItem", (PyCFunction) _wrap_TreeCtrl_SelectItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52206
         { (char *)"TreeCtrl_SelectChildren", (PyCFunction) _wrap_TreeCtrl_SelectChildren, METH_VARARGS | METH_KEYWORDS, NULL},
 
52207
         { (char *)"TreeCtrl_ToggleItemSelection", (PyCFunction) _wrap_TreeCtrl_ToggleItemSelection, METH_VARARGS | METH_KEYWORDS, NULL},
 
52208
         { (char *)"TreeCtrl_EnsureVisible", (PyCFunction) _wrap_TreeCtrl_EnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},
 
52209
         { (char *)"TreeCtrl_ScrollTo", (PyCFunction) _wrap_TreeCtrl_ScrollTo, METH_VARARGS | METH_KEYWORDS, NULL},
 
52210
         { (char *)"TreeCtrl_EditLabel", (PyCFunction) _wrap_TreeCtrl_EditLabel, METH_VARARGS | METH_KEYWORDS, NULL},
 
52211
         { (char *)"TreeCtrl_GetEditControl", (PyCFunction)_wrap_TreeCtrl_GetEditControl, METH_O, NULL},
 
52212
         { (char *)"TreeCtrl_SortChildren", (PyCFunction) _wrap_TreeCtrl_SortChildren, METH_VARARGS | METH_KEYWORDS, NULL},
 
52213
         { (char *)"TreeCtrl_HitTest", (PyCFunction) _wrap_TreeCtrl_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
 
52214
         { (char *)"TreeCtrl_GetBoundingRect", (PyCFunction) _wrap_TreeCtrl_GetBoundingRect, METH_VARARGS | METH_KEYWORDS, NULL},
 
52215
         { (char *)"TreeCtrl_GetClassDefaultAttributes", (PyCFunction) _wrap_TreeCtrl_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
 
52216
         { (char *)"TreeCtrl_SetQuickBestSize", (PyCFunction) _wrap_TreeCtrl_SetQuickBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
52217
         { (char *)"TreeCtrl_GetQuickBestSize", (PyCFunction)_wrap_TreeCtrl_GetQuickBestSize, METH_O, NULL},
 
52218
         { (char *)"TreeCtrl_swigregister", TreeCtrl_swigregister, METH_VARARGS, NULL},
 
52219
         { (char *)"TreeCtrl_swiginit", TreeCtrl_swiginit, METH_VARARGS, NULL},
 
52220
         { (char *)"DirItemData_SetNewDirName", (PyCFunction) _wrap_DirItemData_SetNewDirName, METH_VARARGS | METH_KEYWORDS, NULL},
 
52221
         { (char *)"DirItemData_m_path_set", _wrap_DirItemData_m_path_set, METH_VARARGS, NULL},
 
52222
         { (char *)"DirItemData_m_path_get", (PyCFunction)_wrap_DirItemData_m_path_get, METH_O, NULL},
 
52223
         { (char *)"DirItemData_m_name_set", _wrap_DirItemData_m_name_set, METH_VARARGS, NULL},
 
52224
         { (char *)"DirItemData_m_name_get", (PyCFunction)_wrap_DirItemData_m_name_get, METH_O, NULL},
 
52225
         { (char *)"DirItemData_m_isHidden_set", _wrap_DirItemData_m_isHidden_set, METH_VARARGS, NULL},
 
52226
         { (char *)"DirItemData_m_isHidden_get", (PyCFunction)_wrap_DirItemData_m_isHidden_get, METH_O, NULL},
 
52227
         { (char *)"DirItemData_m_isExpanded_set", _wrap_DirItemData_m_isExpanded_set, METH_VARARGS, NULL},
 
52228
         { (char *)"DirItemData_m_isExpanded_get", (PyCFunction)_wrap_DirItemData_m_isExpanded_get, METH_O, NULL},
 
52229
         { (char *)"DirItemData_m_isDir_set", _wrap_DirItemData_m_isDir_set, METH_VARARGS, NULL},
 
52230
         { (char *)"DirItemData_m_isDir_get", (PyCFunction)_wrap_DirItemData_m_isDir_get, METH_O, NULL},
 
52231
         { (char *)"DirItemData_swigregister", DirItemData_swigregister, METH_VARARGS, NULL},
 
52232
         { (char *)"new_GenericDirCtrl", (PyCFunction) _wrap_new_GenericDirCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52233
         { (char *)"new_PreGenericDirCtrl", (PyCFunction)_wrap_new_PreGenericDirCtrl, METH_NOARGS, NULL},
 
52234
         { (char *)"GenericDirCtrl_Create", (PyCFunction) _wrap_GenericDirCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52235
         { (char *)"GenericDirCtrl_ExpandPath", (PyCFunction) _wrap_GenericDirCtrl_ExpandPath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52236
         { (char *)"GenericDirCtrl_CollapsePath", (PyCFunction) _wrap_GenericDirCtrl_CollapsePath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52237
         { (char *)"GenericDirCtrl_GetDefaultPath", (PyCFunction)_wrap_GenericDirCtrl_GetDefaultPath, METH_O, NULL},
 
52238
         { (char *)"GenericDirCtrl_SetDefaultPath", (PyCFunction) _wrap_GenericDirCtrl_SetDefaultPath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52239
         { (char *)"GenericDirCtrl_GetPath", (PyCFunction)_wrap_GenericDirCtrl_GetPath, METH_O, NULL},
 
52240
         { (char *)"GenericDirCtrl_GetPaths", (PyCFunction)_wrap_GenericDirCtrl_GetPaths, METH_O, NULL},
 
52241
         { (char *)"GenericDirCtrl_GetFilePath", (PyCFunction)_wrap_GenericDirCtrl_GetFilePath, METH_O, NULL},
 
52242
         { (char *)"GenericDirCtrl_SetPath", (PyCFunction) _wrap_GenericDirCtrl_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52243
         { (char *)"GenericDirCtrl_GetFilePaths", (PyCFunction)_wrap_GenericDirCtrl_GetFilePaths, METH_O, NULL},
 
52244
         { (char *)"GenericDirCtrl_SelectPath", (PyCFunction) _wrap_GenericDirCtrl_SelectPath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52245
         { (char *)"GenericDirCtrl_SelectPaths", (PyCFunction) _wrap_GenericDirCtrl_SelectPaths, METH_VARARGS | METH_KEYWORDS, NULL},
 
52246
         { (char *)"GenericDirCtrl_ShowHidden", (PyCFunction) _wrap_GenericDirCtrl_ShowHidden, METH_VARARGS | METH_KEYWORDS, NULL},
 
52247
         { (char *)"GenericDirCtrl_GetShowHidden", (PyCFunction)_wrap_GenericDirCtrl_GetShowHidden, METH_O, NULL},
 
52248
         { (char *)"GenericDirCtrl_GetFilter", (PyCFunction)_wrap_GenericDirCtrl_GetFilter, METH_O, NULL},
 
52249
         { (char *)"GenericDirCtrl_SetFilter", (PyCFunction) _wrap_GenericDirCtrl_SetFilter, METH_VARARGS | METH_KEYWORDS, NULL},
 
52250
         { (char *)"GenericDirCtrl_GetFilterIndex", (PyCFunction)_wrap_GenericDirCtrl_GetFilterIndex, METH_O, NULL},
 
52251
         { (char *)"GenericDirCtrl_SetFilterIndex", (PyCFunction) _wrap_GenericDirCtrl_SetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
 
52252
         { (char *)"GenericDirCtrl_GetRootId", (PyCFunction)_wrap_GenericDirCtrl_GetRootId, METH_O, NULL},
 
52253
         { (char *)"GenericDirCtrl_GetTreeCtrl", (PyCFunction)_wrap_GenericDirCtrl_GetTreeCtrl, METH_O, NULL},
 
52254
         { (char *)"GenericDirCtrl_GetFilterListCtrl", (PyCFunction)_wrap_GenericDirCtrl_GetFilterListCtrl, METH_O, NULL},
 
52255
         { (char *)"GenericDirCtrl_UnselectAll", (PyCFunction)_wrap_GenericDirCtrl_UnselectAll, METH_O, NULL},
 
52256
         { (char *)"GenericDirCtrl_GetDirItemData", (PyCFunction) _wrap_GenericDirCtrl_GetDirItemData, METH_VARARGS | METH_KEYWORDS, NULL},
 
52257
         { (char *)"GenericDirCtrl_FindChild", (PyCFunction) _wrap_GenericDirCtrl_FindChild, METH_VARARGS | METH_KEYWORDS, NULL},
 
52258
         { (char *)"GenericDirCtrl_DoResize", (PyCFunction)_wrap_GenericDirCtrl_DoResize, METH_O, NULL},
 
52259
         { (char *)"GenericDirCtrl_ReCreateTree", (PyCFunction)_wrap_GenericDirCtrl_ReCreateTree, METH_O, NULL},
 
52260
         { (char *)"GenericDirCtrl_swigregister", GenericDirCtrl_swigregister, METH_VARARGS, NULL},
 
52261
         { (char *)"GenericDirCtrl_swiginit", GenericDirCtrl_swiginit, METH_VARARGS, NULL},
 
52262
         { (char *)"new_DirFilterListCtrl", (PyCFunction) _wrap_new_DirFilterListCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52263
         { (char *)"new_PreDirFilterListCtrl", (PyCFunction)_wrap_new_PreDirFilterListCtrl, METH_NOARGS, NULL},
 
52264
         { (char *)"DirFilterListCtrl_Create", (PyCFunction) _wrap_DirFilterListCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52265
         { (char *)"DirFilterListCtrl_FillFilterList", (PyCFunction) _wrap_DirFilterListCtrl_FillFilterList, METH_VARARGS | METH_KEYWORDS, NULL},
 
52266
         { (char *)"DirFilterListCtrl_swigregister", DirFilterListCtrl_swigregister, METH_VARARGS, NULL},
 
52267
         { (char *)"DirFilterListCtrl_swiginit", DirFilterListCtrl_swiginit, METH_VARARGS, NULL},
 
52268
         { (char *)"new_PyControl", (PyCFunction) _wrap_new_PyControl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52269
         { (char *)"new_PrePyControl", (PyCFunction)_wrap_new_PrePyControl, METH_NOARGS, NULL},
 
52270
         { (char *)"PyControl__setCallbackInfo", (PyCFunction) _wrap_PyControl__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
 
52271
         { (char *)"PyControl_DoEraseBackground", (PyCFunction) _wrap_PyControl_DoEraseBackground, METH_VARARGS | METH_KEYWORDS, NULL},
 
52272
         { (char *)"PyControl_DoMoveWindow", (PyCFunction) _wrap_PyControl_DoMoveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
 
52273
         { (char *)"PyControl_DoSetSize", (PyCFunction) _wrap_PyControl_DoSetSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
52274
         { (char *)"PyControl_DoSetClientSize", (PyCFunction) _wrap_PyControl_DoSetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
52275
         { (char *)"PyControl_DoSetVirtualSize", (PyCFunction) _wrap_PyControl_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
52276
         { (char *)"PyControl_DoGetSize", (PyCFunction)_wrap_PyControl_DoGetSize, METH_O, NULL},
 
52277
         { (char *)"PyControl_DoGetClientSize", (PyCFunction)_wrap_PyControl_DoGetClientSize, METH_O, NULL},
 
52278
         { (char *)"PyControl_DoGetPosition", (PyCFunction)_wrap_PyControl_DoGetPosition, METH_O, NULL},
 
52279
         { (char *)"PyControl_DoGetVirtualSize", (PyCFunction)_wrap_PyControl_DoGetVirtualSize, METH_O, NULL},
 
52280
         { (char *)"PyControl_DoGetBestSize", (PyCFunction)_wrap_PyControl_DoGetBestSize, METH_O, NULL},
 
52281
         { (char *)"PyControl_GetDefaultAttributes", (PyCFunction)_wrap_PyControl_GetDefaultAttributes, METH_O, NULL},
 
52282
         { (char *)"PyControl_OnInternalIdle", (PyCFunction)_wrap_PyControl_OnInternalIdle, METH_O, NULL},
 
52283
         { (char *)"PyControl_swigregister", PyControl_swigregister, METH_VARARGS, NULL},
 
52284
         { (char *)"PyControl_swiginit", PyControl_swiginit, METH_VARARGS, NULL},
 
52285
         { (char *)"new_HelpEvent", (PyCFunction) _wrap_new_HelpEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
52286
         { (char *)"HelpEvent_GetPosition", (PyCFunction)_wrap_HelpEvent_GetPosition, METH_O, NULL},
 
52287
         { (char *)"HelpEvent_SetPosition", (PyCFunction) _wrap_HelpEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
 
52288
         { (char *)"HelpEvent_GetLink", (PyCFunction)_wrap_HelpEvent_GetLink, METH_O, NULL},
 
52289
         { (char *)"HelpEvent_SetLink", (PyCFunction) _wrap_HelpEvent_SetLink, METH_VARARGS | METH_KEYWORDS, NULL},
 
52290
         { (char *)"HelpEvent_GetTarget", (PyCFunction)_wrap_HelpEvent_GetTarget, METH_O, NULL},
 
52291
         { (char *)"HelpEvent_SetTarget", (PyCFunction) _wrap_HelpEvent_SetTarget, METH_VARARGS | METH_KEYWORDS, NULL},
 
52292
         { (char *)"HelpEvent_GetOrigin", (PyCFunction)_wrap_HelpEvent_GetOrigin, METH_O, NULL},
 
52293
         { (char *)"HelpEvent_SetOrigin", (PyCFunction) _wrap_HelpEvent_SetOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
 
52294
         { (char *)"HelpEvent_swigregister", HelpEvent_swigregister, METH_VARARGS, NULL},
 
52295
         { (char *)"HelpEvent_swiginit", HelpEvent_swiginit, METH_VARARGS, NULL},
 
52296
         { (char *)"new_ContextHelp", (PyCFunction) _wrap_new_ContextHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
52297
         { (char *)"delete_ContextHelp", (PyCFunction)_wrap_delete_ContextHelp, METH_O, NULL},
 
52298
         { (char *)"ContextHelp_BeginContextHelp", (PyCFunction) _wrap_ContextHelp_BeginContextHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
52299
         { (char *)"ContextHelp_EndContextHelp", (PyCFunction)_wrap_ContextHelp_EndContextHelp, METH_O, NULL},
 
52300
         { (char *)"ContextHelp_swigregister", ContextHelp_swigregister, METH_VARARGS, NULL},
 
52301
         { (char *)"ContextHelp_swiginit", ContextHelp_swiginit, METH_VARARGS, NULL},
 
52302
         { (char *)"new_ContextHelpButton", (PyCFunction) _wrap_new_ContextHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
 
52303
         { (char *)"ContextHelpButton_swigregister", ContextHelpButton_swigregister, METH_VARARGS, NULL},
 
52304
         { (char *)"ContextHelpButton_swiginit", ContextHelpButton_swiginit, METH_VARARGS, NULL},
 
52305
         { (char *)"delete_HelpProvider", (PyCFunction)_wrap_delete_HelpProvider, METH_O, NULL},
 
52306
         { (char *)"HelpProvider_Set", (PyCFunction) _wrap_HelpProvider_Set, METH_VARARGS | METH_KEYWORDS, NULL},
 
52307
         { (char *)"HelpProvider_Get", (PyCFunction)_wrap_HelpProvider_Get, METH_NOARGS, NULL},
 
52308
         { (char *)"HelpProvider_GetHelp", (PyCFunction) _wrap_HelpProvider_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
52309
         { (char *)"HelpProvider_ShowHelp", (PyCFunction) _wrap_HelpProvider_ShowHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
52310
         { (char *)"HelpProvider_ShowHelpAtPoint", (PyCFunction) _wrap_HelpProvider_ShowHelpAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
 
52311
         { (char *)"HelpProvider_AddHelp", (PyCFunction) _wrap_HelpProvider_AddHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
52312
         { (char *)"HelpProvider_AddHelpById", (PyCFunction) _wrap_HelpProvider_AddHelpById, METH_VARARGS | METH_KEYWORDS, NULL},
 
52313
         { (char *)"HelpProvider_RemoveHelp", (PyCFunction) _wrap_HelpProvider_RemoveHelp, METH_VARARGS | METH_KEYWORDS, NULL},
 
52314
         { (char *)"HelpProvider_Destroy", (PyCFunction)_wrap_HelpProvider_Destroy, METH_O, NULL},
 
52315
         { (char *)"HelpProvider_swigregister", HelpProvider_swigregister, METH_VARARGS, NULL},
 
52316
         { (char *)"new_SimpleHelpProvider", (PyCFunction)_wrap_new_SimpleHelpProvider, METH_NOARGS, NULL},
 
52317
         { (char *)"SimpleHelpProvider_swigregister", SimpleHelpProvider_swigregister, METH_VARARGS, NULL},
 
52318
         { (char *)"SimpleHelpProvider_swiginit", SimpleHelpProvider_swiginit, METH_VARARGS, NULL},
 
52319
         { (char *)"new_DragImage", (PyCFunction) _wrap_new_DragImage, METH_VARARGS | METH_KEYWORDS, NULL},
 
52320
         { (char *)"new_DragIcon", (PyCFunction) _wrap_new_DragIcon, METH_VARARGS | METH_KEYWORDS, NULL},
 
52321
         { (char *)"new_DragString", (PyCFunction) _wrap_new_DragString, METH_VARARGS | METH_KEYWORDS, NULL},
 
52322
         { (char *)"new_DragTreeItem", (PyCFunction) _wrap_new_DragTreeItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52323
         { (char *)"new_DragListItem", (PyCFunction) _wrap_new_DragListItem, METH_VARARGS | METH_KEYWORDS, NULL},
 
52324
         { (char *)"delete_DragImage", (PyCFunction)_wrap_delete_DragImage, METH_O, NULL},
 
52325
         { (char *)"DragImage_SetBackingBitmap", (PyCFunction) _wrap_DragImage_SetBackingBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
52326
         { (char *)"DragImage_BeginDrag", (PyCFunction) _wrap_DragImage_BeginDrag, METH_VARARGS | METH_KEYWORDS, NULL},
 
52327
         { (char *)"DragImage_BeginDragBounded", (PyCFunction) _wrap_DragImage_BeginDragBounded, METH_VARARGS | METH_KEYWORDS, NULL},
 
52328
         { (char *)"DragImage_EndDrag", (PyCFunction)_wrap_DragImage_EndDrag, METH_O, NULL},
 
52329
         { (char *)"DragImage_Move", (PyCFunction) _wrap_DragImage_Move, METH_VARARGS | METH_KEYWORDS, NULL},
 
52330
         { (char *)"DragImage_Show", (PyCFunction)_wrap_DragImage_Show, METH_O, NULL},
 
52331
         { (char *)"DragImage_Hide", (PyCFunction)_wrap_DragImage_Hide, METH_O, NULL},
 
52332
         { (char *)"DragImage_GetImageRect", (PyCFunction) _wrap_DragImage_GetImageRect, METH_VARARGS | METH_KEYWORDS, NULL},
 
52333
         { (char *)"DragImage_DoDrawImage", (PyCFunction) _wrap_DragImage_DoDrawImage, METH_VARARGS | METH_KEYWORDS, NULL},
 
52334
         { (char *)"DragImage_UpdateBackingFromWindow", (PyCFunction) _wrap_DragImage_UpdateBackingFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
 
52335
         { (char *)"DragImage_RedrawImage", (PyCFunction) _wrap_DragImage_RedrawImage, METH_VARARGS | METH_KEYWORDS, NULL},
 
52336
         { (char *)"DragImage_swigregister", DragImage_swigregister, METH_VARARGS, NULL},
 
52337
         { (char *)"DragImage_swiginit", DragImage_swiginit, METH_VARARGS, NULL},
 
52338
         { (char *)"DatePickerCtrlBase_SetValue", (PyCFunction) _wrap_DatePickerCtrlBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
 
52339
         { (char *)"DatePickerCtrlBase_GetValue", (PyCFunction)_wrap_DatePickerCtrlBase_GetValue, METH_O, NULL},
 
52340
         { (char *)"DatePickerCtrlBase_SetRange", (PyCFunction) _wrap_DatePickerCtrlBase_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},
 
52341
         { (char *)"DatePickerCtrlBase_GetLowerLimit", (PyCFunction)_wrap_DatePickerCtrlBase_GetLowerLimit, METH_O, NULL},
 
52342
         { (char *)"DatePickerCtrlBase_GetUpperLimit", (PyCFunction)_wrap_DatePickerCtrlBase_GetUpperLimit, METH_O, NULL},
 
52343
         { (char *)"DatePickerCtrlBase_swigregister", DatePickerCtrlBase_swigregister, METH_VARARGS, NULL},
 
52344
         { (char *)"new_DatePickerCtrl", (PyCFunction) _wrap_new_DatePickerCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52345
         { (char *)"new_PreDatePickerCtrl", (PyCFunction)_wrap_new_PreDatePickerCtrl, METH_NOARGS, NULL},
 
52346
         { (char *)"DatePickerCtrl_Create", (PyCFunction) _wrap_DatePickerCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52347
         { (char *)"DatePickerCtrl_swigregister", DatePickerCtrl_swigregister, METH_VARARGS, NULL},
 
52348
         { (char *)"DatePickerCtrl_swiginit", DatePickerCtrl_swiginit, METH_VARARGS, NULL},
 
52349
         { (char *)"new_GenericDatePickerCtrl", (PyCFunction) _wrap_new_GenericDatePickerCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52350
         { (char *)"new_PreGenericDatePickerCtrl", (PyCFunction)_wrap_new_PreGenericDatePickerCtrl, METH_NOARGS, NULL},
 
52351
         { (char *)"GenericDatePickerCtrl_Create", (PyCFunction) _wrap_GenericDatePickerCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52352
         { (char *)"GenericDatePickerCtrl_swigregister", GenericDatePickerCtrl_swigregister, METH_VARARGS, NULL},
 
52353
         { (char *)"GenericDatePickerCtrl_swiginit", GenericDatePickerCtrl_swiginit, METH_VARARGS, NULL},
 
52354
         { (char *)"new_HyperlinkCtrl", (PyCFunction) _wrap_new_HyperlinkCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52355
         { (char *)"new_PreHyperlinkCtrl", (PyCFunction)_wrap_new_PreHyperlinkCtrl, METH_NOARGS, NULL},
 
52356
         { (char *)"HyperlinkCtrl_Create", (PyCFunction) _wrap_HyperlinkCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52357
         { (char *)"HyperlinkCtrl_GetHoverColour", (PyCFunction)_wrap_HyperlinkCtrl_GetHoverColour, METH_O, NULL},
 
52358
         { (char *)"HyperlinkCtrl_SetHoverColour", (PyCFunction) _wrap_HyperlinkCtrl_SetHoverColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52359
         { (char *)"HyperlinkCtrl_GetNormalColour", (PyCFunction)_wrap_HyperlinkCtrl_GetNormalColour, METH_O, NULL},
 
52360
         { (char *)"HyperlinkCtrl_SetNormalColour", (PyCFunction) _wrap_HyperlinkCtrl_SetNormalColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52361
         { (char *)"HyperlinkCtrl_GetVisitedColour", (PyCFunction)_wrap_HyperlinkCtrl_GetVisitedColour, METH_O, NULL},
 
52362
         { (char *)"HyperlinkCtrl_SetVisitedColour", (PyCFunction) _wrap_HyperlinkCtrl_SetVisitedColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52363
         { (char *)"HyperlinkCtrl_GetURL", (PyCFunction)_wrap_HyperlinkCtrl_GetURL, METH_O, NULL},
 
52364
         { (char *)"HyperlinkCtrl_SetURL", (PyCFunction) _wrap_HyperlinkCtrl_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
 
52365
         { (char *)"HyperlinkCtrl_SetVisited", (PyCFunction) _wrap_HyperlinkCtrl_SetVisited, METH_VARARGS | METH_KEYWORDS, NULL},
 
52366
         { (char *)"HyperlinkCtrl_GetVisited", (PyCFunction)_wrap_HyperlinkCtrl_GetVisited, METH_O, NULL},
 
52367
         { (char *)"HyperlinkCtrl_swigregister", HyperlinkCtrl_swigregister, METH_VARARGS, NULL},
 
52368
         { (char *)"HyperlinkCtrl_swiginit", HyperlinkCtrl_swiginit, METH_VARARGS, NULL},
 
52369
         { (char *)"new_HyperlinkEvent", (PyCFunction) _wrap_new_HyperlinkEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
52370
         { (char *)"HyperlinkEvent_GetURL", (PyCFunction)_wrap_HyperlinkEvent_GetURL, METH_O, NULL},
 
52371
         { (char *)"HyperlinkEvent_SetURL", (PyCFunction) _wrap_HyperlinkEvent_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
 
52372
         { (char *)"HyperlinkEvent_swigregister", HyperlinkEvent_swigregister, METH_VARARGS, NULL},
 
52373
         { (char *)"HyperlinkEvent_swiginit", HyperlinkEvent_swiginit, METH_VARARGS, NULL},
 
52374
         { (char *)"PickerBase_CreateBase", (PyCFunction) _wrap_PickerBase_CreateBase, METH_VARARGS | METH_KEYWORDS, NULL},
 
52375
         { (char *)"PickerBase_SetInternalMargin", (PyCFunction) _wrap_PickerBase_SetInternalMargin, METH_VARARGS | METH_KEYWORDS, NULL},
 
52376
         { (char *)"PickerBase_GetInternalMargin", (PyCFunction)_wrap_PickerBase_GetInternalMargin, METH_O, NULL},
 
52377
         { (char *)"PickerBase_SetTextCtrlProportion", (PyCFunction) _wrap_PickerBase_SetTextCtrlProportion, METH_VARARGS | METH_KEYWORDS, NULL},
 
52378
         { (char *)"PickerBase_GetTextCtrlProportion", (PyCFunction)_wrap_PickerBase_GetTextCtrlProportion, METH_O, NULL},
 
52379
         { (char *)"PickerBase_SetPickerCtrlProportion", (PyCFunction) _wrap_PickerBase_SetPickerCtrlProportion, METH_VARARGS | METH_KEYWORDS, NULL},
 
52380
         { (char *)"PickerBase_GetPickerCtrlProportion", (PyCFunction)_wrap_PickerBase_GetPickerCtrlProportion, METH_O, NULL},
 
52381
         { (char *)"PickerBase_IsTextCtrlGrowable", (PyCFunction)_wrap_PickerBase_IsTextCtrlGrowable, METH_O, NULL},
 
52382
         { (char *)"PickerBase_SetTextCtrlGrowable", (PyCFunction) _wrap_PickerBase_SetTextCtrlGrowable, METH_VARARGS | METH_KEYWORDS, NULL},
 
52383
         { (char *)"PickerBase_IsPickerCtrlGrowable", (PyCFunction)_wrap_PickerBase_IsPickerCtrlGrowable, METH_O, NULL},
 
52384
         { (char *)"PickerBase_SetPickerCtrlGrowable", (PyCFunction) _wrap_PickerBase_SetPickerCtrlGrowable, METH_VARARGS | METH_KEYWORDS, NULL},
 
52385
         { (char *)"PickerBase_HasTextCtrl", (PyCFunction)_wrap_PickerBase_HasTextCtrl, METH_O, NULL},
 
52386
         { (char *)"PickerBase_GetTextCtrl", (PyCFunction)_wrap_PickerBase_GetTextCtrl, METH_O, NULL},
 
52387
         { (char *)"PickerBase_GetPickerCtrl", (PyCFunction)_wrap_PickerBase_GetPickerCtrl, METH_O, NULL},
 
52388
         { (char *)"PickerBase_swigregister", PickerBase_swigregister, METH_VARARGS, NULL},
 
52389
         { (char *)"new_PyPickerBase", (PyCFunction) _wrap_new_PyPickerBase, METH_VARARGS | METH_KEYWORDS, NULL},
 
52390
         { (char *)"new_PrePyPickerBase", (PyCFunction)_wrap_new_PrePyPickerBase, METH_NOARGS, NULL},
 
52391
         { (char *)"PyPickerBase__setCallbackInfo", (PyCFunction) _wrap_PyPickerBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
 
52392
         { (char *)"PyPickerBase_UpdatePickerFromTextCtrl", (PyCFunction)_wrap_PyPickerBase_UpdatePickerFromTextCtrl, METH_O, NULL},
 
52393
         { (char *)"PyPickerBase_UpdateTextCtrlFromPicker", (PyCFunction)_wrap_PyPickerBase_UpdateTextCtrlFromPicker, METH_O, NULL},
 
52394
         { (char *)"PyPickerBase_GetTextCtrlStyle", (PyCFunction) _wrap_PyPickerBase_GetTextCtrlStyle, METH_VARARGS | METH_KEYWORDS, NULL},
 
52395
         { (char *)"PyPickerBase_GetPickerStyle", (PyCFunction) _wrap_PyPickerBase_GetPickerStyle, METH_VARARGS | METH_KEYWORDS, NULL},
 
52396
         { (char *)"PyPickerBase_SetTextCtrl", (PyCFunction) _wrap_PyPickerBase_SetTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52397
         { (char *)"PyPickerBase_SetPickerCtrl", (PyCFunction) _wrap_PyPickerBase_SetPickerCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52398
         { (char *)"PyPickerBase_PostCreation", (PyCFunction)_wrap_PyPickerBase_PostCreation, METH_O, NULL},
 
52399
         { (char *)"PyPickerBase_swigregister", PyPickerBase_swigregister, METH_VARARGS, NULL},
 
52400
         { (char *)"PyPickerBase_swiginit", PyPickerBase_swiginit, METH_VARARGS, NULL},
 
52401
         { (char *)"new_ColourPickerCtrl", (PyCFunction) _wrap_new_ColourPickerCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52402
         { (char *)"new_PreColourPickerCtrl", (PyCFunction)_wrap_new_PreColourPickerCtrl, METH_NOARGS, NULL},
 
52403
         { (char *)"ColourPickerCtrl_Create", (PyCFunction) _wrap_ColourPickerCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52404
         { (char *)"ColourPickerCtrl_GetColour", (PyCFunction)_wrap_ColourPickerCtrl_GetColour, METH_O, NULL},
 
52405
         { (char *)"ColourPickerCtrl_SetColour", (PyCFunction) _wrap_ColourPickerCtrl_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52406
         { (char *)"ColourPickerCtrl_swigregister", ColourPickerCtrl_swigregister, METH_VARARGS, NULL},
 
52407
         { (char *)"ColourPickerCtrl_swiginit", ColourPickerCtrl_swiginit, METH_VARARGS, NULL},
 
52408
         { (char *)"new_ColourPickerEvent", (PyCFunction) _wrap_new_ColourPickerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
52409
         { (char *)"ColourPickerEvent_GetColour", (PyCFunction)_wrap_ColourPickerEvent_GetColour, METH_O, NULL},
 
52410
         { (char *)"ColourPickerEvent_SetColour", (PyCFunction) _wrap_ColourPickerEvent_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
52411
         { (char *)"ColourPickerEvent_swigregister", ColourPickerEvent_swigregister, METH_VARARGS, NULL},
 
52412
         { (char *)"ColourPickerEvent_swiginit", ColourPickerEvent_swiginit, METH_VARARGS, NULL},
 
52413
         { (char *)"new_FilePickerCtrl", (PyCFunction) _wrap_new_FilePickerCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52414
         { (char *)"new_PreFilePickerCtrl", (PyCFunction)_wrap_new_PreFilePickerCtrl, METH_NOARGS, NULL},
 
52415
         { (char *)"FilePickerCtrl_Create", (PyCFunction) _wrap_FilePickerCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52416
         { (char *)"FilePickerCtrl_GetPath", (PyCFunction)_wrap_FilePickerCtrl_GetPath, METH_O, NULL},
 
52417
         { (char *)"FilePickerCtrl_SetPath", (PyCFunction) _wrap_FilePickerCtrl_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52418
         { (char *)"FilePickerCtrl_CheckPath", (PyCFunction) _wrap_FilePickerCtrl_CheckPath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52419
         { (char *)"FilePickerCtrl_GetTextCtrlValue", (PyCFunction)_wrap_FilePickerCtrl_GetTextCtrlValue, METH_O, NULL},
 
52420
         { (char *)"FilePickerCtrl_swigregister", FilePickerCtrl_swigregister, METH_VARARGS, NULL},
 
52421
         { (char *)"FilePickerCtrl_swiginit", FilePickerCtrl_swiginit, METH_VARARGS, NULL},
 
52422
         { (char *)"new_DirPickerCtrl", (PyCFunction) _wrap_new_DirPickerCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52423
         { (char *)"new_PreDirPickerCtrl", (PyCFunction)_wrap_new_PreDirPickerCtrl, METH_NOARGS, NULL},
 
52424
         { (char *)"DirPickerCtrl_Create", (PyCFunction) _wrap_DirPickerCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52425
         { (char *)"DirPickerCtrl_GetPath", (PyCFunction)_wrap_DirPickerCtrl_GetPath, METH_O, NULL},
 
52426
         { (char *)"DirPickerCtrl_SetPath", (PyCFunction) _wrap_DirPickerCtrl_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52427
         { (char *)"DirPickerCtrl_CheckPath", (PyCFunction) _wrap_DirPickerCtrl_CheckPath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52428
         { (char *)"DirPickerCtrl_GetTextCtrlValue", (PyCFunction)_wrap_DirPickerCtrl_GetTextCtrlValue, METH_O, NULL},
 
52429
         { (char *)"DirPickerCtrl_swigregister", DirPickerCtrl_swigregister, METH_VARARGS, NULL},
 
52430
         { (char *)"DirPickerCtrl_swiginit", DirPickerCtrl_swiginit, METH_VARARGS, NULL},
 
52431
         { (char *)"new_FileDirPickerEvent", (PyCFunction) _wrap_new_FileDirPickerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
52432
         { (char *)"FileDirPickerEvent_GetPath", (PyCFunction)_wrap_FileDirPickerEvent_GetPath, METH_O, NULL},
 
52433
         { (char *)"FileDirPickerEvent_SetPath", (PyCFunction) _wrap_FileDirPickerEvent_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52434
         { (char *)"FileDirPickerEvent_swigregister", FileDirPickerEvent_swigregister, METH_VARARGS, NULL},
 
52435
         { (char *)"FileDirPickerEvent_swiginit", FileDirPickerEvent_swiginit, METH_VARARGS, NULL},
 
52436
         { (char *)"new_FontPickerCtrl", (PyCFunction) _wrap_new_FontPickerCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52437
         { (char *)"new_PreFontPickerCtrl", (PyCFunction)_wrap_new_PreFontPickerCtrl, METH_NOARGS, NULL},
 
52438
         { (char *)"FontPickerCtrl_Create", (PyCFunction) _wrap_FontPickerCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52439
         { (char *)"FontPickerCtrl_GetSelectedFont", (PyCFunction)_wrap_FontPickerCtrl_GetSelectedFont, METH_O, NULL},
 
52440
         { (char *)"FontPickerCtrl_SetSelectedFont", (PyCFunction) _wrap_FontPickerCtrl_SetSelectedFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
52441
         { (char *)"FontPickerCtrl_SetMaxPointSize", (PyCFunction) _wrap_FontPickerCtrl_SetMaxPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
 
52442
         { (char *)"FontPickerCtrl_GetMaxPointSize", (PyCFunction)_wrap_FontPickerCtrl_GetMaxPointSize, METH_O, NULL},
 
52443
         { (char *)"FontPickerCtrl_swigregister", FontPickerCtrl_swigregister, METH_VARARGS, NULL},
 
52444
         { (char *)"FontPickerCtrl_swiginit", FontPickerCtrl_swiginit, METH_VARARGS, NULL},
 
52445
         { (char *)"new_FontPickerEvent", (PyCFunction) _wrap_new_FontPickerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
52446
         { (char *)"FontPickerEvent_GetFont", (PyCFunction)_wrap_FontPickerEvent_GetFont, METH_O, NULL},
 
52447
         { (char *)"FontPickerEvent_SetFont", (PyCFunction) _wrap_FontPickerEvent_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
 
52448
         { (char *)"FontPickerEvent_swigregister", FontPickerEvent_swigregister, METH_VARARGS, NULL},
 
52449
         { (char *)"FontPickerEvent_swiginit", FontPickerEvent_swiginit, METH_VARARGS, NULL},
 
52450
         { (char *)"new_CollapsiblePane", (PyCFunction) _wrap_new_CollapsiblePane, METH_VARARGS | METH_KEYWORDS, NULL},
 
52451
         { (char *)"new_PreCollapsiblePane", (PyCFunction)_wrap_new_PreCollapsiblePane, METH_NOARGS, NULL},
 
52452
         { (char *)"CollapsiblePane_Create", (PyCFunction) _wrap_CollapsiblePane_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52453
         { (char *)"CollapsiblePane_Collapse", (PyCFunction) _wrap_CollapsiblePane_Collapse, METH_VARARGS | METH_KEYWORDS, NULL},
 
52454
         { (char *)"CollapsiblePane_Expand", (PyCFunction)_wrap_CollapsiblePane_Expand, METH_O, NULL},
 
52455
         { (char *)"CollapsiblePane_IsCollapsed", (PyCFunction)_wrap_CollapsiblePane_IsCollapsed, METH_O, NULL},
 
52456
         { (char *)"CollapsiblePane_IsExpanded", (PyCFunction)_wrap_CollapsiblePane_IsExpanded, METH_O, NULL},
 
52457
         { (char *)"CollapsiblePane_GetPane", (PyCFunction)_wrap_CollapsiblePane_GetPane, METH_O, NULL},
 
52458
         { (char *)"CollapsiblePane_swigregister", CollapsiblePane_swigregister, METH_VARARGS, NULL},
 
52459
         { (char *)"CollapsiblePane_swiginit", CollapsiblePane_swiginit, METH_VARARGS, NULL},
 
52460
         { (char *)"new_CollapsiblePaneEvent", (PyCFunction) _wrap_new_CollapsiblePaneEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
52461
         { (char *)"CollapsiblePaneEvent_GetCollapsed", (PyCFunction)_wrap_CollapsiblePaneEvent_GetCollapsed, METH_O, NULL},
 
52462
         { (char *)"CollapsiblePaneEvent_SetCollapsed", (PyCFunction) _wrap_CollapsiblePaneEvent_SetCollapsed, METH_VARARGS | METH_KEYWORDS, NULL},
 
52463
         { (char *)"CollapsiblePaneEvent_swigregister", CollapsiblePaneEvent_swigregister, METH_VARARGS, NULL},
 
52464
         { (char *)"CollapsiblePaneEvent_swiginit", CollapsiblePaneEvent_swiginit, METH_VARARGS, NULL},
 
52465
         { (char *)"SearchCtrlBase_swigregister", SearchCtrlBase_swigregister, METH_VARARGS, NULL},
 
52466
         { (char *)"new_SearchCtrl", (PyCFunction) _wrap_new_SearchCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52467
         { (char *)"new_PreSearchCtrl", (PyCFunction)_wrap_new_PreSearchCtrl, METH_NOARGS, NULL},
 
52468
         { (char *)"SearchCtrl_Create", (PyCFunction) _wrap_SearchCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52469
         { (char *)"SearchCtrl_SetMenu", (PyCFunction) _wrap_SearchCtrl_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
 
52470
         { (char *)"SearchCtrl_GetMenu", (PyCFunction)_wrap_SearchCtrl_GetMenu, METH_O, NULL},
 
52471
         { (char *)"SearchCtrl_ShowSearchButton", (PyCFunction) _wrap_SearchCtrl_ShowSearchButton, METH_VARARGS | METH_KEYWORDS, NULL},
 
52472
         { (char *)"SearchCtrl_IsSearchButtonVisible", (PyCFunction)_wrap_SearchCtrl_IsSearchButtonVisible, METH_O, NULL},
 
52473
         { (char *)"SearchCtrl_ShowCancelButton", (PyCFunction) _wrap_SearchCtrl_ShowCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
 
52474
         { (char *)"SearchCtrl_IsCancelButtonVisible", (PyCFunction)_wrap_SearchCtrl_IsCancelButtonVisible, METH_O, NULL},
 
52475
         { (char *)"SearchCtrl_SetDescriptiveText", (PyCFunction) _wrap_SearchCtrl_SetDescriptiveText, METH_VARARGS | METH_KEYWORDS, NULL},
 
52476
         { (char *)"SearchCtrl_GetDescriptiveText", (PyCFunction)_wrap_SearchCtrl_GetDescriptiveText, METH_O, NULL},
 
52477
         { (char *)"SearchCtrl_SetSearchBitmap", (PyCFunction) _wrap_SearchCtrl_SetSearchBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
52478
         { (char *)"SearchCtrl_SetSearchMenuBitmap", (PyCFunction) _wrap_SearchCtrl_SetSearchMenuBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
52479
         { (char *)"SearchCtrl_SetCancelBitmap", (PyCFunction) _wrap_SearchCtrl_SetCancelBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
 
52480
         { (char *)"SearchCtrl_swigregister", SearchCtrl_swigregister, METH_VARARGS, NULL},
 
52481
         { (char *)"SearchCtrl_swiginit", SearchCtrl_swiginit, METH_VARARGS, NULL},
 
52482
         { (char *)"new_FileCtrl", (PyCFunction) _wrap_new_FileCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
 
52483
         { (char *)"new_PreFileCtrl", (PyCFunction)_wrap_new_PreFileCtrl, METH_NOARGS, NULL},
 
52484
         { (char *)"FileCtrl_Create", (PyCFunction) _wrap_FileCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52485
         { (char *)"FileCtrl_SetWildcard", (PyCFunction) _wrap_FileCtrl_SetWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
 
52486
         { (char *)"FileCtrl_SetFilterIndex", (PyCFunction) _wrap_FileCtrl_SetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
 
52487
         { (char *)"FileCtrl_SetDirectory", (PyCFunction) _wrap_FileCtrl_SetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
 
52488
         { (char *)"FileCtrl_SetFilename", (PyCFunction) _wrap_FileCtrl_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},
 
52489
         { (char *)"FileCtrl_SetPath", (PyCFunction) _wrap_FileCtrl_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
 
52490
         { (char *)"FileCtrl_GetFilename", (PyCFunction)_wrap_FileCtrl_GetFilename, METH_O, NULL},
 
52491
         { (char *)"FileCtrl_GetDirectory", (PyCFunction)_wrap_FileCtrl_GetDirectory, METH_O, NULL},
 
52492
         { (char *)"FileCtrl_GetWildcard", (PyCFunction)_wrap_FileCtrl_GetWildcard, METH_O, NULL},
 
52493
         { (char *)"FileCtrl_GetPath", (PyCFunction)_wrap_FileCtrl_GetPath, METH_O, NULL},
 
52494
         { (char *)"FileCtrl_GetFilterIndex", (PyCFunction)_wrap_FileCtrl_GetFilterIndex, METH_O, NULL},
 
52495
         { (char *)"FileCtrl_GetPaths", (PyCFunction)_wrap_FileCtrl_GetPaths, METH_O, NULL},
 
52496
         { (char *)"FileCtrl_GetFilenames", (PyCFunction)_wrap_FileCtrl_GetFilenames, METH_O, NULL},
 
52497
         { (char *)"FileCtrl_HasMultipleFileSelection", (PyCFunction)_wrap_FileCtrl_HasMultipleFileSelection, METH_O, NULL},
 
52498
         { (char *)"FileCtrl_ShowHidden", (PyCFunction) _wrap_FileCtrl_ShowHidden, METH_VARARGS | METH_KEYWORDS, NULL},
 
52499
         { (char *)"FileCtrl_swigregister", FileCtrl_swigregister, METH_VARARGS, NULL},
 
52500
         { (char *)"FileCtrl_swiginit", FileCtrl_swiginit, METH_VARARGS, NULL},
 
52501
         { (char *)"new_FileCtrlEvent", (PyCFunction) _wrap_new_FileCtrlEvent, METH_VARARGS | METH_KEYWORDS, NULL},
 
52502
         { (char *)"FileCtrlEvent_SetFiles", (PyCFunction) _wrap_FileCtrlEvent_SetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
 
52503
         { (char *)"FileCtrlEvent_SetDirectory", (PyCFunction) _wrap_FileCtrlEvent_SetDirectory, METH_VARARGS | METH_KEYWORDS, NULL},
 
52504
         { (char *)"FileCtrlEvent_SetFilterIndex", (PyCFunction) _wrap_FileCtrlEvent_SetFilterIndex, METH_VARARGS | METH_KEYWORDS, NULL},
 
52505
         { (char *)"FileCtrlEvent_GetFiles", (PyCFunction)_wrap_FileCtrlEvent_GetFiles, METH_O, NULL},
 
52506
         { (char *)"FileCtrlEvent_GetDirectory", (PyCFunction)_wrap_FileCtrlEvent_GetDirectory, METH_O, NULL},
 
52507
         { (char *)"FileCtrlEvent_GetFilterIndex", (PyCFunction)_wrap_FileCtrlEvent_GetFilterIndex, METH_O, NULL},
 
52508
         { (char *)"FileCtrlEvent_GetFile", (PyCFunction)_wrap_FileCtrlEvent_GetFile, METH_O, NULL},
 
52509
         { (char *)"FileCtrlEvent_swigregister", FileCtrlEvent_swigregister, METH_VARARGS, NULL},
 
52510
         { (char *)"FileCtrlEvent_swiginit", FileCtrlEvent_swiginit, METH_VARARGS, NULL},
 
52511
         { (char *)"new_InfoBar", (PyCFunction) _wrap_new_InfoBar, METH_VARARGS | METH_KEYWORDS, NULL},
 
52512
         { (char *)"new_PreInfoBar", (PyCFunction)_wrap_new_PreInfoBar, METH_NOARGS, NULL},
 
52513
         { (char *)"InfoBar_Create", (PyCFunction) _wrap_InfoBar_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52514
         { (char *)"InfoBar_ShowMessage", (PyCFunction) _wrap_InfoBar_ShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
 
52515
         { (char *)"InfoBar_Dismiss", (PyCFunction)_wrap_InfoBar_Dismiss, METH_O, NULL},
 
52516
         { (char *)"InfoBar_AddButton", (PyCFunction) _wrap_InfoBar_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
 
52517
         { (char *)"InfoBar_RemoveButton", (PyCFunction) _wrap_InfoBar_RemoveButton, METH_VARARGS | METH_KEYWORDS, NULL},
 
52518
         { (char *)"InfoBar_SetShowHideEffects", (PyCFunction) _wrap_InfoBar_SetShowHideEffects, METH_VARARGS | METH_KEYWORDS, NULL},
 
52519
         { (char *)"InfoBar_GetShowEffect", (PyCFunction)_wrap_InfoBar_GetShowEffect, METH_O, NULL},
 
52520
         { (char *)"InfoBar_GetHideEffect", (PyCFunction)_wrap_InfoBar_GetHideEffect, METH_O, NULL},
 
52521
         { (char *)"InfoBar_SetEffectDuration", (PyCFunction) _wrap_InfoBar_SetEffectDuration, METH_VARARGS | METH_KEYWORDS, NULL},
 
52522
         { (char *)"InfoBar_GetEffectDuration", (PyCFunction)_wrap_InfoBar_GetEffectDuration, METH_O, NULL},
 
52523
         { (char *)"InfoBar_swigregister", InfoBar_swigregister, METH_VARARGS, NULL},
 
52524
         { (char *)"InfoBar_swiginit", InfoBar_swiginit, METH_VARARGS, NULL},
 
52525
         { (char *)"new_CommandLinkButton", (PyCFunction) _wrap_new_CommandLinkButton, METH_VARARGS | METH_KEYWORDS, NULL},
 
52526
         { (char *)"new_PreCommandLinkButton", (PyCFunction)_wrap_new_PreCommandLinkButton, METH_NOARGS, NULL},
 
52527
         { (char *)"CommandLinkButton_Create", (PyCFunction) _wrap_CommandLinkButton_Create, METH_VARARGS | METH_KEYWORDS, NULL},
 
52528
         { (char *)"CommandLinkButton_SetMainLabelAndNote", (PyCFunction) _wrap_CommandLinkButton_SetMainLabelAndNote, METH_VARARGS | METH_KEYWORDS, NULL},
 
52529
         { (char *)"CommandLinkButton_SetMainLabel", (PyCFunction) _wrap_CommandLinkButton_SetMainLabel, METH_VARARGS | METH_KEYWORDS, NULL},
 
52530
         { (char *)"CommandLinkButton_SetNote", (PyCFunction) _wrap_CommandLinkButton_SetNote, METH_VARARGS | METH_KEYWORDS, NULL},
 
52531
         { (char *)"CommandLinkButton_GetMainLabel", (PyCFunction)_wrap_CommandLinkButton_GetMainLabel, METH_O, NULL},
 
52532
         { (char *)"CommandLinkButton_GetNote", (PyCFunction)_wrap_CommandLinkButton_GetNote, METH_O, NULL},
 
52533
         { (char *)"CommandLinkButton_swigregister", CommandLinkButton_swigregister, METH_VARARGS, NULL},
 
52534
         { (char *)"CommandLinkButton_swiginit", CommandLinkButton_swiginit, METH_VARARGS, NULL},
 
52535
         { NULL, NULL, 0, NULL }
 
52536
};
 
52537
 
 
52538
 
 
52539
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
52540
 
 
52541
static void *_p_wxComboBoxTo_p_wxTextEntryBase(void *x) {
 
52542
    return (void *)((wxTextEntryBase *) (wxTextEntry *) ((wxComboBox *) x));
 
52543
}
 
52544
static void *_p_wxTextCtrlBaseTo_p_wxTextEntryBase(void *x) {
 
52545
    return (void *)((wxTextEntryBase *) (wxTextEntry *) ((wxTextCtrlBase *) x));
 
52546
}
 
52547
static void *_p_wxSearchCtrlBaseTo_p_wxTextEntryBase(void *x) {
 
52548
    return (void *)((wxTextEntryBase *) (wxTextCtrlIface *) ((wxSearchCtrlBase *) x));
 
52549
}
 
52550
static void *_p_wxTextCtrlTo_p_wxTextEntryBase(void *x) {
 
52551
    return (void *)((wxTextEntryBase *) (wxTextEntry *)(wxTextCtrlBase *) ((wxTextCtrl *) x));
 
52552
}
 
52553
static void *_p_wxTextEntryTo_p_wxTextEntryBase(void *x) {
 
52554
    return (void *)((wxTextEntryBase *)  ((wxTextEntry *) x));
 
52555
}
 
52556
static void *_p_wxTextCtrlIfaceTo_p_wxTextEntryBase(void *x) {
 
52557
    return (void *)((wxTextEntryBase *)  ((wxTextCtrlIface *) x));
 
52558
}
 
52559
static void *_p_wxSearchCtrlTo_p_wxTextEntryBase(void *x) {
 
52560
    return (void *)((wxTextEntryBase *) (wxTextCtrlIface *)(wxSearchCtrlBase *) ((wxSearchCtrl *) x));
 
52561
}
 
52562
static void *_p_wxComboBoxTo_p_wxTextEntry(void *x) {
 
52563
    return (void *)((wxTextEntry *)  ((wxComboBox *) x));
 
52564
}
 
52565
static void *_p_wxTextCtrlBaseTo_p_wxTextEntry(void *x) {
 
52566
    return (void *)((wxTextEntry *)  ((wxTextCtrlBase *) x));
 
52567
}
 
52568
static void *_p_wxTextCtrlTo_p_wxTextEntry(void *x) {
 
52569
    return (void *)((wxTextEntry *) (wxTextCtrlBase *) ((wxTextCtrl *) x));
 
52570
}
 
52571
static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
 
52572
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
 
52573
}
 
52574
static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
 
52575
    return (void *)((wxEvent *)  ((wxMenuEvent *) x));
 
52576
}
 
52577
static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
 
52578
    return (void *)((wxEvent *)  ((wxCloseEvent *) x));
 
52579
}
 
52580
static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
 
52581
    return (void *)((wxEvent *)  ((wxMouseEvent *) x));
 
52582
}
 
52583
static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
 
52584
    return (void *)((wxEvent *)  ((wxEraseEvent *) x));
 
52585
}
 
52586
static void *_p_wxTreeEventTo_p_wxEvent(void *x) {
 
52587
    return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxTreeEvent *) x));
 
52588
}
 
52589
static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
 
52590
    return (void *)((wxEvent *)  ((wxSetCursorEvent *) x));
 
52591
}
 
52592
static void *_p_wxColourPickerEventTo_p_wxEvent(void *x) {
 
52593
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxColourPickerEvent *) x));
 
52594
}
 
52595
static void *_p_wxFileDirPickerEventTo_p_wxEvent(void *x) {
 
52596
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxFileDirPickerEvent *) x));
 
52597
}
 
52598
static void *_p_wxFontPickerEventTo_p_wxEvent(void *x) {
 
52599
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxFontPickerEvent *) x));
 
52600
}
 
52601
static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
 
52602
    return (void *)((wxEvent *)  ((wxInitDialogEvent *) x));
 
52603
}
 
52604
static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
 
52605
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
 
52606
}
 
52607
static void *_p_wxBookCtrlEventTo_p_wxEvent(void *x) {
 
52608
    return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxBookCtrlEvent *) x));
 
52609
}
 
52610
static void *_p_wxTextUrlEventTo_p_wxEvent(void *x) {
 
52611
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxTextUrlEvent *) x));
 
52612
}
 
52613
static void *_p_wxFileCtrlEventTo_p_wxEvent(void *x) {
 
52614
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxFileCtrlEvent *) x));
 
52615
}
 
52616
static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
 
52617
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
 
52618
}
 
52619
static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
 
52620
    return (void *)((wxEvent *)  ((wxMouseCaptureLostEvent *) x));
 
52621
}
 
52622
static void *_p_wxPyEventTo_p_wxEvent(void *x) {
 
52623
    return (void *)((wxEvent *)  ((wxPyEvent *) x));
 
52624
}
 
52625
static void *_p_wxListEventTo_p_wxEvent(void *x) {
 
52626
    return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxListEvent *) x));
 
52627
}
 
52628
static void *_p_wxHelpEventTo_p_wxEvent(void *x) {
 
52629
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxHelpEvent *) x));
 
52630
}
 
52631
static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
 
52632
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
 
52633
}
 
52634
static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
 
52635
    return (void *)((wxEvent *)  ((wxQueryNewPaletteEvent *) x));
 
52636
}
 
52637
static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
 
52638
    return (void *)((wxEvent *)  ((wxMaximizeEvent *) x));
 
52639
}
 
52640
static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
 
52641
    return (void *)((wxEvent *)  ((wxIconizeEvent *) x));
 
52642
}
 
52643
static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
 
52644
    return (void *)((wxEvent *)  ((wxActivateEvent *) x));
 
52645
}
 
52646
static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
 
52647
    return (void *)((wxEvent *)  ((wxSizeEvent *) x));
 
52648
}
 
52649
static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
 
52650
    return (void *)((wxEvent *)  ((wxMoveEvent *) x));
 
52651
}
 
52652
static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
 
52653
    return (void *)((wxEvent *)  ((wxIdleEvent *) x));
 
52654
}
 
52655
static void *_p_wxDateEventTo_p_wxEvent(void *x) {
 
52656
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
 
52657
}
 
52658
static void *_p_wxSpinDoubleEventTo_p_wxEvent(void *x) {
 
52659
    return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSpinDoubleEvent *) x));
 
52660
}
 
52661
static void *_p_wxCollapsiblePaneEventTo_p_wxEvent(void *x) {
 
52662
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxCollapsiblePaneEvent *) x));
 
52663
}
 
52664
static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
 
52665
    return (void *)((wxEvent *)  ((wxPaintEvent *) x));
 
52666
}
 
52667
static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
 
52668
    return (void *)((wxEvent *)  ((wxNcPaintEvent *) x));
 
52669
}
 
52670
static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
 
52671
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
 
52672
}
 
52673
static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
 
52674
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
 
52675
}
 
52676
static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
 
52677
    return (void *)((wxEvent *)  ((wxPaletteChangedEvent *) x));
 
52678
}
 
52679
static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
 
52680
    return (void *)((wxEvent *)  ((wxDisplayChangedEvent *) x));
 
52681
}
 
52682
static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
 
52683
    return (void *)((wxEvent *)  ((wxMouseCaptureChangedEvent *) x));
 
52684
}
 
52685
static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
 
52686
    return (void *)((wxEvent *)  ((wxSysColourChangedEvent *) x));
 
52687
}
 
52688
static void *_p_wxThreadEventTo_p_wxEvent(void *x) {
 
52689
    return (void *)((wxEvent *)  ((wxThreadEvent *) x));
 
52690
}
 
52691
static void *_p_wxHyperlinkEventTo_p_wxEvent(void *x) {
 
52692
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxHyperlinkEvent *) x));
 
52693
}
 
52694
static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
 
52695
    return (void *)((wxEvent *)  ((wxDropFilesEvent *) x));
 
52696
}
 
52697
static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
 
52698
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
 
52699
}
 
52700
static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
 
52701
    return (void *)((wxEvent *)  ((wxFocusEvent *) x));
 
52702
}
 
52703
static void *_p_wxShowEventTo_p_wxEvent(void *x) {
 
52704
    return (void *)((wxEvent *)  ((wxShowEvent *) x));
 
52705
}
 
52706
static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
 
52707
    return (void *)((wxEvent *)  ((wxCommandEvent *) x));
 
52708
}
 
52709
static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
 
52710
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
 
52711
}
 
52712
static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
 
52713
    return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
 
52714
}
 
52715
static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
 
52716
    return (void *)((wxEvent *)  ((wxNavigationKeyEvent *) x));
 
52717
}
 
52718
static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
 
52719
    return (void *)((wxEvent *)  ((wxKeyEvent *) x));
 
52720
}
 
52721
static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
 
52722
    return (void *)((wxEvent *)  ((wxScrollWinEvent *) x));
 
52723
}
 
52724
static void *_p_wxSpinEventTo_p_wxEvent(void *x) {
 
52725
    return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSpinEvent *) x));
 
52726
}
 
52727
static void *_p_wxPyPickerBaseTo_p_wxPickerBase(void *x) {
 
52728
    return (void *)((wxPickerBase *)  ((wxPyPickerBase *) x));
 
52729
}
 
52730
static void *_p_wxColourPickerCtrlTo_p_wxPickerBase(void *x) {
 
52731
    return (void *)((wxPickerBase *)  ((wxColourPickerCtrl *) x));
 
52732
}
 
52733
static void *_p_wxFilePickerCtrlTo_p_wxPickerBase(void *x) {
 
52734
    return (void *)((wxPickerBase *)  ((wxFilePickerCtrl *) x));
 
52735
}
 
52736
static void *_p_wxDirPickerCtrlTo_p_wxPickerBase(void *x) {
 
52737
    return (void *)((wxPickerBase *)  ((wxDirPickerCtrl *) x));
 
52738
}
 
52739
static void *_p_wxFontPickerCtrlTo_p_wxPickerBase(void *x) {
 
52740
    return (void *)((wxPickerBase *)  ((wxFontPickerCtrl *) x));
 
52741
}
 
52742
static void *_p_wxComboBoxTo_p_wxItemContainer(void *x) {
 
52743
    return (void *)((wxItemContainer *)  ((wxComboBox *) x));
 
52744
}
 
52745
static void *_p_wxDirFilterListCtrlTo_p_wxItemContainer(void *x) {
 
52746
    return (void *)((wxItemContainer *) (wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
 
52747
}
 
52748
static void *_p_wxChoiceTo_p_wxItemContainer(void *x) {
 
52749
    return (void *)((wxItemContainer *) (wxControlWithItems *) ((wxChoice *) x));
 
52750
}
 
52751
static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
 
52752
    return (void *)((wxItemContainer *)  ((wxControlWithItems *) x));
 
52753
}
 
52754
static void *_p_wxListBoxTo_p_wxItemContainer(void *x) {
 
52755
    return (void *)((wxItemContainer *) (wxControlWithItems *) ((wxListBox *) x));
 
52756
}
 
52757
static void *_p_wxCheckListBoxTo_p_wxItemContainer(void *x) {
 
52758
    return (void *)((wxItemContainer *) (wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
 
52759
}
 
52760
static void *_p_wxListViewTo_p_wxPyListCtrl(void *x) {
 
52761
    return (void *)((wxPyListCtrl *)  ((wxListView *) x));
 
52762
}
 
52763
static void *_p_wxCollapsiblePaneTo_p_wxControl(void *x) {
 
52764
    return (void *)((wxControl *)  ((wxCollapsiblePane *) x));
 
52765
}
 
52766
static void *_p_wxTextCtrlBaseTo_p_wxControl(void *x) {
 
52767
    return (void *)((wxControl *)  ((wxTextCtrlBase *) x));
 
52768
}
 
52769
static void *_p_wxBookCtrlBaseTo_p_wxControl(void *x) {
 
52770
    return (void *)((wxControl *)  ((wxBookCtrlBase *) x));
 
52771
}
 
52772
static void *_p_wxToolBarTo_p_wxControl(void *x) {
 
52773
    return (void *)((wxControl *) (wxToolBarBase *) ((wxToolBar *) x));
 
52774
}
 
52775
static void *_p_wxDatePickerCtrlBaseTo_p_wxControl(void *x) {
 
52776
    return (void *)((wxControl *)  ((wxDatePickerCtrlBase *) x));
 
52777
}
 
52778
static void *_p_wxDatePickerCtrlGenericTo_p_wxControl(void *x) {
 
52779
    return (void *)((wxControl *) (wxDatePickerCtrlBase *) ((wxDatePickerCtrlGeneric *) x));
 
52780
}
 
52781
static void *_p_wxSearchCtrlBaseTo_p_wxControl(void *x) {
 
52782
    return (void *)((wxControl *)  ((wxSearchCtrlBase *) x));
 
52783
}
 
52784
static void *_p_wxInfoBarTo_p_wxControl(void *x) {
 
52785
    return (void *)((wxControl *)  ((wxInfoBar *) x));
 
52786
}
 
52787
static void *_p_wxPickerBaseTo_p_wxControl(void *x) {
 
52788
    return (void *)((wxControl *)  ((wxPickerBase *) x));
 
52789
}
 
52790
static void *_p_wxPyPickerBaseTo_p_wxControl(void *x) {
 
52791
    return (void *)((wxControl *) (wxPickerBase *) ((wxPyPickerBase *) x));
 
52792
}
 
52793
static void *_p_wxToggleButtonTo_p_wxControl(void *x) {
 
52794
    return (void *)((wxControl *) (wxAnyButton *) ((wxToggleButton *) x));
 
52795
}
 
52796
static void *_p_wxRadioButtonTo_p_wxControl(void *x) {
 
52797
    return (void *)((wxControl *)  ((wxRadioButton *) x));
 
52798
}
 
52799
static void *_p_wxAnyButtonTo_p_wxControl(void *x) {
 
52800
    return (void *)((wxControl *)  ((wxAnyButton *) x));
 
52801
}
 
52802
static void *_p_wxCommandLinkButtonTo_p_wxControl(void *x) {
 
52803
    return (void *)((wxControl *) (wxAnyButton *)(wxButton *) ((wxCommandLinkButton *) x));
 
52804
}
 
52805
static void *_p_wxSearchCtrlTo_p_wxControl(void *x) {
 
52806
    return (void *)((wxControl *) (wxSearchCtrlBase *) ((wxSearchCtrl *) x));
 
52807
}
 
52808
static void *_p_wxToolbookTo_p_wxControl(void *x) {
 
52809
    return (void *)((wxControl *) (wxBookCtrlBase *) ((wxToolbook *) x));
 
52810
}
 
52811
static void *_p_wxSpinCtrlDoubleTo_p_wxControl(void *x) {
 
52812
    return (void *)((wxControl *)  ((wxSpinCtrlDouble *) x));
 
52813
}
 
52814
static void *_p_wxToolBarBaseTo_p_wxControl(void *x) {
 
52815
    return (void *)((wxControl *)  ((wxToolBarBase *) x));
 
52816
}
 
52817
static void *_p_wxPyListCtrlTo_p_wxControl(void *x) {
 
52818
    return (void *)((wxControl *)  ((wxPyListCtrl *) x));
 
52819
}
 
52820
static void *_p_wxComboBoxTo_p_wxControl(void *x) {
 
52821
    return (void *)((wxControl *)  ((wxComboBox *) x));
 
52822
}
 
52823
static void *_p_wxDirFilterListCtrlTo_p_wxControl(void *x) {
 
52824
    return (void *)((wxControl *) (wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
 
52825
}
 
52826
static void *_p_wxPyControlTo_p_wxControl(void *x) {
 
52827
    return (void *)((wxControl *)  ((wxPyControl *) x));
 
52828
}
 
52829
static void *_p_wxGenericDirCtrlTo_p_wxControl(void *x) {
 
52830
    return (void *)((wxControl *)  ((wxGenericDirCtrl *) x));
 
52831
}
 
52832
static void *_p_wxScrollBarTo_p_wxControl(void *x) {
 
52833
    return (void *)((wxControl *)  ((wxScrollBar *) x));
 
52834
}
 
52835
static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
 
52836
    return (void *)((wxControl *)  ((wxControlWithItems *) x));
 
52837
}
 
52838
static void *_p_wxGaugeTo_p_wxControl(void *x) {
 
52839
    return (void *)((wxControl *)  ((wxGauge *) x));
 
52840
}
 
52841
static void *_p_wxStaticLineTo_p_wxControl(void *x) {
 
52842
    return (void *)((wxControl *)  ((wxStaticLine *) x));
 
52843
}
 
52844
static void *_p_wxChoicebookTo_p_wxControl(void *x) {
 
52845
    return (void *)((wxControl *) (wxBookCtrlBase *) ((wxChoicebook *) x));
 
52846
}
 
52847
static void *_p_wxListbookTo_p_wxControl(void *x) {
 
52848
    return (void *)((wxControl *) (wxBookCtrlBase *) ((wxListbook *) x));
 
52849
}
 
52850
static void *_p_wxHyperlinkCtrlTo_p_wxControl(void *x) {
 
52851
    return (void *)((wxControl *)  ((wxHyperlinkCtrl *) x));
 
52852
}
 
52853
static void *_p_wxPyTreeCtrlTo_p_wxControl(void *x) {
 
52854
    return (void *)((wxControl *)  ((wxPyTreeCtrl *) x));
 
52855
}
 
52856
static void *_p_wxCheckBoxTo_p_wxControl(void *x) {
 
52857
    return (void *)((wxControl *)  ((wxCheckBox *) x));
 
52858
}
 
52859
static void *_p_wxRadioBoxTo_p_wxControl(void *x) {
 
52860
    return (void *)((wxControl *)  ((wxRadioBox *) x));
 
52861
}
 
52862
static void *_p_wxCheckListBoxTo_p_wxControl(void *x) {
 
52863
    return (void *)((wxControl *) (wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
 
52864
}
 
52865
static void *_p_wxListBoxTo_p_wxControl(void *x) {
 
52866
    return (void *)((wxControl *) (wxControlWithItems *) ((wxListBox *) x));
 
52867
}
 
52868
static void *_p_wxChoiceTo_p_wxControl(void *x) {
 
52869
    return (void *)((wxControl *) (wxControlWithItems *) ((wxChoice *) x));
 
52870
}
 
52871
static void *_p_wxListViewTo_p_wxControl(void *x) {
 
52872
    return (void *)((wxControl *) (wxPyListCtrl *) ((wxListView *) x));
 
52873
}
 
52874
static void *_p_wxNotebookTo_p_wxControl(void *x) {
 
52875
    return (void *)((wxControl *) (wxBookCtrlBase *) ((wxNotebook *) x));
 
52876
}
 
52877
static void *_p_wxStaticBitmapTo_p_wxControl(void *x) {
 
52878
    return (void *)((wxControl *)  ((wxStaticBitmap *) x));
 
52879
}
 
52880
static void *_p_wxSpinCtrlTo_p_wxControl(void *x) {
 
52881
    return (void *)((wxControl *)  ((wxSpinCtrl *) x));
 
52882
}
 
52883
static void *_p_wxStaticTextTo_p_wxControl(void *x) {
 
52884
    return (void *)((wxControl *)  ((wxStaticText *) x));
 
52885
}
 
52886
static void *_p_wxStaticBoxTo_p_wxControl(void *x) {
 
52887
    return (void *)((wxControl *)  ((wxStaticBox *) x));
 
52888
}
 
52889
static void *_p_wxSliderTo_p_wxControl(void *x) {
 
52890
    return (void *)((wxControl *)  ((wxSlider *) x));
 
52891
}
 
52892
static void *_p_wxTreebookTo_p_wxControl(void *x) {
 
52893
    return (void *)((wxControl *) (wxBookCtrlBase *) ((wxTreebook *) x));
 
52894
}
 
52895
static void *_p_wxSpinButtonTo_p_wxControl(void *x) {
 
52896
    return (void *)((wxControl *)  ((wxSpinButton *) x));
 
52897
}
 
52898
static void *_p_wxButtonTo_p_wxControl(void *x) {
 
52899
    return (void *)((wxControl *) (wxAnyButton *) ((wxButton *) x));
 
52900
}
 
52901
static void *_p_wxBitmapButtonTo_p_wxControl(void *x) {
 
52902
    return (void *)((wxControl *) (wxAnyButton *)(wxButton *) ((wxBitmapButton *) x));
 
52903
}
 
52904
static void *_p_wxContextHelpButtonTo_p_wxControl(void *x) {
 
52905
    return (void *)((wxControl *) (wxAnyButton *)(wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
 
52906
}
 
52907
static void *_p_wxDatePickerCtrlTo_p_wxControl(void *x) {
 
52908
    return (void *)((wxControl *) (wxDatePickerCtrlBase *) ((wxDatePickerCtrl *) x));
 
52909
}
 
52910
static void *_p_wxColourPickerCtrlTo_p_wxControl(void *x) {
 
52911
    return (void *)((wxControl *) (wxPickerBase *) ((wxColourPickerCtrl *) x));
 
52912
}
 
52913
static void *_p_wxFilePickerCtrlTo_p_wxControl(void *x) {
 
52914
    return (void *)((wxControl *) (wxPickerBase *) ((wxFilePickerCtrl *) x));
 
52915
}
 
52916
static void *_p_wxDirPickerCtrlTo_p_wxControl(void *x) {
 
52917
    return (void *)((wxControl *) (wxPickerBase *) ((wxDirPickerCtrl *) x));
 
52918
}
 
52919
static void *_p_wxFontPickerCtrlTo_p_wxControl(void *x) {
 
52920
    return (void *)((wxControl *) (wxPickerBase *) ((wxFontPickerCtrl *) x));
 
52921
}
 
52922
static void *_p_wxTextCtrlTo_p_wxControl(void *x) {
 
52923
    return (void *)((wxControl *) (wxTextCtrlBase *) ((wxTextCtrl *) x));
 
52924
}
 
52925
static void *_p_wxToolBarTo_p_wxToolBarBase(void *x) {
 
52926
    return (void *)((wxToolBarBase *)  ((wxToolBar *) x));
 
52927
}
 
52928
static void *_p_wxButtonTo_p_wxAnyButton(void *x) {
 
52929
    return (void *)((wxAnyButton *)  ((wxButton *) x));
 
52930
}
 
52931
static void *_p_wxBitmapButtonTo_p_wxAnyButton(void *x) {
 
52932
    return (void *)((wxAnyButton *) (wxButton *) ((wxBitmapButton *) x));
 
52933
}
 
52934
static void *_p_wxContextHelpButtonTo_p_wxAnyButton(void *x) {
 
52935
    return (void *)((wxAnyButton *) (wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
 
52936
}
 
52937
static void *_p_wxToggleButtonTo_p_wxAnyButton(void *x) {
 
52938
    return (void *)((wxAnyButton *)  ((wxToggleButton *) x));
 
52939
}
 
52940
static void *_p_wxCommandLinkButtonTo_p_wxAnyButton(void *x) {
 
52941
    return (void *)((wxAnyButton *) (wxButton *) ((wxCommandLinkButton *) x));
 
52942
}
 
52943
static void *_p_wxDirFilterListCtrlTo_p_wxChoice(void *x) {
 
52944
    return (void *)((wxChoice *)  ((wxDirFilterListCtrl *) x));
 
52945
}
 
52946
static void *_p_wxTreeEventTo_p_wxNotifyEvent(void *x) {
 
52947
    return (void *)((wxNotifyEvent *)  ((wxTreeEvent *) x));
 
52948
}
 
52949
static void *_p_wxBookCtrlEventTo_p_wxNotifyEvent(void *x) {
 
52950
    return (void *)((wxNotifyEvent *)  ((wxBookCtrlEvent *) x));
 
52951
}
 
52952
static void *_p_wxSpinDoubleEventTo_p_wxNotifyEvent(void *x) {
 
52953
    return (void *)((wxNotifyEvent *)  ((wxSpinDoubleEvent *) x));
 
52954
}
 
52955
static void *_p_wxListEventTo_p_wxNotifyEvent(void *x) {
 
52956
    return (void *)((wxNotifyEvent *)  ((wxListEvent *) x));
 
52957
}
 
52958
static void *_p_wxSpinEventTo_p_wxNotifyEvent(void *x) {
 
52959
    return (void *)((wxNotifyEvent *)  ((wxSpinEvent *) x));
 
52960
}
 
52961
static void *_p_wxSearchCtrlBaseTo_p_wxTextCtrlIface(void *x) {
 
52962
    return (void *)((wxTextCtrlIface *)  ((wxSearchCtrlBase *) x));
 
52963
}
 
52964
static void *_p_wxSearchCtrlTo_p_wxTextCtrlIface(void *x) {
 
52965
    return (void *)((wxTextCtrlIface *) (wxSearchCtrlBase *) ((wxSearchCtrl *) x));
 
52966
}
 
52967
static void *_p_wxTextCtrlTo_p_wxTextCtrlBase(void *x) {
 
52968
    return (void *)((wxTextCtrlBase *)  ((wxTextCtrl *) x));
 
52969
}
 
52970
static void *_p_wxChoicebookTo_p_wxBookCtrlBase(void *x) {
 
52971
    return (void *)((wxBookCtrlBase *)  ((wxChoicebook *) x));
 
52972
}
 
52973
static void *_p_wxListbookTo_p_wxBookCtrlBase(void *x) {
 
52974
    return (void *)((wxBookCtrlBase *)  ((wxListbook *) x));
 
52975
}
 
52976
static void *_p_wxToolbookTo_p_wxBookCtrlBase(void *x) {
 
52977
    return (void *)((wxBookCtrlBase *)  ((wxToolbook *) x));
 
52978
}
 
52979
static void *_p_wxTreebookTo_p_wxBookCtrlBase(void *x) {
 
52980
    return (void *)((wxBookCtrlBase *)  ((wxTreebook *) x));
 
52981
}
 
52982
static void *_p_wxNotebookTo_p_wxBookCtrlBase(void *x) {
 
52983
    return (void *)((wxBookCtrlBase *)  ((wxNotebook *) x));
 
52984
}
 
52985
static void *_p_wxDatePickerCtrlGenericTo_p_wxDatePickerCtrlBase(void *x) {
 
52986
    return (void *)((wxDatePickerCtrlBase *)  ((wxDatePickerCtrlGeneric *) x));
 
52987
}
 
52988
static void *_p_wxDatePickerCtrlTo_p_wxDatePickerCtrlBase(void *x) {
 
52989
    return (void *)((wxDatePickerCtrlBase *)  ((wxDatePickerCtrl *) x));
 
52990
}
 
52991
static void *_p_wxSearchCtrlTo_p_wxSearchCtrlBase(void *x) {
 
52992
    return (void *)((wxSearchCtrlBase *)  ((wxSearchCtrl *) x));
 
52993
}
 
52994
static void *_p_wxCollapsiblePaneTo_p_wxEvtHandler(void *x) {
 
52995
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxCollapsiblePane *) x));
 
52996
}
 
52997
static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
 
52998
    return (void *)((wxEvtHandler *)  ((wxEventBlocker *) x));
 
52999
}
 
53000
static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
 
53001
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
 
53002
}
 
53003
static void *_p_wxTextCtrlBaseTo_p_wxEvtHandler(void *x) {
 
53004
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxTextCtrlBase *) x));
 
53005
}
 
53006
static void *_p_wxBookCtrlBaseTo_p_wxEvtHandler(void *x) {
 
53007
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxBookCtrlBase *) x));
 
53008
}
 
53009
static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
 
53010
    return (void *)((wxEvtHandler *)  ((wxValidator *) x));
 
53011
}
 
53012
static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
 
53013
    return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
 
53014
}
 
53015
static void *_p_wxToolBarTo_p_wxEvtHandler(void *x) {
 
53016
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxToolBarBase *) ((wxToolBar *) x));
 
53017
}
 
53018
static void *_p_wxDatePickerCtrlBaseTo_p_wxEvtHandler(void *x) {
 
53019
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxDatePickerCtrlBase *) x));
 
53020
}
 
53021
static void *_p_wxDatePickerCtrlGenericTo_p_wxEvtHandler(void *x) {
 
53022
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxDatePickerCtrlBase *) ((wxDatePickerCtrlGeneric *) x));
 
53023
}
 
53024
static void *_p_wxSearchCtrlBaseTo_p_wxEvtHandler(void *x) {
 
53025
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSearchCtrlBase *) x));
 
53026
}
 
53027
static void *_p_wxFileCtrlTo_p_wxEvtHandler(void *x) {
 
53028
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxFileCtrl *) x));
 
53029
}
 
53030
static void *_p_wxInfoBarTo_p_wxEvtHandler(void *x) {
 
53031
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxInfoBar *) x));
 
53032
}
 
53033
static void *_p_wxPickerBaseTo_p_wxEvtHandler(void *x) {
 
53034
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPickerBase *) x));
 
53035
}
 
53036
static void *_p_wxPyPickerBaseTo_p_wxEvtHandler(void *x) {
 
53037
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxPickerBase *) ((wxPyPickerBase *) x));
 
53038
}
 
53039
static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
 
53040
    return (void *)((wxEvtHandler *)  ((wxMenu *) x));
 
53041
}
 
53042
static void *_p_wxToggleButtonTo_p_wxEvtHandler(void *x) {
 
53043
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxAnyButton *) ((wxToggleButton *) x));
 
53044
}
 
53045
static void *_p_wxRadioButtonTo_p_wxEvtHandler(void *x) {
 
53046
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxRadioButton *) x));
 
53047
}
 
53048
static void *_p_wxAnyButtonTo_p_wxEvtHandler(void *x) {
 
53049
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxAnyButton *) x));
 
53050
}
 
53051
static void *_p_wxCommandLinkButtonTo_p_wxEvtHandler(void *x) {
 
53052
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxAnyButton *)(wxButton *) ((wxCommandLinkButton *) x));
 
53053
}
 
53054
static void *_p_wxSearchCtrlTo_p_wxEvtHandler(void *x) {
 
53055
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxSearchCtrlBase *) ((wxSearchCtrl *) x));
 
53056
}
 
53057
static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
 
53058
    return (void *)((wxEvtHandler *)  ((wxWindow *) x));
 
53059
}
 
53060
static void *_p_wxSpinCtrlDoubleTo_p_wxEvtHandler(void *x) {
 
53061
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSpinCtrlDouble *) x));
 
53062
}
 
53063
static void *_p_wxToolbookTo_p_wxEvtHandler(void *x) {
 
53064
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxToolbook *) x));
 
53065
}
 
53066
static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
 
53067
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
 
53068
}
 
53069
static void *_p_wxComboBoxTo_p_wxEvtHandler(void *x) {
 
53070
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxComboBox *) x));
 
53071
}
 
53072
static void *_p_wxToolBarBaseTo_p_wxEvtHandler(void *x) {
 
53073
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxToolBarBase *) x));
 
53074
}
 
53075
static void *_p_wxPyListCtrlTo_p_wxEvtHandler(void *x) {
 
53076
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPyListCtrl *) x));
 
53077
}
 
53078
static void *_p_wxDirFilterListCtrlTo_p_wxEvtHandler(void *x) {
 
53079
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
 
53080
}
 
53081
static void *_p_wxPyControlTo_p_wxEvtHandler(void *x) {
 
53082
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPyControl *) x));
 
53083
}
 
53084
static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
 
53085
    return (void *)((wxEvtHandler *)  ((wxPyApp *) x));
 
53086
}
 
53087
static void *_p_wxGenericDirCtrlTo_p_wxEvtHandler(void *x) {
 
53088
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxGenericDirCtrl *) x));
 
53089
}
 
53090
static void *_p_wxScrollBarTo_p_wxEvtHandler(void *x) {
 
53091
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxScrollBar *) x));
 
53092
}
 
53093
static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
 
53094
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
 
53095
}
 
53096
static void *_p_wxGaugeTo_p_wxEvtHandler(void *x) {
 
53097
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxGauge *) x));
 
53098
}
 
53099
static void *_p_wxStaticLineTo_p_wxEvtHandler(void *x) {
 
53100
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticLine *) x));
 
53101
}
 
53102
static void *_p_wxPyEvtHandlerTo_p_wxEvtHandler(void *x) {
 
53103
    return (void *)((wxEvtHandler *)  ((wxPyEvtHandler *) x));
 
53104
}
 
53105
static void *_p_wxChoicebookTo_p_wxEvtHandler(void *x) {
 
53106
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxChoicebook *) x));
 
53107
}
 
53108
static void *_p_wxListbookTo_p_wxEvtHandler(void *x) {
 
53109
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxListbook *) x));
 
53110
}
 
53111
static void *_p_wxHyperlinkCtrlTo_p_wxEvtHandler(void *x) {
 
53112
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxHyperlinkCtrl *) x));
 
53113
}
 
53114
static void *_p_wxPyTreeCtrlTo_p_wxEvtHandler(void *x) {
 
53115
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPyTreeCtrl *) x));
 
53116
}
 
53117
static void *_p_wxCheckBoxTo_p_wxEvtHandler(void *x) {
 
53118
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxCheckBox *) x));
 
53119
}
 
53120
static void *_p_wxRadioBoxTo_p_wxEvtHandler(void *x) {
 
53121
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxRadioBox *) x));
 
53122
}
 
53123
static void *_p_wxCheckListBoxTo_p_wxEvtHandler(void *x) {
 
53124
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
 
53125
}
 
53126
static void *_p_wxListBoxTo_p_wxEvtHandler(void *x) {
 
53127
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *) ((wxListBox *) x));
 
53128
}
 
53129
static void *_p_wxChoiceTo_p_wxEvtHandler(void *x) {
 
53130
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxControlWithItems *) ((wxChoice *) x));
 
53131
}
 
53132
static void *_p_wxStaticBitmapTo_p_wxEvtHandler(void *x) {
 
53133
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticBitmap *) x));
 
53134
}
 
53135
static void *_p_wxNotebookTo_p_wxEvtHandler(void *x) {
 
53136
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxNotebook *) x));
 
53137
}
 
53138
static void *_p_wxListViewTo_p_wxEvtHandler(void *x) {
 
53139
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxPyListCtrl *) ((wxListView *) x));
 
53140
}
 
53141
static void *_p_wxSpinCtrlTo_p_wxEvtHandler(void *x) {
 
53142
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSpinCtrl *) x));
 
53143
}
 
53144
static void *_p_wxStaticTextTo_p_wxEvtHandler(void *x) {
 
53145
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticText *) x));
 
53146
}
 
53147
static void *_p_wxStaticBoxTo_p_wxEvtHandler(void *x) {
 
53148
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStaticBox *) x));
 
53149
}
 
53150
static void *_p_wxSliderTo_p_wxEvtHandler(void *x) {
 
53151
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSlider *) x));
 
53152
}
 
53153
static void *_p_wxSpinButtonTo_p_wxEvtHandler(void *x) {
 
53154
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxSpinButton *) x));
 
53155
}
 
53156
static void *_p_wxBitmapButtonTo_p_wxEvtHandler(void *x) {
 
53157
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxAnyButton *)(wxButton *) ((wxBitmapButton *) x));
 
53158
}
 
53159
static void *_p_wxButtonTo_p_wxEvtHandler(void *x) {
 
53160
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxAnyButton *) ((wxButton *) x));
 
53161
}
 
53162
static void *_p_wxTreebookTo_p_wxEvtHandler(void *x) {
 
53163
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxTreebook *) x));
 
53164
}
 
53165
static void *_p_wxContextHelpButtonTo_p_wxEvtHandler(void *x) {
 
53166
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxAnyButton *)(wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
 
53167
}
 
53168
static void *_p_wxDatePickerCtrlTo_p_wxEvtHandler(void *x) {
 
53169
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxDatePickerCtrlBase *) ((wxDatePickerCtrl *) x));
 
53170
}
 
53171
static void *_p_wxColourPickerCtrlTo_p_wxEvtHandler(void *x) {
 
53172
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxPickerBase *) ((wxColourPickerCtrl *) x));
 
53173
}
 
53174
static void *_p_wxFilePickerCtrlTo_p_wxEvtHandler(void *x) {
 
53175
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxPickerBase *) ((wxFilePickerCtrl *) x));
 
53176
}
 
53177
static void *_p_wxDirPickerCtrlTo_p_wxEvtHandler(void *x) {
 
53178
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxPickerBase *) ((wxDirPickerCtrl *) x));
 
53179
}
 
53180
static void *_p_wxFontPickerCtrlTo_p_wxEvtHandler(void *x) {
 
53181
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxPickerBase *) ((wxFontPickerCtrl *) x));
 
53182
}
 
53183
static void *_p_wxTextCtrlTo_p_wxEvtHandler(void *x) {
 
53184
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxTextCtrlBase *) ((wxTextCtrl *) x));
 
53185
}
 
53186
static void *_p_wxCheckListBoxTo_p_wxListBox(void *x) {
 
53187
    return (void *)((wxListBox *)  ((wxCheckListBox *) x));
 
53188
}
 
53189
static void *_p_wxBitmapButtonTo_p_wxButton(void *x) {
 
53190
    return (void *)((wxButton *)  ((wxBitmapButton *) x));
 
53191
}
 
53192
static void *_p_wxContextHelpButtonTo_p_wxButton(void *x) {
 
53193
    return (void *)((wxButton *) (wxBitmapButton *) ((wxContextHelpButton *) x));
 
53194
}
 
53195
static void *_p_wxCommandLinkButtonTo_p_wxButton(void *x) {
 
53196
    return (void *)((wxButton *)  ((wxCommandLinkButton *) x));
 
53197
}
 
53198
static void *_p_wxContextHelpButtonTo_p_wxBitmapButton(void *x) {
 
53199
    return (void *)((wxBitmapButton *)  ((wxContextHelpButton *) x));
 
53200
}
 
53201
static void *_p_wxSimpleHelpProviderTo_p_wxHelpProvider(void *x) {
 
53202
    return (void *)((wxHelpProvider *)  ((wxSimpleHelpProvider *) x));
 
53203
}
 
53204
static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
 
53205
    return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
 
53206
}
 
53207
static void *_p_wxToolbookTo_p_wxObject(void *x) {
 
53208
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxToolbook *) x));
 
53209
}
 
53210
static void *_p_wxInfoBarTo_p_wxObject(void *x) {
 
53211
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxInfoBar *) x));
 
53212
}
 
53213
static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
 
53214
    return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
 
53215
}
 
53216
static void *_p_wxSizerItemTo_p_wxObject(void *x) {
 
53217
    return (void *)((wxObject *)  ((wxSizerItem *) x));
 
53218
}
 
53219
static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
 
53220
    return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
 
53221
}
 
53222
static void *_p_wxBookCtrlEventTo_p_wxObject(void *x) {
 
53223
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxBookCtrlEvent *) x));
 
53224
}
 
53225
static void *_p_wxScrollEventTo_p_wxObject(void *x) {
 
53226
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
 
53227
}
 
53228
static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
 
53229
    return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
 
53230
}
 
53231
static void *_p_wxTextUrlEventTo_p_wxObject(void *x) {
 
53232
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxTextUrlEvent *) x));
 
53233
}
 
53234
static void *_p_wxFileCtrlEventTo_p_wxObject(void *x) {
 
53235
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFileCtrlEvent *) x));
 
53236
}
 
53237
static void *_p_wxSizerTo_p_wxObject(void *x) {
 
53238
    return (void *)((wxObject *)  ((wxSizer *) x));
 
53239
}
 
53240
static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
 
53241
    return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
 
53242
}
 
53243
static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
 
53244
    return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
 
53245
}
 
53246
static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
 
53247
    return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
 
53248
}
 
53249
static void *_p_wxCheckBoxTo_p_wxObject(void *x) {
 
53250
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxCheckBox *) x));
 
53251
}
 
53252
static void *_p_wxPyTreeCtrlTo_p_wxObject(void *x) {
 
53253
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPyTreeCtrl *) x));
 
53254
}
 
53255
static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
 
53256
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
 
53257
}
 
53258
static void *_p_wxEventTo_p_wxObject(void *x) {
 
53259
    return (void *)((wxObject *)  ((wxEvent *) x));
 
53260
}
 
53261
static void *_p_wxGridSizerTo_p_wxObject(void *x) {
 
53262
    return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
 
53263
}
 
53264
static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
 
53265
    return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
 
53266
}
 
53267
static void *_p_wxSearchCtrlTo_p_wxObject(void *x) {
 
53268
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxSearchCtrlBase *) ((wxSearchCtrl *) x));
 
53269
}
 
53270
static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
 
53271
    return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
 
53272
}
 
53273
static void *_p_wxGenericDirCtrlTo_p_wxObject(void *x) {
 
53274
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxGenericDirCtrl *) x));
 
53275
}
 
53276
static void *_p_wxPickerBaseTo_p_wxObject(void *x) {
 
53277
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPickerBase *) x));
 
53278
}
 
53279
static void *_p_wxPyPickerBaseTo_p_wxObject(void *x) {
 
53280
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxPickerBase *) ((wxPyPickerBase *) x));
 
53281
}
 
53282
static void *_p_wxPyListCtrlTo_p_wxObject(void *x) {
 
53283
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPyListCtrl *) x));
 
53284
}
 
53285
static void *_p_wxDirItemDataTo_p_wxObject(void *x) {
 
53286
    return (void *)((wxObject *)  ((wxDirItemData *) x));
 
53287
}
 
53288
static void *_p_wxDirFilterListCtrlTo_p_wxObject(void *x) {
 
53289
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
 
53290
}
 
53291
static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
 
53292
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
 
53293
}
 
53294
static void *_p_wxPaintEventTo_p_wxObject(void *x) {
 
53295
    return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
 
53296
}
 
53297
static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
 
53298
    return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
 
53299
}
 
53300
static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
 
53301
    return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
 
53302
}
 
53303
static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
 
53304
    return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
 
53305
}
 
53306
static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
 
53307
    return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
 
53308
}
 
53309
static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
 
53310
    return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
 
53311
}
 
53312
static void *_p_wxThreadEventTo_p_wxObject(void *x) {
 
53313
    return (void *)((wxObject *) (wxEvent *) ((wxThreadEvent *) x));
 
53314
}
 
53315
static void *_p_wxStaticLineTo_p_wxObject(void *x) {
 
53316
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticLine *) x));
 
53317
}
 
53318
static void *_p_wxControlTo_p_wxObject(void *x) {
 
53319
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
 
53320
}
 
53321
static void *_p_wxPyControlTo_p_wxObject(void *x) {
 
53322
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPyControl *) x));
 
53323
}
 
53324
static void *_p_wxAnyButtonTo_p_wxObject(void *x) {
 
53325
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxAnyButton *) x));
 
53326
}
 
53327
static void *_p_wxGaugeTo_p_wxObject(void *x) {
 
53328
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxGauge *) x));
 
53329
}
 
53330
static void *_p_wxRadioButtonTo_p_wxObject(void *x) {
 
53331
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxRadioButton *) x));
 
53332
}
 
53333
static void *_p_wxToggleButtonTo_p_wxObject(void *x) {
 
53334
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxAnyButton *) ((wxToggleButton *) x));
 
53335
}
 
53336
static void *_p_wxToolBarBaseTo_p_wxObject(void *x) {
 
53337
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxToolBarBase *) x));
 
53338
}
 
53339
static void *_p_wxCommandLinkButtonTo_p_wxObject(void *x) {
 
53340
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxAnyButton *)(wxButton *) ((wxCommandLinkButton *) x));
 
53341
}
 
53342
static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
 
53343
    return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
 
53344
}
 
53345
static void *_p_wxColourPickerEventTo_p_wxObject(void *x) {
 
53346
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxColourPickerEvent *) x));
 
53347
}
 
53348
static void *_p_wxFileDirPickerEventTo_p_wxObject(void *x) {
 
53349
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFileDirPickerEvent *) x));
 
53350
}
 
53351
static void *_p_wxFontPickerEventTo_p_wxObject(void *x) {
 
53352
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFontPickerEvent *) x));
 
53353
}
 
53354
static void *_p_wxChoiceTo_p_wxObject(void *x) {
 
53355
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *) ((wxChoice *) x));
 
53356
}
 
53357
static void *_p_wxFSFileTo_p_wxObject(void *x) {
 
53358
    return (void *)((wxObject *)  ((wxFSFile *) x));
 
53359
}
 
53360
static void *_p_wxSpinCtrlDoubleTo_p_wxObject(void *x) {
 
53361
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSpinCtrlDouble *) x));
 
53362
}
 
53363
static void *_p_wxPySizerTo_p_wxObject(void *x) {
 
53364
    return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
 
53365
}
 
53366
static void *_p_wxTreebookTo_p_wxObject(void *x) {
 
53367
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxTreebook *) x));
 
53368
}
 
53369
static void *_p_wxListViewTo_p_wxObject(void *x) {
 
53370
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxPyListCtrl *) ((wxListView *) x));
 
53371
}
 
53372
static void *_p_wxHyperlinkEventTo_p_wxObject(void *x) {
 
53373
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxHyperlinkEvent *) x));
 
53374
}
 
53375
static void *_p_wxTextCtrlTo_p_wxObject(void *x) {
 
53376
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxTextCtrlBase *) ((wxTextCtrl *) x));
 
53377
}
 
53378
static void *_p_wxNotebookTo_p_wxObject(void *x) {
 
53379
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxNotebook *) x));
 
53380
}
 
53381
static void *_p_wxPyEventTo_p_wxObject(void *x) {
 
53382
    return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
 
53383
}
 
53384
static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
 
53385
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
 
53386
}
 
53387
static void *_p_wxChoicebookTo_p_wxObject(void *x) {
 
53388
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxChoicebook *) x));
 
53389
}
 
53390
static void *_p_wxDatePickerCtrlGenericTo_p_wxObject(void *x) {
 
53391
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxDatePickerCtrlBase *) ((wxDatePickerCtrlGeneric *) x));
 
53392
}
 
53393
static void *_p_wxListbookTo_p_wxObject(void *x) {
 
53394
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxBookCtrlBase *) ((wxListbook *) x));
 
53395
}
 
53396
static void *_p_wxShowEventTo_p_wxObject(void *x) {
 
53397
    return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
 
53398
}
 
53399
static void *_p_wxStaticBitmapTo_p_wxObject(void *x) {
 
53400
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticBitmap *) x));
 
53401
}
 
53402
static void *_p_wxSliderTo_p_wxObject(void *x) {
 
53403
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSlider *) x));
 
53404
}
 
53405
static void *_p_wxMenuItemTo_p_wxObject(void *x) {
 
53406
    return (void *)((wxObject *)  ((wxMenuItem *) x));
 
53407
}
 
53408
static void *_p_wxDateEventTo_p_wxObject(void *x) {
 
53409
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
 
53410
}
 
53411
static void *_p_wxIdleEventTo_p_wxObject(void *x) {
 
53412
    return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
 
53413
}
 
53414
static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
 
53415
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
 
53416
}
 
53417
static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
 
53418
    return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
 
53419
}
 
53420
static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
 
53421
    return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
 
53422
}
 
53423
static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
 
53424
    return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
 
53425
}
 
53426
static void *_p_wxActivateEventTo_p_wxObject(void *x) {
 
53427
    return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
 
53428
}
 
53429
static void *_p_wxSizeEventTo_p_wxObject(void *x) {
 
53430
    return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
 
53431
}
 
53432
static void *_p_wxMoveEventTo_p_wxObject(void *x) {
 
53433
    return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
 
53434
}
 
53435
static void *_p_wxStaticBoxTo_p_wxObject(void *x) {
 
53436
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticBox *) x));
 
53437
}
 
53438
static void *_p_wxSpinDoubleEventTo_p_wxObject(void *x) {
 
53439
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSpinDoubleEvent *) x));
 
53440
}
 
53441
static void *_p_wxContextHelpTo_p_wxObject(void *x) {
 
53442
    return (void *)((wxObject *)  ((wxContextHelp *) x));
 
53443
}
 
53444
static void *_p_wxCollapsiblePaneEventTo_p_wxObject(void *x) {
 
53445
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxCollapsiblePaneEvent *) x));
 
53446
}
 
53447
static void *_p_wxBookCtrlBaseTo_p_wxObject(void *x) {
 
53448
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxBookCtrlBase *) x));
 
53449
}
 
53450
static void *_p_wxTextCtrlBaseTo_p_wxObject(void *x) {
 
53451
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxTextCtrlBase *) x));
 
53452
}
 
53453
static void *_p_wxDatePickerCtrlBaseTo_p_wxObject(void *x) {
 
53454
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxDatePickerCtrlBase *) x));
 
53455
}
 
53456
static void *_p_wxSearchCtrlBaseTo_p_wxObject(void *x) {
 
53457
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSearchCtrlBase *) x));
 
53458
}
 
53459
static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
 
53460
    return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
 
53461
}
 
53462
static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
 
53463
    return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
 
53464
}
 
53465
static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
 
53466
    return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
 
53467
}
 
53468
static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
 
53469
    return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
 
53470
}
 
53471
static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
 
53472
    return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
 
53473
}
 
53474
static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
 
53475
    return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
 
53476
}
 
53477
static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
 
53478
    return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
 
53479
}
 
53480
static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
 
53481
    return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
 
53482
}
 
53483
static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
 
53484
    return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
 
53485
}
 
53486
static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
 
53487
    return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
 
53488
}
 
53489
static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
 
53490
    return (void *)((wxObject *)  ((wxImageHandler *) x));
 
53491
}
 
53492
static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
 
53493
    return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
 
53494
}
 
53495
static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
 
53496
    return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
 
53497
}
 
53498
static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
 
53499
    return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
 
53500
}
 
53501
static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
 
53502
    return (void *)((wxObject *)  ((wxEvtHandler *) x));
 
53503
}
 
53504
static void *_p_wxPyEvtHandlerTo_p_wxObject(void *x) {
 
53505
    return (void *)((wxObject *) (wxEvtHandler *) ((wxPyEvtHandler *) x));
 
53506
}
 
53507
static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
 
53508
    return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
 
53509
}
 
53510
static void *_p_wxListEventTo_p_wxObject(void *x) {
 
53511
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxListEvent *) x));
 
53512
}
 
53513
static void *_p_wxListBoxTo_p_wxObject(void *x) {
 
53514
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *) ((wxListBox *) x));
 
53515
}
 
53516
static void *_p_wxCheckListBoxTo_p_wxObject(void *x) {
 
53517
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
 
53518
}
 
53519
static void *_p_wxButtonTo_p_wxObject(void *x) {
 
53520
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxAnyButton *) ((wxButton *) x));
 
53521
}
 
53522
static void *_p_wxBitmapButtonTo_p_wxObject(void *x) {
 
53523
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxAnyButton *)(wxButton *) ((wxBitmapButton *) x));
 
53524
}
 
53525
static void *_p_wxSpinButtonTo_p_wxObject(void *x) {
 
53526
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSpinButton *) x));
 
53527
}
 
53528
static void *_p_wxContextHelpButtonTo_p_wxObject(void *x) {
 
53529
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxAnyButton *)(wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
 
53530
}
 
53531
static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
 
53532
    return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
 
53533
}
 
53534
static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
 
53535
    return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
 
53536
}
 
53537
static void *_p_wxScrollBarTo_p_wxObject(void *x) {
 
53538
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxScrollBar *) x));
 
53539
}
 
53540
static void *_p_wxRadioBoxTo_p_wxObject(void *x) {
 
53541
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxRadioBox *) x));
 
53542
}
 
53543
static void *_p_wxComboBoxTo_p_wxObject(void *x) {
 
53544
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxComboBox *) x));
 
53545
}
 
53546
static void *_p_wxHelpEventTo_p_wxObject(void *x) {
 
53547
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxHelpEvent *) x));
 
53548
}
 
53549
static void *_p_wxListItemTo_p_wxObject(void *x) {
 
53550
    return (void *)((wxObject *)  ((wxListItem *) x));
 
53551
}
 
53552
static void *_p_wxImageTo_p_wxObject(void *x) {
 
53553
    return (void *)((wxObject *)  ((wxImage *) x));
 
53554
}
 
53555
static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
 
53556
    return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
 
53557
}
 
53558
static void *_p_wxSpinEventTo_p_wxObject(void *x) {
 
53559
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSpinEvent *) x));
 
53560
}
 
53561
static void *_p_wxGenericDragImageTo_p_wxObject(void *x) {
 
53562
    return (void *)((wxObject *)  ((wxGenericDragImage *) x));
 
53563
}
 
53564
static void *_p_wxSpinCtrlTo_p_wxObject(void *x) {
 
53565
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxSpinCtrl *) x));
 
53566
}
 
53567
static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
 
53568
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
 
53569
}
 
53570
static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
 
53571
    return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
 
53572
}
 
53573
static void *_p_wxKeyEventTo_p_wxObject(void *x) {
 
53574
    return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
 
53575
}
 
53576
static void *_p_wxWindowTo_p_wxObject(void *x) {
 
53577
    return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
 
53578
}
 
53579
static void *_p_wxMenuTo_p_wxObject(void *x) {
 
53580
    return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
 
53581
}
 
53582
static void *_p_wxMenuBarTo_p_wxObject(void *x) {
 
53583
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
 
53584
}
 
53585
static void *_p_wxFileSystemTo_p_wxObject(void *x) {
 
53586
    return (void *)((wxObject *)  ((wxFileSystem *) x));
 
53587
}
 
53588
static void *_p_wxCollapsiblePaneTo_p_wxObject(void *x) {
 
53589
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxCollapsiblePane *) x));
 
53590
}
 
53591
static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
 
53592
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
 
53593
}
 
53594
static void *_p_wxMenuEventTo_p_wxObject(void *x) {
 
53595
    return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
 
53596
}
 
53597
static void *_p_wxPyAppTo_p_wxObject(void *x) {
 
53598
    return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
 
53599
}
 
53600
static void *_p_wxCloseEventTo_p_wxObject(void *x) {
 
53601
    return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
 
53602
}
 
53603
static void *_p_wxMouseEventTo_p_wxObject(void *x) {
 
53604
    return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
 
53605
}
 
53606
static void *_p_wxEraseEventTo_p_wxObject(void *x) {
 
53607
    return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
 
53608
}
 
53609
static void *_p_wxTreeEventTo_p_wxObject(void *x) {
 
53610
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxTreeEvent *) x));
 
53611
}
 
53612
static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
 
53613
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
 
53614
}
 
53615
static void *_p_wxCommandEventTo_p_wxObject(void *x) {
 
53616
    return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
 
53617
}
 
53618
static void *_p_wxWrapSizerTo_p_wxObject(void *x) {
 
53619
    return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxWrapSizer *) x));
 
53620
}
 
53621
static void *_p_wxStaticTextTo_p_wxObject(void *x) {
 
53622
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStaticText *) x));
 
53623
}
 
53624
static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
 
53625
    return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
 
53626
}
 
53627
static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
 
53628
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
 
53629
}
 
53630
static void *_p_wxFocusEventTo_p_wxObject(void *x) {
 
53631
    return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
 
53632
}
 
53633
static void *_p_wxDatePickerCtrlTo_p_wxObject(void *x) {
 
53634
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxDatePickerCtrlBase *) ((wxDatePickerCtrl *) x));
 
53635
}
 
53636
static void *_p_wxColourPickerCtrlTo_p_wxObject(void *x) {
 
53637
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxPickerBase *) ((wxColourPickerCtrl *) x));
 
53638
}
 
53639
static void *_p_wxFilePickerCtrlTo_p_wxObject(void *x) {
 
53640
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxPickerBase *) ((wxFilePickerCtrl *) x));
 
53641
}
 
53642
static void *_p_wxDirPickerCtrlTo_p_wxObject(void *x) {
 
53643
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxPickerBase *) ((wxDirPickerCtrl *) x));
 
53644
}
 
53645
static void *_p_wxFontPickerCtrlTo_p_wxObject(void *x) {
 
53646
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxPickerBase *) ((wxFontPickerCtrl *) x));
 
53647
}
 
53648
static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
 
53649
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
 
53650
}
 
53651
static void *_p_wxHyperlinkCtrlTo_p_wxObject(void *x) {
 
53652
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxHyperlinkCtrl *) x));
 
53653
}
 
53654
static void *_p_wxToolBarToolBaseTo_p_wxObject(void *x) {
 
53655
    return (void *)((wxObject *)  ((wxToolBarToolBase *) x));
 
53656
}
 
53657
static void *_p_wxToolBarTo_p_wxObject(void *x) {
 
53658
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxToolBarBase *) ((wxToolBar *) x));
 
53659
}
 
53660
static void *_p_wxFileCtrlTo_p_wxObject(void *x) {
 
53661
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxFileCtrl *) x));
 
53662
}
 
53663
static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
 
53664
    return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
 
53665
}
 
53666
static void *_p_wxValidatorTo_p_wxObject(void *x) {
 
53667
    return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
 
53668
}
 
53669
static void *_p_wxChoicebookTo_p_wxWithImages(void *x) {
 
53670
    return (void *)((wxWithImages *) (wxBookCtrlBase *) ((wxChoicebook *) x));
 
53671
}
 
53672
static void *_p_wxListbookTo_p_wxWithImages(void *x) {
 
53673
    return (void *)((wxWithImages *) (wxBookCtrlBase *) ((wxListbook *) x));
 
53674
}
 
53675
static void *_p_wxBookCtrlBaseTo_p_wxWithImages(void *x) {
 
53676
    return (void *)((wxWithImages *)  ((wxBookCtrlBase *) x));
 
53677
}
 
53678
static void *_p_wxToolbookTo_p_wxWithImages(void *x) {
 
53679
    return (void *)((wxWithImages *) (wxBookCtrlBase *) ((wxToolbook *) x));
 
53680
}
 
53681
static void *_p_wxTreebookTo_p_wxWithImages(void *x) {
 
53682
    return (void *)((wxWithImages *) (wxBookCtrlBase *) ((wxTreebook *) x));
 
53683
}
 
53684
static void *_p_wxNotebookTo_p_wxWithImages(void *x) {
 
53685
    return (void *)((wxWithImages *) (wxBookCtrlBase *) ((wxNotebook *) x));
 
53686
}
 
53687
static void *_p_wxCollapsiblePaneTo_p_wxWindow(void *x) {
 
53688
    return (void *)((wxWindow *) (wxControl *) ((wxCollapsiblePane *) x));
 
53689
}
 
53690
static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
 
53691
    return (void *)((wxWindow *)  ((wxMenuBar *) x));
 
53692
}
 
53693
static void *_p_wxTextCtrlBaseTo_p_wxWindow(void *x) {
 
53694
    return (void *)((wxWindow *) (wxControl *) ((wxTextCtrlBase *) x));
 
53695
}
 
53696
static void *_p_wxBookCtrlBaseTo_p_wxWindow(void *x) {
 
53697
    return (void *)((wxWindow *) (wxControl *) ((wxBookCtrlBase *) x));
 
53698
}
 
53699
static void *_p_wxToolBarTo_p_wxWindow(void *x) {
 
53700
    return (void *)((wxWindow *) (wxControl *)(wxToolBarBase *) ((wxToolBar *) x));
 
53701
}
 
53702
static void *_p_wxDatePickerCtrlBaseTo_p_wxWindow(void *x) {
 
53703
    return (void *)((wxWindow *) (wxControl *) ((wxDatePickerCtrlBase *) x));
 
53704
}
 
53705
static void *_p_wxDatePickerCtrlGenericTo_p_wxWindow(void *x) {
 
53706
    return (void *)((wxWindow *) (wxControl *)(wxDatePickerCtrlBase *) ((wxDatePickerCtrlGeneric *) x));
 
53707
}
 
53708
static void *_p_wxSearchCtrlBaseTo_p_wxWindow(void *x) {
 
53709
    return (void *)((wxWindow *) (wxControl *) ((wxSearchCtrlBase *) x));
 
53710
}
 
53711
static void *_p_wxFileCtrlTo_p_wxWindow(void *x) {
 
53712
    return (void *)((wxWindow *)  ((wxFileCtrl *) x));
 
53713
}
 
53714
static void *_p_wxInfoBarTo_p_wxWindow(void *x) {
 
53715
    return (void *)((wxWindow *) (wxControl *) ((wxInfoBar *) x));
 
53716
}
 
53717
static void *_p_wxPickerBaseTo_p_wxWindow(void *x) {
 
53718
    return (void *)((wxWindow *) (wxControl *) ((wxPickerBase *) x));
 
53719
}
 
53720
static void *_p_wxPyPickerBaseTo_p_wxWindow(void *x) {
 
53721
    return (void *)((wxWindow *) (wxControl *)(wxPickerBase *) ((wxPyPickerBase *) x));
 
53722
}
 
53723
static void *_p_wxToggleButtonTo_p_wxWindow(void *x) {
 
53724
    return (void *)((wxWindow *) (wxControl *)(wxAnyButton *) ((wxToggleButton *) x));
 
53725
}
 
53726
static void *_p_wxRadioButtonTo_p_wxWindow(void *x) {
 
53727
    return (void *)((wxWindow *) (wxControl *) ((wxRadioButton *) x));
 
53728
}
 
53729
static void *_p_wxAnyButtonTo_p_wxWindow(void *x) {
 
53730
    return (void *)((wxWindow *) (wxControl *) ((wxAnyButton *) x));
 
53731
}
 
53732
static void *_p_wxCommandLinkButtonTo_p_wxWindow(void *x) {
 
53733
    return (void *)((wxWindow *) (wxControl *)(wxAnyButton *)(wxButton *) ((wxCommandLinkButton *) x));
 
53734
}
 
53735
static void *_p_wxSearchCtrlTo_p_wxWindow(void *x) {
 
53736
    return (void *)((wxWindow *) (wxControl *)(wxSearchCtrlBase *) ((wxSearchCtrl *) x));
 
53737
}
 
53738
static void *_p_wxToolbookTo_p_wxWindow(void *x) {
 
53739
    return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxToolbook *) x));
 
53740
}
 
53741
static void *_p_wxSpinCtrlDoubleTo_p_wxWindow(void *x) {
 
53742
    return (void *)((wxWindow *) (wxControl *) ((wxSpinCtrlDouble *) x));
 
53743
}
 
53744
static void *_p_wxControlTo_p_wxWindow(void *x) {
 
53745
    return (void *)((wxWindow *)  ((wxControl *) x));
 
53746
}
 
53747
static void *_p_wxToolBarBaseTo_p_wxWindow(void *x) {
 
53748
    return (void *)((wxWindow *) (wxControl *) ((wxToolBarBase *) x));
 
53749
}
 
53750
static void *_p_wxComboBoxTo_p_wxWindow(void *x) {
 
53751
    return (void *)((wxWindow *) (wxControl *) ((wxComboBox *) x));
 
53752
}
 
53753
static void *_p_wxPyListCtrlTo_p_wxWindow(void *x) {
 
53754
    return (void *)((wxWindow *) (wxControl *) ((wxPyListCtrl *) x));
 
53755
}
 
53756
static void *_p_wxDirFilterListCtrlTo_p_wxWindow(void *x) {
 
53757
    return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *)(wxChoice *) ((wxDirFilterListCtrl *) x));
 
53758
}
 
53759
static void *_p_wxPyControlTo_p_wxWindow(void *x) {
 
53760
    return (void *)((wxWindow *) (wxControl *) ((wxPyControl *) x));
 
53761
}
 
53762
static void *_p_wxGenericDirCtrlTo_p_wxWindow(void *x) {
 
53763
    return (void *)((wxWindow *) (wxControl *) ((wxGenericDirCtrl *) x));
 
53764
}
 
53765
static void *_p_wxScrollBarTo_p_wxWindow(void *x) {
 
53766
    return (void *)((wxWindow *) (wxControl *) ((wxScrollBar *) x));
 
53767
}
 
53768
static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
 
53769
    return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
 
53770
}
 
53771
static void *_p_wxGaugeTo_p_wxWindow(void *x) {
 
53772
    return (void *)((wxWindow *) (wxControl *) ((wxGauge *) x));
 
53773
}
 
53774
static void *_p_wxStaticLineTo_p_wxWindow(void *x) {
 
53775
    return (void *)((wxWindow *) (wxControl *) ((wxStaticLine *) x));
 
53776
}
 
53777
static void *_p_wxChoicebookTo_p_wxWindow(void *x) {
 
53778
    return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxChoicebook *) x));
 
53779
}
 
53780
static void *_p_wxListbookTo_p_wxWindow(void *x) {
 
53781
    return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxListbook *) x));
 
53782
}
 
53783
static void *_p_wxHyperlinkCtrlTo_p_wxWindow(void *x) {
 
53784
    return (void *)((wxWindow *) (wxControl *) ((wxHyperlinkCtrl *) x));
 
53785
}
 
53786
static void *_p_wxPyTreeCtrlTo_p_wxWindow(void *x) {
 
53787
    return (void *)((wxWindow *) (wxControl *) ((wxPyTreeCtrl *) x));
 
53788
}
 
53789
static void *_p_wxCheckBoxTo_p_wxWindow(void *x) {
 
53790
    return (void *)((wxWindow *) (wxControl *) ((wxCheckBox *) x));
 
53791
}
 
53792
static void *_p_wxRadioBoxTo_p_wxWindow(void *x) {
 
53793
    return (void *)((wxWindow *) (wxControl *) ((wxRadioBox *) x));
 
53794
}
 
53795
static void *_p_wxCheckListBoxTo_p_wxWindow(void *x) {
 
53796
    return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *)(wxListBox *) ((wxCheckListBox *) x));
 
53797
}
 
53798
static void *_p_wxListBoxTo_p_wxWindow(void *x) {
 
53799
    return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *) ((wxListBox *) x));
 
53800
}
 
53801
static void *_p_wxChoiceTo_p_wxWindow(void *x) {
 
53802
    return (void *)((wxWindow *) (wxControl *)(wxControlWithItems *) ((wxChoice *) x));
 
53803
}
 
53804
static void *_p_wxNotebookTo_p_wxWindow(void *x) {
 
53805
    return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxNotebook *) x));
 
53806
}
 
53807
static void *_p_wxStaticBitmapTo_p_wxWindow(void *x) {
 
53808
    return (void *)((wxWindow *) (wxControl *) ((wxStaticBitmap *) x));
 
53809
}
 
53810
static void *_p_wxListViewTo_p_wxWindow(void *x) {
 
53811
    return (void *)((wxWindow *) (wxControl *)(wxPyListCtrl *) ((wxListView *) x));
 
53812
}
 
53813
static void *_p_wxSpinCtrlTo_p_wxWindow(void *x) {
 
53814
    return (void *)((wxWindow *) (wxControl *) ((wxSpinCtrl *) x));
 
53815
}
 
53816
static void *_p_wxStaticTextTo_p_wxWindow(void *x) {
 
53817
    return (void *)((wxWindow *) (wxControl *) ((wxStaticText *) x));
 
53818
}
 
53819
static void *_p_wxStaticBoxTo_p_wxWindow(void *x) {
 
53820
    return (void *)((wxWindow *) (wxControl *) ((wxStaticBox *) x));
 
53821
}
 
53822
static void *_p_wxSliderTo_p_wxWindow(void *x) {
 
53823
    return (void *)((wxWindow *) (wxControl *) ((wxSlider *) x));
 
53824
}
 
53825
static void *_p_wxTreebookTo_p_wxWindow(void *x) {
 
53826
    return (void *)((wxWindow *) (wxControl *)(wxBookCtrlBase *) ((wxTreebook *) x));
 
53827
}
 
53828
static void *_p_wxSpinButtonTo_p_wxWindow(void *x) {
 
53829
    return (void *)((wxWindow *) (wxControl *) ((wxSpinButton *) x));
 
53830
}
 
53831
static void *_p_wxButtonTo_p_wxWindow(void *x) {
 
53832
    return (void *)((wxWindow *) (wxControl *)(wxAnyButton *) ((wxButton *) x));
 
53833
}
 
53834
static void *_p_wxBitmapButtonTo_p_wxWindow(void *x) {
 
53835
    return (void *)((wxWindow *) (wxControl *)(wxAnyButton *)(wxButton *) ((wxBitmapButton *) x));
 
53836
}
 
53837
static void *_p_wxContextHelpButtonTo_p_wxWindow(void *x) {
 
53838
    return (void *)((wxWindow *) (wxControl *)(wxAnyButton *)(wxButton *)(wxBitmapButton *) ((wxContextHelpButton *) x));
 
53839
}
 
53840
static void *_p_wxDatePickerCtrlTo_p_wxWindow(void *x) {
 
53841
    return (void *)((wxWindow *) (wxControl *)(wxDatePickerCtrlBase *) ((wxDatePickerCtrl *) x));
 
53842
}
 
53843
static void *_p_wxColourPickerCtrlTo_p_wxWindow(void *x) {
 
53844
    return (void *)((wxWindow *) (wxControl *)(wxPickerBase *) ((wxColourPickerCtrl *) x));
 
53845
}
 
53846
static void *_p_wxFilePickerCtrlTo_p_wxWindow(void *x) {
 
53847
    return (void *)((wxWindow *) (wxControl *)(wxPickerBase *) ((wxFilePickerCtrl *) x));
 
53848
}
 
53849
static void *_p_wxDirPickerCtrlTo_p_wxWindow(void *x) {
 
53850
    return (void *)((wxWindow *) (wxControl *)(wxPickerBase *) ((wxDirPickerCtrl *) x));
 
53851
}
 
53852
static void *_p_wxFontPickerCtrlTo_p_wxWindow(void *x) {
 
53853
    return (void *)((wxWindow *) (wxControl *)(wxPickerBase *) ((wxFontPickerCtrl *) x));
 
53854
}
 
53855
static void *_p_wxTextCtrlTo_p_wxWindow(void *x) {
 
53856
    return (void *)((wxWindow *) (wxControl *)(wxTextCtrlBase *) ((wxTextCtrl *) x));
 
53857
}
 
53858
static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
 
53859
    return (void *)((wxCommandEvent *)  ((wxWindowDestroyEvent *) x));
 
53860
}
 
53861
static void *_p_wxHyperlinkEventTo_p_wxCommandEvent(void *x) {
 
53862
    return (void *)((wxCommandEvent *)  ((wxHyperlinkEvent *) x));
 
53863
}
 
53864
static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
 
53865
    return (void *)((wxCommandEvent *)  ((wxClipboardTextEvent *) x));
 
53866
}
 
53867
static void *_p_wxColourPickerEventTo_p_wxCommandEvent(void *x) {
 
53868
    return (void *)((wxCommandEvent *)  ((wxColourPickerEvent *) x));
 
53869
}
 
53870
static void *_p_wxFileDirPickerEventTo_p_wxCommandEvent(void *x) {
 
53871
    return (void *)((wxCommandEvent *)  ((wxFileDirPickerEvent *) x));
 
53872
}
 
53873
static void *_p_wxFontPickerEventTo_p_wxCommandEvent(void *x) {
 
53874
    return (void *)((wxCommandEvent *)  ((wxFontPickerEvent *) x));
 
53875
}
 
53876
static void *_p_wxTextUrlEventTo_p_wxCommandEvent(void *x) {
 
53877
    return (void *)((wxCommandEvent *)  ((wxTextUrlEvent *) x));
 
53878
}
 
53879
static void *_p_wxBookCtrlEventTo_p_wxCommandEvent(void *x) {
 
53880
    return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxBookCtrlEvent *) x));
 
53881
}
 
53882
static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
 
53883
    return (void *)((wxCommandEvent *)  ((wxScrollEvent *) x));
 
53884
}
 
53885
static void *_p_wxFileCtrlEventTo_p_wxCommandEvent(void *x) {
 
53886
    return (void *)((wxCommandEvent *)  ((wxFileCtrlEvent *) x));
 
53887
}
 
53888
static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
 
53889
    return (void *)((wxCommandEvent *)  ((wxPyCommandEvent *) x));
 
53890
}
 
53891
static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
 
53892
    return (void *)((wxCommandEvent *)  ((wxContextMenuEvent *) x));
 
53893
}
 
53894
static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
 
53895
    return (void *)((wxCommandEvent *)  ((wxChildFocusEvent *) x));
 
53896
}
 
53897
static void *_p_wxSpinDoubleEventTo_p_wxCommandEvent(void *x) {
 
53898
    return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSpinDoubleEvent *) x));
 
53899
}
 
53900
static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
 
53901
    return (void *)((wxCommandEvent *)  ((wxDateEvent *) x));
 
53902
}
 
53903
static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
 
53904
    return (void *)((wxCommandEvent *)  ((wxWindowCreateEvent *) x));
 
53905
}
 
53906
static void *_p_wxListEventTo_p_wxCommandEvent(void *x) {
 
53907
    return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxListEvent *) x));
 
53908
}
 
53909
static void *_p_wxCollapsiblePaneEventTo_p_wxCommandEvent(void *x) {
 
53910
    return (void *)((wxCommandEvent *)  ((wxCollapsiblePaneEvent *) x));
 
53911
}
 
53912
static void *_p_wxTreeEventTo_p_wxCommandEvent(void *x) {
 
53913
    return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxTreeEvent *) x));
 
53914
}
 
53915
static void *_p_wxSpinEventTo_p_wxCommandEvent(void *x) {
 
53916
    return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSpinEvent *) x));
 
53917
}
 
53918
static void *_p_wxHelpEventTo_p_wxCommandEvent(void *x) {
 
53919
    return (void *)((wxCommandEvent *)  ((wxHelpEvent *) x));
 
53920
}
 
53921
static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
 
53922
    return (void *)((wxCommandEvent *)  ((wxNotifyEvent *) x));
 
53923
}
 
53924
static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
 
53925
    return (void *)((wxCommandEvent *)  ((wxUpdateUIEvent *) x));
 
53926
}
 
53927
static void *_p_wxTextCtrlBaseTo_p_wxTextAreaBase(void *x) {
 
53928
    return (void *)((wxTextAreaBase *)  ((wxTextCtrlBase *) x));
 
53929
}
 
53930
static void *_p_wxSearchCtrlBaseTo_p_wxTextAreaBase(void *x) {
 
53931
    return (void *)((wxTextAreaBase *) (wxTextCtrlIface *) ((wxSearchCtrlBase *) x));
 
53932
}
 
53933
static void *_p_wxTextCtrlTo_p_wxTextAreaBase(void *x) {
 
53934
    return (void *)((wxTextAreaBase *) (wxTextCtrlBase *) ((wxTextCtrl *) x));
 
53935
}
 
53936
static void *_p_wxTextCtrlIfaceTo_p_wxTextAreaBase(void *x) {
 
53937
    return (void *)((wxTextAreaBase *)  ((wxTextCtrlIface *) x));
 
53938
}
 
53939
static void *_p_wxSearchCtrlTo_p_wxTextAreaBase(void *x) {
 
53940
    return (void *)((wxTextAreaBase *) (wxTextCtrlIface *)(wxSearchCtrlBase *) ((wxSearchCtrl *) x));
 
53941
}
 
53942
static void *_p_wxDirFilterListCtrlTo_p_wxControlWithItems(void *x) {
 
53943
    return (void *)((wxControlWithItems *) (wxChoice *) ((wxDirFilterListCtrl *) x));
 
53944
}
 
53945
static void *_p_wxChoiceTo_p_wxControlWithItems(void *x) {
 
53946
    return (void *)((wxControlWithItems *)  ((wxChoice *) x));
 
53947
}
 
53948
static void *_p_wxListBoxTo_p_wxControlWithItems(void *x) {
 
53949
    return (void *)((wxControlWithItems *)  ((wxListBox *) x));
 
53950
}
 
53951
static void *_p_wxCheckListBoxTo_p_wxControlWithItems(void *x) {
 
53952
    return (void *)((wxControlWithItems *) (wxListBox *) ((wxCheckListBox *) x));
 
53953
}
 
53954
static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
 
53955
    return (void *)((wxValidator *)  ((wxPyValidator *) x));
 
53956
}
 
53957
static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
 
53958
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
 
53959
static swig_type_info _swigt__p_double = {"_p_double", "double *|wxDouble *", 0, 0, (void*)0, 0};
 
53960
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
 
53961
static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
 
53962
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
 
53963
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
 
53964
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
 
53965
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
 
53966
static swig_type_info _swigt__p_wxAnyButton = {"_p_wxAnyButton", "wxAnyButton *", 0, 0, (void*)0, 0};
 
53967
static swig_type_info _swigt__p_wxArrayInt = {"_p_wxArrayInt", "wxArrayInt *", 0, 0, (void*)0, 0};
 
53968
static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
 
53969
static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
 
53970
static swig_type_info _swigt__p_wxBitmapButton = {"_p_wxBitmapButton", "wxBitmapButton *", 0, 0, (void*)0, 0};
 
53971
static swig_type_info _swigt__p_wxBookCtrlBase = {"_p_wxBookCtrlBase", "wxBookCtrlBase *", 0, 0, (void*)0, 0};
 
53972
static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
 
53973
static swig_type_info _swigt__p_wxCheckBox = {"_p_wxCheckBox", "wxCheckBox *", 0, 0, (void*)0, 0};
 
53974
static swig_type_info _swigt__p_wxCheckListBox = {"_p_wxCheckListBox", "wxCheckListBox *", 0, 0, (void*)0, 0};
 
53975
static swig_type_info _swigt__p_wxChoice = {"_p_wxChoice", "wxChoice *", 0, 0, (void*)0, 0};
 
53976
static swig_type_info _swigt__p_wxChoicebook = {"_p_wxChoicebook", "wxChoicebook *", 0, 0, (void*)0, 0};
 
53977
static swig_type_info _swigt__p_wxCollapsiblePane = {"_p_wxCollapsiblePane", "wxCollapsiblePane *", 0, 0, (void*)0, 0};
 
53978
static swig_type_info _swigt__p_wxCollapsiblePaneEvent = {"_p_wxCollapsiblePaneEvent", "wxCollapsiblePaneEvent *", 0, 0, (void*)0, 0};
 
53979
static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
 
53980
static swig_type_info _swigt__p_wxColourPickerCtrl = {"_p_wxColourPickerCtrl", "wxColourPickerCtrl *", 0, 0, (void*)0, 0};
 
53981
static swig_type_info _swigt__p_wxColourPickerEvent = {"_p_wxColourPickerEvent", "wxColourPickerEvent *", 0, 0, (void*)0, 0};
 
53982
static swig_type_info _swigt__p_wxComboBox = {"_p_wxComboBox", "wxComboBox *", 0, 0, (void*)0, 0};
 
53983
static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
 
53984
static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
 
53985
static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
 
53986
static swig_type_info _swigt__p_wxBookCtrlEvent = {"_p_wxBookCtrlEvent", 0, 0, 0, 0, 0};
 
53987
static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
 
53988
static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
 
53989
static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
 
53990
static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
 
53991
static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
 
53992
static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
 
53993
static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
 
53994
static swig_type_info _swigt__p_wxCommandLinkButton = {"_p_wxCommandLinkButton", "wxCommandLinkButton *", 0, 0, (void*)0, 0};
 
53995
static swig_type_info _swigt__p_wxContextHelp = {"_p_wxContextHelp", "wxContextHelp *", 0, 0, (void*)0, 0};
 
53996
static swig_type_info _swigt__p_wxContextHelpButton = {"_p_wxContextHelpButton", "wxContextHelpButton *", 0, 0, (void*)0, 0};
 
53997
static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
 
53998
static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
 
53999
static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
 
54000
static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
 
54001
static swig_type_info _swigt__p_wxDatePickerCtrl = {"_p_wxDatePickerCtrl", "wxDatePickerCtrl *", 0, 0, (void*)0, 0};
 
54002
static swig_type_info _swigt__p_wxDatePickerCtrlBase = {"_p_wxDatePickerCtrlBase", "wxDatePickerCtrlBase *", 0, 0, (void*)0, 0};
 
54003
static swig_type_info _swigt__p_wxDatePickerCtrlGeneric = {"_p_wxDatePickerCtrlGeneric", "wxDatePickerCtrlGeneric *", 0, 0, (void*)0, 0};
 
54004
static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
 
54005
static swig_type_info _swigt__p_wxDirFilterListCtrl = {"_p_wxDirFilterListCtrl", "wxDirFilterListCtrl *", 0, 0, (void*)0, 0};
 
54006
static swig_type_info _swigt__p_wxDirItemData = {"_p_wxDirItemData", "wxDirItemData *", 0, 0, (void*)0, 0};
 
54007
static swig_type_info _swigt__p_wxDirPickerCtrl = {"_p_wxDirPickerCtrl", "wxDirPickerCtrl *", 0, 0, (void*)0, 0};
 
54008
static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
 
54009
static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
 
54010
static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
 
54011
static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
 
54012
static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
 
54013
static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
 
54014
static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
 
54015
static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
 
54016
static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
 
54017
static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
 
54018
static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
 
54019
static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
 
54020
static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
 
54021
static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
 
54022
static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
 
54023
static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
 
54024
static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
 
54025
static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
 
54026
static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
 
54027
static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
 
54028
static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
 
54029
static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
 
54030
static swig_type_info _swigt__p_wxThreadEvent = {"_p_wxThreadEvent", 0, 0, 0, 0, 0};
 
54031
static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
 
54032
static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
 
54033
static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
 
54034
static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
 
54035
static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
 
54036
static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
 
54037
static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
 
54038
static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
 
54039
static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
 
54040
static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
 
54041
static swig_type_info _swigt__p_wxPyEvtHandler = {"_p_wxPyEvtHandler", 0, 0, 0, 0, 0};
 
54042
static swig_type_info _swigt__p_wxFileCtrl = {"_p_wxFileCtrl", "wxFileCtrl *", 0, 0, (void*)0, 0};
 
54043
static swig_type_info _swigt__p_wxFileCtrlEvent = {"_p_wxFileCtrlEvent", "wxFileCtrlEvent *", 0, 0, (void*)0, 0};
 
54044
static swig_type_info _swigt__p_wxFileDirPickerEvent = {"_p_wxFileDirPickerEvent", "wxFileDirPickerEvent *", 0, 0, (void*)0, 0};
 
54045
static swig_type_info _swigt__p_wxFilePickerCtrl = {"_p_wxFilePickerCtrl", "wxFilePickerCtrl *", 0, 0, (void*)0, 0};
 
54046
static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
 
54047
static swig_type_info _swigt__p_wxFontPickerCtrl = {"_p_wxFontPickerCtrl", "wxFontPickerCtrl *", 0, 0, (void*)0, 0};
 
54048
static swig_type_info _swigt__p_wxFontPickerEvent = {"_p_wxFontPickerEvent", "wxFontPickerEvent *", 0, 0, (void*)0, 0};
 
54049
static swig_type_info _swigt__p_wxGauge = {"_p_wxGauge", "wxGauge *", 0, 0, (void*)0, 0};
 
54050
static swig_type_info _swigt__p_wxGenericDirCtrl = {"_p_wxGenericDirCtrl", "wxGenericDirCtrl *", 0, 0, (void*)0, 0};
 
54051
static swig_type_info _swigt__p_wxGenericDragImage = {"_p_wxGenericDragImage", "wxGenericDragImage *", 0, 0, (void*)0, 0};
 
54052
static swig_type_info _swigt__p_wxHelpEvent = {"_p_wxHelpEvent", "wxHelpEvent *", 0, 0, (void*)0, 0};
 
54053
static swig_type_info _swigt__p_wxHelpProvider = {"_p_wxHelpProvider", "wxHelpProvider *", 0, 0, (void*)0, 0};
 
54054
static swig_type_info _swigt__p_wxHyperlinkCtrl = {"_p_wxHyperlinkCtrl", "wxHyperlinkCtrl *", 0, 0, (void*)0, 0};
 
54055
static swig_type_info _swigt__p_wxHyperlinkEvent = {"_p_wxHyperlinkEvent", "wxHyperlinkEvent *", 0, 0, (void*)0, 0};
 
54056
static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
 
54057
static swig_type_info _swigt__p_wxImageList = {"_p_wxImageList", "wxImageList *", 0, 0, (void*)0, 0};
 
54058
static swig_type_info _swigt__p_wxInfoBar = {"_p_wxInfoBar", "wxInfoBar *", 0, 0, (void*)0, 0};
 
54059
static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
 
54060
static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
 
54061
static swig_type_info _swigt__p_wxListBox = {"_p_wxListBox", "wxListBox *", 0, 0, (void*)0, 0};
 
54062
static swig_type_info _swigt__p_wxListEvent = {"_p_wxListEvent", "wxListEvent *", 0, 0, (void*)0, 0};
 
54063
static swig_type_info _swigt__p_wxListItem = {"_p_wxListItem", "wxListItem *", 0, 0, (void*)0, 0};
 
54064
static swig_type_info _swigt__p_wxListItemAttr = {"_p_wxListItemAttr", "wxListItemAttr *", 0, 0, (void*)0, 0};
 
54065
static swig_type_info _swigt__p_wxListView = {"_p_wxListView", "wxListView *", 0, 0, (void*)0, 0};
 
54066
static swig_type_info _swigt__p_wxListbook = {"_p_wxListbook", "wxListbook *", 0, 0, (void*)0, 0};
 
54067
static swig_type_info _swigt__p_wxMemoryDC = {"_p_wxMemoryDC", "wxMemoryDC *", 0, 0, (void*)0, 0};
 
54068
static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
 
54069
static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
 
54070
static swig_type_info _swigt__p_wxNotebook = {"_p_wxNotebook", "wxNotebook *", 0, 0, (void*)0, 0};
 
54071
static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
 
54072
static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
 
54073
static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
 
54074
static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
 
54075
static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
 
54076
static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
 
54077
static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
 
54078
static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
 
54079
static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
 
54080
static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
 
54081
static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
 
54082
static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
 
54083
static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
 
54084
static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
 
54085
static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
 
54086
static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
 
54087
static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
 
54088
static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
 
54089
static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
 
54090
static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
 
54091
static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
 
54092
static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
 
54093
static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
 
54094
static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
 
54095
static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
 
54096
static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
 
54097
static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
 
54098
static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
 
54099
static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
 
54100
static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
 
54101
static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
 
54102
static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
 
54103
static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
 
54104
static swig_type_info _swigt__p_wxWrapSizer = {"_p_wxWrapSizer", 0, 0, 0, 0, 0};
 
54105
static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
 
54106
static swig_type_info _swigt__p_wxPickerBase = {"_p_wxPickerBase", "wxPickerBase *", 0, 0, (void*)0, 0};
 
54107
static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
 
54108
static swig_type_info _swigt__p_wxPyControl = {"_p_wxPyControl", "wxPyControl *", 0, 0, (void*)0, 0};
 
54109
static swig_type_info _swigt__p_wxPyListCtrl = {"_p_wxPyListCtrl", "wxPyListCtrl *", 0, 0, (void*)0, 0};
 
54110
static swig_type_info _swigt__p_wxPyPickerBase = {"_p_wxPyPickerBase", "wxPyPickerBase *", 0, 0, (void*)0, 0};
 
54111
static swig_type_info _swigt__p_wxPyTreeCtrl = {"_p_wxPyTreeCtrl", "wxPyTreeCtrl *", 0, 0, (void*)0, 0};
 
54112
static swig_type_info _swigt__p_wxPyTreeItemData = {"_p_wxPyTreeItemData", "wxPyTreeItemData *", 0, 0, (void*)0, 0};
 
54113
static swig_type_info _swigt__p_wxRadioBox = {"_p_wxRadioBox", "wxRadioBox *", 0, 0, (void*)0, 0};
 
54114
static swig_type_info _swigt__p_wxRadioButton = {"_p_wxRadioButton", "wxRadioButton *", 0, 0, (void*)0, 0};
 
54115
static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
 
54116
static swig_type_info _swigt__p_wxRefCounter = {"_p_wxRefCounter", "wxRefCounter *|wxObjectRefData *", 0, 0, (void*)0, 0};
 
54117
static swig_type_info _swigt__p_wxScrollBar = {"_p_wxScrollBar", "wxScrollBar *", 0, 0, (void*)0, 0};
 
54118
static swig_type_info _swigt__p_wxSearchCtrl = {"_p_wxSearchCtrl", "wxSearchCtrl *", 0, 0, (void*)0, 0};
 
54119
static swig_type_info _swigt__p_wxSearchCtrlBase = {"_p_wxSearchCtrlBase", "wxSearchCtrlBase *", 0, 0, (void*)0, 0};
 
54120
static swig_type_info _swigt__p_wxSimpleHelpProvider = {"_p_wxSimpleHelpProvider", "wxSimpleHelpProvider *", 0, 0, (void*)0, 0};
 
54121
static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
 
54122
static swig_type_info _swigt__p_wxSlider = {"_p_wxSlider", "wxSlider *", 0, 0, (void*)0, 0};
 
54123
static swig_type_info _swigt__p_wxSpinButton = {"_p_wxSpinButton", "wxSpinButton *", 0, 0, (void*)0, 0};
 
54124
static swig_type_info _swigt__p_wxSpinCtrl = {"_p_wxSpinCtrl", "wxSpinCtrl *", 0, 0, (void*)0, 0};
 
54125
static swig_type_info _swigt__p_wxSpinCtrlDouble = {"_p_wxSpinCtrlDouble", "wxSpinCtrlDouble *", 0, 0, (void*)0, 0};
 
54126
static swig_type_info _swigt__p_wxSpinDoubleEvent = {"_p_wxSpinDoubleEvent", "wxSpinDoubleEvent *", 0, 0, (void*)0, 0};
 
54127
static swig_type_info _swigt__p_wxSpinEvent = {"_p_wxSpinEvent", "wxSpinEvent *", 0, 0, (void*)0, 0};
 
54128
static swig_type_info _swigt__p_wxStaticBitmap = {"_p_wxStaticBitmap", "wxStaticBitmap *", 0, 0, (void*)0, 0};
 
54129
static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
 
54130
static swig_type_info _swigt__p_wxStaticLine = {"_p_wxStaticLine", "wxStaticLine *", 0, 0, (void*)0, 0};
 
54131
static swig_type_info _swigt__p_wxStaticText = {"_p_wxStaticText", "wxStaticText *", 0, 0, (void*)0, 0};
 
54132
static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
 
54133
static swig_type_info _swigt__p_wxTextAreaBase = {"_p_wxTextAreaBase", "wxTextAreaBase *", 0, 0, (void*)0, 0};
 
54134
static swig_type_info _swigt__p_wxTextAttr = {"_p_wxTextAttr", "wxTextAttr *", 0, 0, (void*)0, 0};
 
54135
static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
 
54136
static swig_type_info _swigt__p_wxTextCtrlBase = {"_p_wxTextCtrlBase", "wxTextCtrlBase *", 0, 0, (void*)0, 0};
 
54137
static swig_type_info _swigt__p_wxTextCtrlIface = {"_p_wxTextCtrlIface", "wxTextCtrlIface *", 0, 0, (void*)0, 0};
 
54138
static swig_type_info _swigt__p_wxTextEntry = {"_p_wxTextEntry", "wxTextEntry *", 0, 0, (void*)0, 0};
 
54139
static swig_type_info _swigt__p_wxTextEntryBase = {"_p_wxTextEntryBase", "wxTextEntryBase *", 0, 0, (void*)0, 0};
 
54140
static swig_type_info _swigt__p_wxTextUrlEvent = {"_p_wxTextUrlEvent", "wxTextUrlEvent *", 0, 0, (void*)0, 0};
 
54141
static swig_type_info _swigt__p_wxToggleButton = {"_p_wxToggleButton", "wxToggleButton *", 0, 0, (void*)0, 0};
 
54142
static swig_type_info _swigt__p_wxToolBar = {"_p_wxToolBar", "wxToolBar *", 0, 0, (void*)0, 0};
 
54143
static swig_type_info _swigt__p_wxToolBarBase = {"_p_wxToolBarBase", "wxToolBarBase *", 0, 0, (void*)0, 0};
 
54144
static swig_type_info _swigt__p_wxToolBarToolBase = {"_p_wxToolBarToolBase", "wxToolBarToolBase *", 0, 0, (void*)0, 0};
 
54145
static swig_type_info _swigt__p_wxToolbook = {"_p_wxToolbook", "wxToolbook *", 0, 0, (void*)0, 0};
 
54146
static swig_type_info _swigt__p_wxTreeEvent = {"_p_wxTreeEvent", "wxTreeEvent *", 0, 0, (void*)0, 0};
 
54147
static swig_type_info _swigt__p_wxTreeItemId = {"_p_wxTreeItemId", "wxTreeItemId *", 0, 0, (void*)0, 0};
 
54148
static swig_type_info _swigt__p_wxTreebook = {"_p_wxTreebook", "wxTreebook *", 0, 0, (void*)0, 0};
 
54149
static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
 
54150
static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
 
54151
static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
 
54152
static swig_type_info _swigt__p_wxWindowBase = {"_p_wxWindowBase", "wxWindowBase *", 0, 0, (void*)0, 0};
 
54153
static swig_type_info _swigt__p_wxWithImages = {"_p_wxWithImages", "wxWithImages *", 0, 0, (void*)0, 0};
 
54154
 
 
54155
static swig_type_info *swig_type_initial[] = {
 
54156
  &_swigt__p_bool,
 
54157
  &_swigt__p_char,
 
54158
  &_swigt__p_double,
 
54159
  &_swigt__p_int,
 
54160
  &_swigt__p_long,
 
54161
  &_swigt__p_unsigned_char,
 
54162
  &_swigt__p_unsigned_int,
 
54163
  &_swigt__p_unsigned_long,
 
54164
  &_swigt__p_void,
 
54165
  &_swigt__p_wxANIHandler,
 
54166
  &_swigt__p_wxAcceleratorTable,
 
54167
  &_swigt__p_wxActivateEvent,
 
54168
  &_swigt__p_wxAnyButton,
 
54169
  &_swigt__p_wxArrayInt,
 
54170
  &_swigt__p_wxArrayString,
 
54171
  &_swigt__p_wxBMPHandler,
 
54172
  &_swigt__p_wxBitmap,
 
54173
  &_swigt__p_wxBitmapButton,
 
54174
  &_swigt__p_wxBookCtrlBase,
 
54175
  &_swigt__p_wxBookCtrlEvent,
 
54176
  &_swigt__p_wxBoxSizer,
 
54177
  &_swigt__p_wxButton,
 
54178
  &_swigt__p_wxCURHandler,
 
54179
  &_swigt__p_wxCheckBox,
 
54180
  &_swigt__p_wxCheckListBox,
 
54181
  &_swigt__p_wxChildFocusEvent,
 
54182
  &_swigt__p_wxChoice,
 
54183
  &_swigt__p_wxChoicebook,
 
54184
  &_swigt__p_wxClipboardTextEvent,
 
54185
  &_swigt__p_wxCloseEvent,
 
54186
  &_swigt__p_wxCollapsiblePane,
 
54187
  &_swigt__p_wxCollapsiblePaneEvent,
 
54188
  &_swigt__p_wxColour,
 
54189
  &_swigt__p_wxColourPickerCtrl,
 
54190
  &_swigt__p_wxColourPickerEvent,
 
54191
  &_swigt__p_wxComboBox,
 
54192
  &_swigt__p_wxCommandEvent,
 
54193
  &_swigt__p_wxCommandLinkButton,
 
54194
  &_swigt__p_wxContextHelp,
 
54195
  &_swigt__p_wxContextHelpButton,
 
54196
  &_swigt__p_wxContextMenuEvent,
 
54197
  &_swigt__p_wxControl,
 
54198
  &_swigt__p_wxControlWithItems,
 
54199
  &_swigt__p_wxCursor,
 
54200
  &_swigt__p_wxDC,
 
54201
  &_swigt__p_wxDateEvent,
 
54202
  &_swigt__p_wxDatePickerCtrl,
 
54203
  &_swigt__p_wxDatePickerCtrlBase,
 
54204
  &_swigt__p_wxDatePickerCtrlGeneric,
 
54205
  &_swigt__p_wxDateTime,
 
54206
  &_swigt__p_wxDirFilterListCtrl,
 
54207
  &_swigt__p_wxDirItemData,
 
54208
  &_swigt__p_wxDirPickerCtrl,
 
54209
  &_swigt__p_wxDisplayChangedEvent,
 
54210
  &_swigt__p_wxDropFilesEvent,
 
54211
  &_swigt__p_wxDuplexMode,
 
54212
  &_swigt__p_wxEraseEvent,
 
54213
  &_swigt__p_wxEvent,
 
54214
  &_swigt__p_wxEventBlocker,
 
54215
  &_swigt__p_wxEvtHandler,
 
54216
  &_swigt__p_wxFSFile,
 
54217
  &_swigt__p_wxFileCtrl,
 
54218
  &_swigt__p_wxFileCtrlEvent,
 
54219
  &_swigt__p_wxFileDirPickerEvent,
 
54220
  &_swigt__p_wxFilePickerCtrl,
 
54221
  &_swigt__p_wxFileSystem,
 
54222
  &_swigt__p_wxFlexGridSizer,
 
54223
  &_swigt__p_wxFocusEvent,
 
54224
  &_swigt__p_wxFont,
 
54225
  &_swigt__p_wxFontPickerCtrl,
 
54226
  &_swigt__p_wxFontPickerEvent,
 
54227
  &_swigt__p_wxGBSizerItem,
 
54228
  &_swigt__p_wxGIFHandler,
 
54229
  &_swigt__p_wxGauge,
 
54230
  &_swigt__p_wxGenericDirCtrl,
 
54231
  &_swigt__p_wxGenericDragImage,
 
54232
  &_swigt__p_wxGridBagSizer,
 
54233
  &_swigt__p_wxGridSizer,
 
54234
  &_swigt__p_wxHelpEvent,
 
54235
  &_swigt__p_wxHelpProvider,
 
54236
  &_swigt__p_wxHyperlinkCtrl,
 
54237
  &_swigt__p_wxHyperlinkEvent,
 
54238
  &_swigt__p_wxICOHandler,
 
54239
  &_swigt__p_wxIcon,
 
54240
  &_swigt__p_wxIconizeEvent,
 
54241
  &_swigt__p_wxIdleEvent,
 
54242
  &_swigt__p_wxImage,
 
54243
  &_swigt__p_wxImageHandler,
 
54244
  &_swigt__p_wxImageList,
 
54245
  &_swigt__p_wxIndividualLayoutConstraint,
 
54246
  &_swigt__p_wxInfoBar,
 
54247
  &_swigt__p_wxInitDialogEvent,
 
54248
  &_swigt__p_wxItemContainer,
 
54249
  &_swigt__p_wxJPEGHandler,
 
54250
  &_swigt__p_wxKeyEvent,
 
54251
  &_swigt__p_wxLayoutConstraints,
 
54252
  &_swigt__p_wxListBox,
 
54253
  &_swigt__p_wxListEvent,
 
54254
  &_swigt__p_wxListItem,
 
54255
  &_swigt__p_wxListItemAttr,
 
54256
  &_swigt__p_wxListView,
 
54257
  &_swigt__p_wxListbook,
 
54258
  &_swigt__p_wxMaximizeEvent,
 
54259
  &_swigt__p_wxMemoryDC,
 
54260
  &_swigt__p_wxMenu,
 
54261
  &_swigt__p_wxMenuBar,
 
54262
  &_swigt__p_wxMenuEvent,
 
54263
  &_swigt__p_wxMenuItem,
 
54264
  &_swigt__p_wxMouseCaptureChangedEvent,
 
54265
  &_swigt__p_wxMouseCaptureLostEvent,
 
54266
  &_swigt__p_wxMouseEvent,
 
54267
  &_swigt__p_wxMoveEvent,
 
54268
  &_swigt__p_wxNavigationKeyEvent,
 
54269
  &_swigt__p_wxNcPaintEvent,
 
54270
  &_swigt__p_wxNotebook,
 
54271
  &_swigt__p_wxNotifyEvent,
 
54272
  &_swigt__p_wxObject,
 
54273
  &_swigt__p_wxPCXHandler,
 
54274
  &_swigt__p_wxPNGHandler,
 
54275
  &_swigt__p_wxPNMHandler,
 
54276
  &_swigt__p_wxPaintEvent,
 
54277
  &_swigt__p_wxPaletteChangedEvent,
 
54278
  &_swigt__p_wxPaperSize,
 
54279
  &_swigt__p_wxPickerBase,
 
54280
  &_swigt__p_wxPoint,
 
54281
  &_swigt__p_wxPyApp,
 
54282
  &_swigt__p_wxPyCommandEvent,
 
54283
  &_swigt__p_wxPyControl,
 
54284
  &_swigt__p_wxPyEvent,
 
54285
  &_swigt__p_wxPyEvtHandler,
 
54286
  &_swigt__p_wxPyImageHandler,
 
54287
  &_swigt__p_wxPyListCtrl,
 
54288
  &_swigt__p_wxPyPickerBase,
 
54289
  &_swigt__p_wxPySizer,
 
54290
  &_swigt__p_wxPyTreeCtrl,
 
54291
  &_swigt__p_wxPyTreeItemData,
 
54292
  &_swigt__p_wxPyValidator,
 
54293
  &_swigt__p_wxQueryNewPaletteEvent,
 
54294
  &_swigt__p_wxRadioBox,
 
54295
  &_swigt__p_wxRadioButton,
 
54296
  &_swigt__p_wxRect,
 
54297
  &_swigt__p_wxRefCounter,
 
54298
  &_swigt__p_wxScrollBar,
 
54299
  &_swigt__p_wxScrollEvent,
 
54300
  &_swigt__p_wxScrollWinEvent,
 
54301
  &_swigt__p_wxSearchCtrl,
 
54302
  &_swigt__p_wxSearchCtrlBase,
 
54303
  &_swigt__p_wxSetCursorEvent,
 
54304
  &_swigt__p_wxShowEvent,
 
54305
  &_swigt__p_wxSimpleHelpProvider,
 
54306
  &_swigt__p_wxSize,
 
54307
  &_swigt__p_wxSizeEvent,
 
54308
  &_swigt__p_wxSizer,
 
54309
  &_swigt__p_wxSizerItem,
 
54310
  &_swigt__p_wxSlider,
 
54311
  &_swigt__p_wxSpinButton,
 
54312
  &_swigt__p_wxSpinCtrl,
 
54313
  &_swigt__p_wxSpinCtrlDouble,
 
54314
  &_swigt__p_wxSpinDoubleEvent,
 
54315
  &_swigt__p_wxSpinEvent,
 
54316
  &_swigt__p_wxStaticBitmap,
 
54317
  &_swigt__p_wxStaticBox,
 
54318
  &_swigt__p_wxStaticBoxSizer,
 
54319
  &_swigt__p_wxStaticLine,
 
54320
  &_swigt__p_wxStaticText,
 
54321
  &_swigt__p_wxStdDialogButtonSizer,
 
54322
  &_swigt__p_wxString,
 
54323
  &_swigt__p_wxSysColourChangedEvent,
 
54324
  &_swigt__p_wxTGAHandler,
 
54325
  &_swigt__p_wxTIFFHandler,
 
54326
  &_swigt__p_wxTextAreaBase,
 
54327
  &_swigt__p_wxTextAttr,
 
54328
  &_swigt__p_wxTextCtrl,
 
54329
  &_swigt__p_wxTextCtrlBase,
 
54330
  &_swigt__p_wxTextCtrlIface,
 
54331
  &_swigt__p_wxTextEntry,
 
54332
  &_swigt__p_wxTextEntryBase,
 
54333
  &_swigt__p_wxTextUrlEvent,
 
54334
  &_swigt__p_wxThreadEvent,
 
54335
  &_swigt__p_wxToggleButton,
 
54336
  &_swigt__p_wxToolBar,
 
54337
  &_swigt__p_wxToolBarBase,
 
54338
  &_swigt__p_wxToolBarToolBase,
 
54339
  &_swigt__p_wxToolbook,
 
54340
  &_swigt__p_wxTreeEvent,
 
54341
  &_swigt__p_wxTreeItemId,
 
54342
  &_swigt__p_wxTreebook,
 
54343
  &_swigt__p_wxUpdateUIEvent,
 
54344
  &_swigt__p_wxValidator,
 
54345
  &_swigt__p_wxVisualAttributes,
 
54346
  &_swigt__p_wxWindow,
 
54347
  &_swigt__p_wxWindowBase,
 
54348
  &_swigt__p_wxWindowCreateEvent,
 
54349
  &_swigt__p_wxWindowDestroyEvent,
 
54350
  &_swigt__p_wxWithImages,
 
54351
  &_swigt__p_wxWrapSizer,
 
54352
  &_swigt__p_wxXPMHandler,
 
54353
};
 
54354
 
 
54355
static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
 
54356
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
 
54357
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
 
54358
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
 
54359
static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
 
54360
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
 
54361
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
 
54362
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
 
54363
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
 
54364
static swig_cast_info _swigc__p_wxAnyButton[] = {  {&_swigt__p_wxButton, _p_wxButtonTo_p_wxAnyButton, 0, 0},  {&_swigt__p_wxBitmapButton, _p_wxBitmapButtonTo_p_wxAnyButton, 0, 0},  {&_swigt__p_wxContextHelpButton, _p_wxContextHelpButtonTo_p_wxAnyButton, 0, 0},  {&_swigt__p_wxAnyButton, 0, 0, 0},  {&_swigt__p_wxCommandLinkButton, _p_wxCommandLinkButtonTo_p_wxAnyButton, 0, 0},  {&_swigt__p_wxToggleButton, _p_wxToggleButtonTo_p_wxAnyButton, 0, 0},{0, 0, 0, 0}};
 
54365
static swig_cast_info _swigc__p_wxArrayInt[] = {  {&_swigt__p_wxArrayInt, 0, 0, 0},{0, 0, 0, 0}};
 
54366
static swig_cast_info _swigc__p_wxArrayString[] = {  {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
 
54367
static swig_cast_info _swigc__p_wxBitmap[] = {  {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
 
54368
static swig_cast_info _swigc__p_wxBitmapButton[] = {  {&_swigt__p_wxBitmapButton, 0, 0, 0},  {&_swigt__p_wxContextHelpButton, _p_wxContextHelpButtonTo_p_wxBitmapButton, 0, 0},{0, 0, 0, 0}};
 
54369
static swig_cast_info _swigc__p_wxBookCtrlBase[] = {  {&_swigt__p_wxChoicebook, _p_wxChoicebookTo_p_wxBookCtrlBase, 0, 0},  {&_swigt__p_wxListbook, _p_wxListbookTo_p_wxBookCtrlBase, 0, 0},  {&_swigt__p_wxBookCtrlBase, 0, 0, 0},  {&_swigt__p_wxToolbook, _p_wxToolbookTo_p_wxBookCtrlBase, 0, 0},  {&_swigt__p_wxTreebook, _p_wxTreebookTo_p_wxBookCtrlBase, 0, 0},  {&_swigt__p_wxNotebook, _p_wxNotebookTo_p_wxBookCtrlBase, 0, 0},{0, 0, 0, 0}};
 
54370
static swig_cast_info _swigc__p_wxButton[] = {  {&_swigt__p_wxButton, 0, 0, 0},  {&_swigt__p_wxBitmapButton, _p_wxBitmapButtonTo_p_wxButton, 0, 0},  {&_swigt__p_wxContextHelpButton, _p_wxContextHelpButtonTo_p_wxButton, 0, 0},  {&_swigt__p_wxCommandLinkButton, _p_wxCommandLinkButtonTo_p_wxButton, 0, 0},{0, 0, 0, 0}};
 
54371
static swig_cast_info _swigc__p_wxCheckBox[] = {  {&_swigt__p_wxCheckBox, 0, 0, 0},{0, 0, 0, 0}};
 
54372
static swig_cast_info _swigc__p_wxCheckListBox[] = {  {&_swigt__p_wxCheckListBox, 0, 0, 0},{0, 0, 0, 0}};
 
54373
static swig_cast_info _swigc__p_wxChoice[] = {  {&_swigt__p_wxDirFilterListCtrl, _p_wxDirFilterListCtrlTo_p_wxChoice, 0, 0},  {&_swigt__p_wxChoice, 0, 0, 0},{0, 0, 0, 0}};
 
54374
static swig_cast_info _swigc__p_wxChoicebook[] = {  {&_swigt__p_wxChoicebook, 0, 0, 0},{0, 0, 0, 0}};
 
54375
static swig_cast_info _swigc__p_wxCollapsiblePane[] = {  {&_swigt__p_wxCollapsiblePane, 0, 0, 0},{0, 0, 0, 0}};
 
54376
static swig_cast_info _swigc__p_wxCollapsiblePaneEvent[] = {  {&_swigt__p_wxCollapsiblePaneEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54377
static swig_cast_info _swigc__p_wxColour[] = {  {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
 
54378
static swig_cast_info _swigc__p_wxColourPickerCtrl[] = {  {&_swigt__p_wxColourPickerCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54379
static swig_cast_info _swigc__p_wxColourPickerEvent[] = {  {&_swigt__p_wxColourPickerEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54380
static swig_cast_info _swigc__p_wxComboBox[] = {  {&_swigt__p_wxComboBox, 0, 0, 0},{0, 0, 0, 0}};
 
54381
static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54382
static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54383
static swig_cast_info _swigc__p_wxBookCtrlEvent[] = {{&_swigt__p_wxBookCtrlEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54384
static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54385
static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54386
static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54387
static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54388
static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54389
static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54390
static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54391
static swig_cast_info _swigc__p_wxCommandEvent[] = {  {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxHyperlinkEvent, _p_wxHyperlinkEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxColourPickerEvent, _p_wxColourPickerEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxFileDirPickerEvent, _p_wxFileDirPickerEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxFontPickerEvent, _p_wxFontPickerEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxTextUrlEvent, _p_wxTextUrlEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxBookCtrlEvent, _p_wxBookCtrlEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxFileCtrlEvent, _p_wxFileCtrlEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_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_wxSpinDoubleEvent, _p_wxSpinDoubleEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxListEvent, _p_wxListEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxCollapsiblePaneEvent, _p_wxCollapsiblePaneEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxTreeEvent, _p_wxTreeEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxSpinEvent, _p_wxSpinEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxHelpEvent, _p_wxHelpEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0},  {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
 
54392
static swig_cast_info _swigc__p_wxCommandLinkButton[] = {  {&_swigt__p_wxCommandLinkButton, 0, 0, 0},{0, 0, 0, 0}};
 
54393
static swig_cast_info _swigc__p_wxContextHelp[] = {  {&_swigt__p_wxContextHelp, 0, 0, 0},{0, 0, 0, 0}};
 
54394
static swig_cast_info _swigc__p_wxContextHelpButton[] = {  {&_swigt__p_wxContextHelpButton, 0, 0, 0},{0, 0, 0, 0}};
 
54395
static swig_cast_info _swigc__p_wxControl[] = {  {&_swigt__p_wxCollapsiblePane, _p_wxCollapsiblePaneTo_p_wxControl, 0, 0},  {&_swigt__p_wxDatePickerCtrlGeneric, _p_wxDatePickerCtrlGenericTo_p_wxControl, 0, 0},  {&_swigt__p_wxTextCtrlBase, _p_wxTextCtrlBaseTo_p_wxControl, 0, 0},  {&_swigt__p_wxBookCtrlBase, _p_wxBookCtrlBaseTo_p_wxControl, 0, 0},  {&_swigt__p_wxDatePickerCtrlBase, _p_wxDatePickerCtrlBaseTo_p_wxControl, 0, 0},  {&_swigt__p_wxSearchCtrlBase, _p_wxSearchCtrlBaseTo_p_wxControl, 0, 0},  {&_swigt__p_wxInfoBar, _p_wxInfoBarTo_p_wxControl, 0, 0},  {&_swigt__p_wxToolBar, _p_wxToolBarTo_p_wxControl, 0, 0},  {&_swigt__p_wxPyPickerBase, _p_wxPyPickerBaseTo_p_wxControl, 0, 0},  {&_swigt__p_wxPickerBase, _p_wxPickerBaseTo_p_wxControl, 0, 0},  {&_swigt__p_wxAnyButton, _p_wxAnyButtonTo_p_wxControl, 0, 0},  {&_swigt__p_wxRadioButton, _p_wxRadioButtonTo_p_wxControl, 0, 0},  {&_swigt__p_wxToggleButton, _p_wxToggleButtonTo_p_wxControl, 0, 0},  {&_swigt__p_wxCommandLinkButton, _p_wxCommandLinkButtonTo_p_wxControl, 0, 0},  {&_swigt__p_wxSearchCtrl, _p_wxSearchCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxToolbook, _p_wxToolbookTo_p_wxControl, 0, 0},  {&_swigt__p_wxSpinCtrlDouble, _p_wxSpinCtrlDoubleTo_p_wxControl, 0, 0},  {&_swigt__p_wxPyControl, _p_wxPyControlTo_p_wxControl, 0, 0},  {&_swigt__p_wxControl, 0, 0, 0},  {&_swigt__p_wxToolBarBase, _p_wxToolBarBaseTo_p_wxControl, 0, 0},  {&_swigt__p_wxDirFilterListCtrl, _p_wxDirFilterListCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxPyListCtrl, _p_wxPyListCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxComboBox, _p_wxComboBoxTo_p_wxControl, 0, 0},  {&_swigt__p_wxGenericDirCtrl, _p_wxGenericDirCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxScrollBar, _p_wxScrollBarTo_p_wxControl, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxControl, 0, 0},  {&_swigt__p_wxGauge, _p_wxGaugeTo_p_wxControl, 0, 0},  {&_swigt__p_wxChoicebook, _p_wxChoicebookTo_p_wxControl, 0, 0},  {&_swigt__p_wxStaticLine, _p_wxStaticLineTo_p_wxControl, 0, 0},  {&_swigt__p_wxListbook, _p_wxListbookTo_p_wxControl, 0, 0},  {&_swigt__p_wxHyperlinkCtrl, _p_wxHyperlinkCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxPyTreeCtrl, _p_wxPyTreeCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxCheckBox, _p_wxCheckBoxTo_p_wxControl, 0, 0},  {&_swigt__p_wxRadioBox, _p_wxRadioBoxTo_p_wxControl, 0, 0},  {&_swigt__p_wxChoice, _p_wxChoiceTo_p_wxControl, 0, 0},  {&_swigt__p_wxListBox, _p_wxListBoxTo_p_wxControl, 0, 0},  {&_swigt__p_wxCheckListBox, _p_wxCheckListBoxTo_p_wxControl, 0, 0},  {&_swigt__p_wxNotebook, _p_wxNotebookTo_p_wxControl, 0, 0},  {&_swigt__p_wxListView, _p_wxListViewTo_p_wxControl, 0, 0},  {&_swigt__p_wxStaticBitmap, _p_wxStaticBitmapTo_p_wxControl, 0, 0},  {&_swigt__p_wxSpinCtrl, _p_wxSpinCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxStaticText, _p_wxStaticTextTo_p_wxControl, 0, 0},  {&_swigt__p_wxStaticBox, _p_wxStaticBoxTo_p_wxControl, 0, 0},  {&_swigt__p_wxSlider, _p_wxSliderTo_p_wxControl, 0, 0},  {&_swigt__p_wxTreebook, _p_wxTreebookTo_p_wxControl, 0, 0},  {&_swigt__p_wxContextHelpButton, _p_wxContextHelpButtonTo_p_wxControl, 0, 0},  {&_swigt__p_wxBitmapButton, _p_wxBitmapButtonTo_p_wxControl, 0, 0},  {&_swigt__p_wxButton, _p_wxButtonTo_p_wxControl, 0, 0},  {&_swigt__p_wxSpinButton, _p_wxSpinButtonTo_p_wxControl, 0, 0},  {&_swigt__p_wxFontPickerCtrl, _p_wxFontPickerCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxDirPickerCtrl, _p_wxDirPickerCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxFilePickerCtrl, _p_wxFilePickerCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxColourPickerCtrl, _p_wxColourPickerCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxDatePickerCtrl, _p_wxDatePickerCtrlTo_p_wxControl, 0, 0},  {&_swigt__p_wxTextCtrl, _p_wxTextCtrlTo_p_wxControl, 0, 0},{0, 0, 0, 0}};
 
54396
static swig_cast_info _swigc__p_wxControlWithItems[] = {  {&_swigt__p_wxDirFilterListCtrl, _p_wxDirFilterListCtrlTo_p_wxControlWithItems, 0, 0},  {&_swigt__p_wxChoice, _p_wxChoiceTo_p_wxControlWithItems, 0, 0},  {&_swigt__p_wxControlWithItems, 0, 0, 0},  {&_swigt__p_wxListBox, _p_wxListBoxTo_p_wxControlWithItems, 0, 0},  {&_swigt__p_wxCheckListBox, _p_wxCheckListBoxTo_p_wxControlWithItems, 0, 0},{0, 0, 0, 0}};
 
54397
static swig_cast_info _swigc__p_wxCursor[] = {  {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
 
54398
static swig_cast_info _swigc__p_wxDC[] = {  {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
 
54399
static swig_cast_info _swigc__p_wxDatePickerCtrl[] = {  {&_swigt__p_wxDatePickerCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54400
static swig_cast_info _swigc__p_wxDatePickerCtrlBase[] = {  {&_swigt__p_wxDatePickerCtrlBase, 0, 0, 0},  {&_swigt__p_wxDatePickerCtrlGeneric, _p_wxDatePickerCtrlGenericTo_p_wxDatePickerCtrlBase, 0, 0},  {&_swigt__p_wxDatePickerCtrl, _p_wxDatePickerCtrlTo_p_wxDatePickerCtrlBase, 0, 0},{0, 0, 0, 0}};
 
54401
static swig_cast_info _swigc__p_wxDatePickerCtrlGeneric[] = {  {&_swigt__p_wxDatePickerCtrlGeneric, 0, 0, 0},{0, 0, 0, 0}};
 
54402
static swig_cast_info _swigc__p_wxDateTime[] = {  {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
 
54403
static swig_cast_info _swigc__p_wxDirFilterListCtrl[] = {  {&_swigt__p_wxDirFilterListCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54404
static swig_cast_info _swigc__p_wxDirItemData[] = {  {&_swigt__p_wxDirItemData, 0, 0, 0},{0, 0, 0, 0}};
 
54405
static swig_cast_info _swigc__p_wxDirPickerCtrl[] = {  {&_swigt__p_wxDirPickerCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54406
static swig_cast_info _swigc__p_wxDuplexMode[] = {  {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
 
54407
static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54408
static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54409
static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54410
static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54411
static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54412
static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54413
static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54414
static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54415
static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54416
static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54417
static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54418
static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54419
static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54420
static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54421
static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54422
static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54423
static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54424
static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54425
static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54426
static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54427
static swig_cast_info _swigc__p_wxThreadEvent[] = {{&_swigt__p_wxThreadEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54428
static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54429
static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54430
static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54431
static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54432
static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54433
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_wxTreeEvent, _p_wxTreeEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxColourPickerEvent, _p_wxColourPickerEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxFileDirPickerEvent, _p_wxFileDirPickerEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxFontPickerEvent, _p_wxFontPickerEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxBookCtrlEvent, _p_wxBookCtrlEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxFileCtrlEvent, _p_wxFileCtrlEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxTextUrlEvent, _p_wxTextUrlEventTo_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_wxListEvent, _p_wxListEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxHelpEvent, _p_wxHelpEventTo_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_wxCollapsiblePaneEvent, _p_wxCollapsiblePaneEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxSpinDoubleEvent, _p_wxSpinDoubleEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_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_wxThreadEvent, _p_wxThreadEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxHyperlinkEvent, _p_wxHyperlinkEventTo_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_wxShowEvent, _p_wxShowEventTo_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_wxSpinEvent, _p_wxSpinEventTo_p_wxEvent, 0, 0},  {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
 
54434
static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
 
54435
static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
 
54436
static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
 
54437
static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
 
54438
static swig_cast_info _swigc__p_wxPyEvtHandler[] = {{&_swigt__p_wxPyEvtHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54439
static swig_cast_info _swigc__p_wxEvtHandler[] = {  {&_swigt__p_wxCollapsiblePane, _p_wxCollapsiblePaneTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxDatePickerCtrlGeneric, _p_wxDatePickerCtrlGenericTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSearchCtrlBase, _p_wxSearchCtrlBaseTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxTextCtrlBase, _p_wxTextCtrlBaseTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxBookCtrlBase, _p_wxBookCtrlBaseTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxDatePickerCtrlBase, _p_wxDatePickerCtrlBaseTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxInfoBar, _p_wxInfoBarTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxFileCtrl, _p_wxFileCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxToolBar, _p_wxToolBarTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPickerBase, _p_wxPickerBaseTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyPickerBase, _p_wxPyPickerBaseTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxToggleButton, _p_wxToggleButtonTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxAnyButton, _p_wxAnyButtonTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxCommandLinkButton, _p_wxCommandLinkButtonTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxRadioButton, _p_wxRadioButtonTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSearchCtrl, _p_wxSearchCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxToolbook, _p_wxToolbookTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSpinCtrlDouble, _p_wxSpinCtrlDoubleTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyControl, _p_wxPyControlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxToolBarBase, _p_wxToolBarBaseTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxDirFilterListCtrl, _p_wxDirFilterListCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyListCtrl, _p_wxPyListCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxComboBox, _p_wxComboBoxTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxGenericDirCtrl, _p_wxGenericDirCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxScrollBar, _p_wxScrollBarTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxGauge, _p_wxGaugeTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxChoicebook, _p_wxChoicebookTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxEvtHandler, 0, 0, 0},  {&_swigt__p_wxStaticLine, _p_wxStaticLineTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyEvtHandler, _p_wxPyEvtHandlerTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxListbook, _p_wxListbookTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxHyperlinkCtrl, _p_wxHyperlinkCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyTreeCtrl, _p_wxPyTreeCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxCheckBox, _p_wxCheckBoxTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxRadioBox, _p_wxRadioBoxTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxChoice, _p_wxChoiceTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxListBox, _p_wxListBoxTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxCheckListBox, _p_wxCheckListBoxTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxNotebook, _p_wxNotebookTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxListView, _p_wxListViewTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxStaticBitmap, _p_wxStaticBitmapTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSpinCtrl, _p_wxSpinCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxStaticText, _p_wxStaticTextTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxStaticBox, _p_wxStaticBoxTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSlider, _p_wxSliderTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxTreebook, _p_wxTreebookTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxContextHelpButton, _p_wxContextHelpButtonTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxBitmapButton, _p_wxBitmapButtonTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxButton, _p_wxButtonTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxSpinButton, _p_wxSpinButtonTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxFontPickerCtrl, _p_wxFontPickerCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxDirPickerCtrl, _p_wxDirPickerCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxFilePickerCtrl, _p_wxFilePickerCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxColourPickerCtrl, _p_wxColourPickerCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxDatePickerCtrl, _p_wxDatePickerCtrlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxTextCtrl, _p_wxTextCtrlTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
 
54440
static swig_cast_info _swigc__p_wxFileCtrl[] = {  {&_swigt__p_wxFileCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54441
static swig_cast_info _swigc__p_wxFileCtrlEvent[] = {  {&_swigt__p_wxFileCtrlEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54442
static swig_cast_info _swigc__p_wxFileDirPickerEvent[] = {  {&_swigt__p_wxFileDirPickerEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54443
static swig_cast_info _swigc__p_wxFilePickerCtrl[] = {  {&_swigt__p_wxFilePickerCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54444
static swig_cast_info _swigc__p_wxFont[] = {  {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
 
54445
static swig_cast_info _swigc__p_wxFontPickerCtrl[] = {  {&_swigt__p_wxFontPickerCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54446
static swig_cast_info _swigc__p_wxFontPickerEvent[] = {  {&_swigt__p_wxFontPickerEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54447
static swig_cast_info _swigc__p_wxGauge[] = {  {&_swigt__p_wxGauge, 0, 0, 0},{0, 0, 0, 0}};
 
54448
static swig_cast_info _swigc__p_wxGenericDirCtrl[] = {  {&_swigt__p_wxGenericDirCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54449
static swig_cast_info _swigc__p_wxGenericDragImage[] = {  {&_swigt__p_wxGenericDragImage, 0, 0, 0},{0, 0, 0, 0}};
 
54450
static swig_cast_info _swigc__p_wxHelpEvent[] = {  {&_swigt__p_wxHelpEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54451
static swig_cast_info _swigc__p_wxHelpProvider[] = {  {&_swigt__p_wxHelpProvider, 0, 0, 0},  {&_swigt__p_wxSimpleHelpProvider, _p_wxSimpleHelpProviderTo_p_wxHelpProvider, 0, 0},{0, 0, 0, 0}};
 
54452
static swig_cast_info _swigc__p_wxHyperlinkCtrl[] = {  {&_swigt__p_wxHyperlinkCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54453
static swig_cast_info _swigc__p_wxHyperlinkEvent[] = {  {&_swigt__p_wxHyperlinkEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54454
static swig_cast_info _swigc__p_wxIcon[] = {  {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
 
54455
static swig_cast_info _swigc__p_wxImageList[] = {  {&_swigt__p_wxImageList, 0, 0, 0},{0, 0, 0, 0}};
 
54456
static swig_cast_info _swigc__p_wxInfoBar[] = {  {&_swigt__p_wxInfoBar, 0, 0, 0},{0, 0, 0, 0}};
 
54457
static swig_cast_info _swigc__p_wxItemContainer[] = {  {&_swigt__p_wxComboBox, _p_wxComboBoxTo_p_wxItemContainer, 0, 0},  {&_swigt__p_wxDirFilterListCtrl, _p_wxDirFilterListCtrlTo_p_wxItemContainer, 0, 0},  {&_swigt__p_wxChoice, _p_wxChoiceTo_p_wxItemContainer, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxItemContainer, 0, 0},  {&_swigt__p_wxListBox, _p_wxListBoxTo_p_wxItemContainer, 0, 0},  {&_swigt__p_wxCheckListBox, _p_wxCheckListBoxTo_p_wxItemContainer, 0, 0},  {&_swigt__p_wxItemContainer, 0, 0, 0},{0, 0, 0, 0}};
 
54458
static swig_cast_info _swigc__p_wxKeyEvent[] = {  {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54459
static swig_cast_info _swigc__p_wxListBox[] = {  {&_swigt__p_wxListBox, 0, 0, 0},  {&_swigt__p_wxCheckListBox, _p_wxCheckListBoxTo_p_wxListBox, 0, 0},{0, 0, 0, 0}};
 
54460
static swig_cast_info _swigc__p_wxListEvent[] = {  {&_swigt__p_wxListEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54461
static swig_cast_info _swigc__p_wxListItem[] = {  {&_swigt__p_wxListItem, 0, 0, 0},{0, 0, 0, 0}};
 
54462
static swig_cast_info _swigc__p_wxListItemAttr[] = {  {&_swigt__p_wxListItemAttr, 0, 0, 0},{0, 0, 0, 0}};
 
54463
static swig_cast_info _swigc__p_wxListView[] = {  {&_swigt__p_wxListView, 0, 0, 0},{0, 0, 0, 0}};
 
54464
static swig_cast_info _swigc__p_wxListbook[] = {  {&_swigt__p_wxListbook, 0, 0, 0},{0, 0, 0, 0}};
 
54465
static swig_cast_info _swigc__p_wxMemoryDC[] = {  {&_swigt__p_wxMemoryDC, 0, 0, 0},{0, 0, 0, 0}};
 
54466
static swig_cast_info _swigc__p_wxMenu[] = {  {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
 
54467
static swig_cast_info _swigc__p_wxMouseEvent[] = {  {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54468
static swig_cast_info _swigc__p_wxNotebook[] = {  {&_swigt__p_wxNotebook, 0, 0, 0},{0, 0, 0, 0}};
 
54469
static swig_cast_info _swigc__p_wxNotifyEvent[] = {  {&_swigt__p_wxTreeEvent, _p_wxTreeEventTo_p_wxNotifyEvent, 0, 0},  {&_swigt__p_wxBookCtrlEvent, _p_wxBookCtrlEventTo_p_wxNotifyEvent, 0, 0},  {&_swigt__p_wxSpinDoubleEvent, _p_wxSpinDoubleEventTo_p_wxNotifyEvent, 0, 0},  {&_swigt__p_wxListEvent, _p_wxListEventTo_p_wxNotifyEvent, 0, 0},  {&_swigt__p_wxSpinEvent, _p_wxSpinEventTo_p_wxNotifyEvent, 0, 0},  {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54470
static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
 
54471
static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
 
54472
static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
 
54473
static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
 
54474
static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
 
54475
static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
 
54476
static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
 
54477
static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
 
54478
static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
 
54479
static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
 
54480
static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
 
54481
static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
 
54482
static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
 
54483
static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54484
static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54485
static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54486
static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54487
static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54488
static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54489
static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54490
static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54491
static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54492
static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54493
static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54494
static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54495
static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54496
static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
 
54497
static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
 
54498
static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
 
54499
static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
 
54500
static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
 
54501
static swig_cast_info _swigc__p_wxWrapSizer[] = {{&_swigt__p_wxWrapSizer, 0, 0, 0},{0, 0, 0, 0}};
 
54502
static swig_cast_info _swigc__p_wxObject[] = {  {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0},  {&_swigt__p_wxToolbook, _p_wxToolbookTo_p_wxObject, 0, 0},  {&_swigt__p_wxInfoBar, _p_wxInfoBarTo_p_wxObject, 0, 0},  {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0},  {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0},  {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0},  {&_swigt__p_wxBookCtrlEvent, _p_wxBookCtrlEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxTextUrlEvent, _p_wxTextUrlEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxFileCtrlEvent, _p_wxFileCtrlEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0},  {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxCheckBox, _p_wxCheckBoxTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyTreeCtrl, _p_wxPyTreeCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0},  {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxSearchCtrl, _p_wxSearchCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxGenericDirCtrl, _p_wxGenericDirCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyPickerBase, _p_wxPyPickerBaseTo_p_wxObject, 0, 0},  {&_swigt__p_wxPickerBase, _p_wxPickerBaseTo_p_wxObject, 0, 0},  {&_swigt__p_wxDirItemData, _p_wxDirItemDataTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyListCtrl, _p_wxPyListCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxDirFilterListCtrl, _p_wxDirFilterListCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxThreadEvent, _p_wxThreadEventTo_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_wxStaticLine, _p_wxStaticLineTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyControl, _p_wxPyControlTo_p_wxObject, 0, 0},  {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0},  {&_swigt__p_wxCommandLinkButton, _p_wxCommandLinkButtonTo_p_wxObject, 0, 0},  {&_swigt__p_wxToggleButton, _p_wxToggleButtonTo_p_wxObject, 0, 0},  {&_swigt__p_wxRadioButton, _p_wxRadioButtonTo_p_wxObject, 0, 0},  {&_swigt__p_wxAnyButton, _p_wxAnyButtonTo_p_wxObject, 0, 0},  {&_swigt__p_wxToolBarBase, _p_wxToolBarBaseTo_p_wxObject, 0, 0},  {&_swigt__p_wxGauge, _p_wxGaugeTo_p_wxObject, 0, 0},  {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxColourPickerEvent, _p_wxColourPickerEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxFileDirPickerEvent, _p_wxFileDirPickerEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxFontPickerEvent, _p_wxFontPickerEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxChoice, _p_wxChoiceTo_p_wxObject, 0, 0},  {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0},  {&_swigt__p_wxSpinCtrlDouble, _p_wxSpinCtrlDoubleTo_p_wxObject, 0, 0},  {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxListView, _p_wxListViewTo_p_wxObject, 0, 0},  {&_swigt__p_wxTreebook, _p_wxTreebookTo_p_wxObject, 0, 0},  {&_swigt__p_wxHyperlinkEvent, _p_wxHyperlinkEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxTextCtrl, _p_wxTextCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxNotebook, _p_wxNotebookTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxChoicebook, _p_wxChoicebookTo_p_wxObject, 0, 0},  {&_swigt__p_wxDatePickerCtrlGeneric, _p_wxDatePickerCtrlGenericTo_p_wxObject, 0, 0},  {&_swigt__p_wxListbook, _p_wxListbookTo_p_wxObject, 0, 0},  {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxStaticBitmap, _p_wxStaticBitmapTo_p_wxObject, 0, 0},  {&_swigt__p_wxSlider, _p_wxSliderTo_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_wxCollapsiblePaneEvent, _p_wxCollapsiblePaneEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxSpinDoubleEvent, _p_wxSpinDoubleEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxStaticBox, _p_wxStaticBoxTo_p_wxObject, 0, 0},  {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0},  {&_swigt__p_wxContextHelp, _p_wxContextHelpTo_p_wxObject, 0, 0},  {&_swigt__p_wxTextCtrlBase, _p_wxTextCtrlBaseTo_p_wxObject, 0, 0},  {&_swigt__p_wxBookCtrlBase, _p_wxBookCtrlBaseTo_p_wxObject, 0, 0},  {&_swigt__p_wxDatePickerCtrlBase, _p_wxDatePickerCtrlBaseTo_p_wxObject, 0, 0},  {&_swigt__p_wxSearchCtrlBase, _p_wxSearchCtrlBaseTo_p_wxObject, 0, 0},  {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxListEvent, _p_wxListEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyEvtHandler, _p_wxPyEvtHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxListBox, _p_wxListBoxTo_p_wxObject, 0, 0},  {&_swigt__p_wxCheckListBox, _p_wxCheckListBoxTo_p_wxObject, 0, 0},  {&_swigt__p_wxButton, _p_wxButtonTo_p_wxObject, 0, 0},  {&_swigt__p_wxBitmapButton, _p_wxBitmapButtonTo_p_wxObject, 0, 0},  {&_swigt__p_wxContextHelpButton, _p_wxContextHelpButtonTo_p_wxObject, 0, 0},  {&_swigt__p_wxSpinButton, _p_wxSpinButtonTo_p_wxObject, 0, 0},  {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0},  {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxScrollBar, _p_wxScrollBarTo_p_wxObject, 0, 0},  {&_swigt__p_wxRadioBox, _p_wxRadioBoxTo_p_wxObject, 0, 0},  {&_swigt__p_wxHelpEvent, _p_wxHelpEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxComboBox, _p_wxComboBoxTo_p_wxObject, 0, 0},  {&_swigt__p_wxListItem, _p_wxListItemTo_p_wxObject, 0, 0},  {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0},  {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxSpinEvent, _p_wxSpinEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxGenericDragImage, _p_wxGenericDragImageTo_p_wxObject, 0, 0},  {&_swigt__p_wxSpinCtrl, _p_wxSpinCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxObject, 0, 0, 0},  {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0},  {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxCollapsiblePane, _p_wxCollapsiblePaneTo_p_wxObject, 0, 0},  {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0},  {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_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_wxTreeEvent, _p_wxTreeEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxStaticText, _p_wxStaticTextTo_p_wxObject, 0, 0},  {&_swigt__p_wxWrapSizer, _p_wxWrapSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxColourPickerCtrl, _p_wxColourPickerCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxFilePickerCtrl, _p_wxFilePickerCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxDirPickerCtrl, _p_wxDirPickerCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxFontPickerCtrl, _p_wxFontPickerCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxDatePickerCtrl, _p_wxDatePickerCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0},  {&_swigt__p_wxHyperlinkCtrl, _p_wxHyperlinkCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxToolBarToolBase, _p_wxToolBarToolBaseTo_p_wxObject, 0, 0},  {&_swigt__p_wxToolBar, _p_wxToolBarTo_p_wxObject, 0, 0},  {&_swigt__p_wxFileCtrl, _p_wxFileCtrlTo_p_wxObject, 0, 0},  {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
 
54503
static swig_cast_info _swigc__p_wxPaperSize[] = {  {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
 
54504
static swig_cast_info _swigc__p_wxPickerBase[] = {  {&_swigt__p_wxPickerBase, 0, 0, 0},  {&_swigt__p_wxPyPickerBase, _p_wxPyPickerBaseTo_p_wxPickerBase, 0, 0},  {&_swigt__p_wxColourPickerCtrl, _p_wxColourPickerCtrlTo_p_wxPickerBase, 0, 0},  {&_swigt__p_wxFilePickerCtrl, _p_wxFilePickerCtrlTo_p_wxPickerBase, 0, 0},  {&_swigt__p_wxDirPickerCtrl, _p_wxDirPickerCtrlTo_p_wxPickerBase, 0, 0},  {&_swigt__p_wxFontPickerCtrl, _p_wxFontPickerCtrlTo_p_wxPickerBase, 0, 0},{0, 0, 0, 0}};
 
54505
static swig_cast_info _swigc__p_wxPoint[] = {  {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
 
54506
static swig_cast_info _swigc__p_wxPyControl[] = {  {&_swigt__p_wxPyControl, 0, 0, 0},{0, 0, 0, 0}};
 
54507
static swig_cast_info _swigc__p_wxPyListCtrl[] = {  {&_swigt__p_wxPyListCtrl, 0, 0, 0},  {&_swigt__p_wxListView, _p_wxListViewTo_p_wxPyListCtrl, 0, 0},{0, 0, 0, 0}};
 
54508
static swig_cast_info _swigc__p_wxPyPickerBase[] = {  {&_swigt__p_wxPyPickerBase, 0, 0, 0},{0, 0, 0, 0}};
 
54509
static swig_cast_info _swigc__p_wxPyTreeCtrl[] = {  {&_swigt__p_wxPyTreeCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54510
static swig_cast_info _swigc__p_wxPyTreeItemData[] = {  {&_swigt__p_wxPyTreeItemData, 0, 0, 0},{0, 0, 0, 0}};
 
54511
static swig_cast_info _swigc__p_wxRadioBox[] = {  {&_swigt__p_wxRadioBox, 0, 0, 0},{0, 0, 0, 0}};
 
54512
static swig_cast_info _swigc__p_wxRadioButton[] = {  {&_swigt__p_wxRadioButton, 0, 0, 0},{0, 0, 0, 0}};
 
54513
static swig_cast_info _swigc__p_wxRect[] = {  {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
 
54514
static swig_cast_info _swigc__p_wxRefCounter[] = {  {&_swigt__p_wxRefCounter, 0, 0, 0},{0, 0, 0, 0}};
 
54515
static swig_cast_info _swigc__p_wxScrollBar[] = {  {&_swigt__p_wxScrollBar, 0, 0, 0},{0, 0, 0, 0}};
 
54516
static swig_cast_info _swigc__p_wxSearchCtrl[] = {  {&_swigt__p_wxSearchCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54517
static swig_cast_info _swigc__p_wxSearchCtrlBase[] = {  {&_swigt__p_wxSearchCtrlBase, 0, 0, 0},  {&_swigt__p_wxSearchCtrl, _p_wxSearchCtrlTo_p_wxSearchCtrlBase, 0, 0},{0, 0, 0, 0}};
 
54518
static swig_cast_info _swigc__p_wxSimpleHelpProvider[] = {  {&_swigt__p_wxSimpleHelpProvider, 0, 0, 0},{0, 0, 0, 0}};
 
54519
static swig_cast_info _swigc__p_wxSize[] = {  {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
 
54520
static swig_cast_info _swigc__p_wxSlider[] = {  {&_swigt__p_wxSlider, 0, 0, 0},{0, 0, 0, 0}};
 
54521
static swig_cast_info _swigc__p_wxSpinButton[] = {  {&_swigt__p_wxSpinButton, 0, 0, 0},{0, 0, 0, 0}};
 
54522
static swig_cast_info _swigc__p_wxSpinCtrl[] = {  {&_swigt__p_wxSpinCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54523
static swig_cast_info _swigc__p_wxSpinCtrlDouble[] = {  {&_swigt__p_wxSpinCtrlDouble, 0, 0, 0},{0, 0, 0, 0}};
 
54524
static swig_cast_info _swigc__p_wxSpinDoubleEvent[] = {  {&_swigt__p_wxSpinDoubleEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54525
static swig_cast_info _swigc__p_wxSpinEvent[] = {  {&_swigt__p_wxSpinEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54526
static swig_cast_info _swigc__p_wxStaticBitmap[] = {  {&_swigt__p_wxStaticBitmap, 0, 0, 0},{0, 0, 0, 0}};
 
54527
static swig_cast_info _swigc__p_wxStaticBox[] = {  {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
 
54528
static swig_cast_info _swigc__p_wxStaticLine[] = {  {&_swigt__p_wxStaticLine, 0, 0, 0},{0, 0, 0, 0}};
 
54529
static swig_cast_info _swigc__p_wxStaticText[] = {  {&_swigt__p_wxStaticText, 0, 0, 0},{0, 0, 0, 0}};
 
54530
static swig_cast_info _swigc__p_wxString[] = {  {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
 
54531
static swig_cast_info _swigc__p_wxTextAreaBase[] = {  {&_swigt__p_wxTextAreaBase, 0, 0, 0},  {&_swigt__p_wxTextCtrlBase, _p_wxTextCtrlBaseTo_p_wxTextAreaBase, 0, 0},  {&_swigt__p_wxSearchCtrlBase, _p_wxSearchCtrlBaseTo_p_wxTextAreaBase, 0, 0},  {&_swigt__p_wxTextCtrl, _p_wxTextCtrlTo_p_wxTextAreaBase, 0, 0},  {&_swigt__p_wxTextCtrlIface, _p_wxTextCtrlIfaceTo_p_wxTextAreaBase, 0, 0},  {&_swigt__p_wxSearchCtrl, _p_wxSearchCtrlTo_p_wxTextAreaBase, 0, 0},{0, 0, 0, 0}};
 
54532
static swig_cast_info _swigc__p_wxTextAttr[] = {  {&_swigt__p_wxTextAttr, 0, 0, 0},{0, 0, 0, 0}};
 
54533
static swig_cast_info _swigc__p_wxTextCtrl[] = {  {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
 
54534
static swig_cast_info _swigc__p_wxTextCtrlBase[] = {  {&_swigt__p_wxTextCtrlBase, 0, 0, 0},  {&_swigt__p_wxTextCtrl, _p_wxTextCtrlTo_p_wxTextCtrlBase, 0, 0},{0, 0, 0, 0}};
 
54535
static swig_cast_info _swigc__p_wxTextCtrlIface[] = {  {&_swigt__p_wxSearchCtrlBase, _p_wxSearchCtrlBaseTo_p_wxTextCtrlIface, 0, 0},  {&_swigt__p_wxTextCtrlIface, 0, 0, 0},  {&_swigt__p_wxSearchCtrl, _p_wxSearchCtrlTo_p_wxTextCtrlIface, 0, 0},{0, 0, 0, 0}};
 
54536
static swig_cast_info _swigc__p_wxTextEntry[] = {  {&_swigt__p_wxComboBox, _p_wxComboBoxTo_p_wxTextEntry, 0, 0},  {&_swigt__p_wxTextCtrlBase, _p_wxTextCtrlBaseTo_p_wxTextEntry, 0, 0},  {&_swigt__p_wxTextCtrl, _p_wxTextCtrlTo_p_wxTextEntry, 0, 0},  {&_swigt__p_wxTextEntry, 0, 0, 0},{0, 0, 0, 0}};
 
54537
static swig_cast_info _swigc__p_wxTextEntryBase[] = {  {&_swigt__p_wxComboBox, _p_wxComboBoxTo_p_wxTextEntryBase, 0, 0},  {&_swigt__p_wxTextCtrlBase, _p_wxTextCtrlBaseTo_p_wxTextEntryBase, 0, 0},  {&_swigt__p_wxSearchCtrlBase, _p_wxSearchCtrlBaseTo_p_wxTextEntryBase, 0, 0},  {&_swigt__p_wxTextCtrl, _p_wxTextCtrlTo_p_wxTextEntryBase, 0, 0},  {&_swigt__p_wxTextEntry, _p_wxTextEntryTo_p_wxTextEntryBase, 0, 0},  {&_swigt__p_wxTextCtrlIface, _p_wxTextCtrlIfaceTo_p_wxTextEntryBase, 0, 0},  {&_swigt__p_wxTextEntryBase, 0, 0, 0},  {&_swigt__p_wxSearchCtrl, _p_wxSearchCtrlTo_p_wxTextEntryBase, 0, 0},{0, 0, 0, 0}};
 
54538
static swig_cast_info _swigc__p_wxTextUrlEvent[] = {  {&_swigt__p_wxTextUrlEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54539
static swig_cast_info _swigc__p_wxToggleButton[] = {  {&_swigt__p_wxToggleButton, 0, 0, 0},{0, 0, 0, 0}};
 
54540
static swig_cast_info _swigc__p_wxToolBar[] = {  {&_swigt__p_wxToolBar, 0, 0, 0},{0, 0, 0, 0}};
 
54541
static swig_cast_info _swigc__p_wxToolBarBase[] = {  {&_swigt__p_wxToolBarBase, 0, 0, 0},  {&_swigt__p_wxToolBar, _p_wxToolBarTo_p_wxToolBarBase, 0, 0},{0, 0, 0, 0}};
 
54542
static swig_cast_info _swigc__p_wxToolBarToolBase[] = {  {&_swigt__p_wxToolBarToolBase, 0, 0, 0},{0, 0, 0, 0}};
 
54543
static swig_cast_info _swigc__p_wxToolbook[] = {  {&_swigt__p_wxToolbook, 0, 0, 0},{0, 0, 0, 0}};
 
54544
static swig_cast_info _swigc__p_wxTreeEvent[] = {  {&_swigt__p_wxTreeEvent, 0, 0, 0},{0, 0, 0, 0}};
 
54545
static swig_cast_info _swigc__p_wxTreeItemId[] = {  {&_swigt__p_wxTreeItemId, 0, 0, 0},{0, 0, 0, 0}};
 
54546
static swig_cast_info _swigc__p_wxTreebook[] = {  {&_swigt__p_wxTreebook, 0, 0, 0},{0, 0, 0, 0}};
 
54547
static swig_cast_info _swigc__p_wxValidator[] = {  {&_swigt__p_wxValidator, 0, 0, 0},  {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxValidator, 0, 0},{0, 0, 0, 0}};
 
54548
static swig_cast_info _swigc__p_wxVisualAttributes[] = {  {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
 
54549
static swig_cast_info _swigc__p_wxWindow[] = {  {&_swigt__p_wxCollapsiblePane, _p_wxCollapsiblePaneTo_p_wxWindow, 0, 0},  {&_swigt__p_wxDatePickerCtrlGeneric, _p_wxDatePickerCtrlGenericTo_p_wxWindow, 0, 0},  {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSearchCtrlBase, _p_wxSearchCtrlBaseTo_p_wxWindow, 0, 0},  {&_swigt__p_wxTextCtrlBase, _p_wxTextCtrlBaseTo_p_wxWindow, 0, 0},  {&_swigt__p_wxBookCtrlBase, _p_wxBookCtrlBaseTo_p_wxWindow, 0, 0},  {&_swigt__p_wxDatePickerCtrlBase, _p_wxDatePickerCtrlBaseTo_p_wxWindow, 0, 0},  {&_swigt__p_wxInfoBar, _p_wxInfoBarTo_p_wxWindow, 0, 0},  {&_swigt__p_wxFileCtrl, _p_wxFileCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxToolBar, _p_wxToolBarTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyPickerBase, _p_wxPyPickerBaseTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPickerBase, _p_wxPickerBaseTo_p_wxWindow, 0, 0},  {&_swigt__p_wxRadioButton, _p_wxRadioButtonTo_p_wxWindow, 0, 0},  {&_swigt__p_wxToggleButton, _p_wxToggleButtonTo_p_wxWindow, 0, 0},  {&_swigt__p_wxAnyButton, _p_wxAnyButtonTo_p_wxWindow, 0, 0},  {&_swigt__p_wxCommandLinkButton, _p_wxCommandLinkButtonTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSearchCtrl, _p_wxSearchCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxToolbook, _p_wxToolbookTo_p_wxWindow, 0, 0},  {&_swigt__p_wxWindow, 0, 0, 0},  {&_swigt__p_wxSpinCtrlDouble, _p_wxSpinCtrlDoubleTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyControl, _p_wxPyControlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxToolBarBase, _p_wxToolBarBaseTo_p_wxWindow, 0, 0},  {&_swigt__p_wxDirFilterListCtrl, _p_wxDirFilterListCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyListCtrl, _p_wxPyListCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxComboBox, _p_wxComboBoxTo_p_wxWindow, 0, 0},  {&_swigt__p_wxGenericDirCtrl, _p_wxGenericDirCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxScrollBar, _p_wxScrollBarTo_p_wxWindow, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0},  {&_swigt__p_wxGauge, _p_wxGaugeTo_p_wxWindow, 0, 0},  {&_swigt__p_wxChoicebook, _p_wxChoicebookTo_p_wxWindow, 0, 0},  {&_swigt__p_wxStaticLine, _p_wxStaticLineTo_p_wxWindow, 0, 0},  {&_swigt__p_wxListbook, _p_wxListbookTo_p_wxWindow, 0, 0},  {&_swigt__p_wxHyperlinkCtrl, _p_wxHyperlinkCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxPyTreeCtrl, _p_wxPyTreeCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxCheckBox, _p_wxCheckBoxTo_p_wxWindow, 0, 0},  {&_swigt__p_wxRadioBox, _p_wxRadioBoxTo_p_wxWindow, 0, 0},  {&_swigt__p_wxChoice, _p_wxChoiceTo_p_wxWindow, 0, 0},  {&_swigt__p_wxListBox, _p_wxListBoxTo_p_wxWindow, 0, 0},  {&_swigt__p_wxCheckListBox, _p_wxCheckListBoxTo_p_wxWindow, 0, 0},  {&_swigt__p_wxNotebook, _p_wxNotebookTo_p_wxWindow, 0, 0},  {&_swigt__p_wxListView, _p_wxListViewTo_p_wxWindow, 0, 0},  {&_swigt__p_wxStaticBitmap, _p_wxStaticBitmapTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSpinCtrl, _p_wxSpinCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxStaticText, _p_wxStaticTextTo_p_wxWindow, 0, 0},  {&_swigt__p_wxStaticBox, _p_wxStaticBoxTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSlider, _p_wxSliderTo_p_wxWindow, 0, 0},  {&_swigt__p_wxTreebook, _p_wxTreebookTo_p_wxWindow, 0, 0},  {&_swigt__p_wxContextHelpButton, _p_wxContextHelpButtonTo_p_wxWindow, 0, 0},  {&_swigt__p_wxBitmapButton, _p_wxBitmapButtonTo_p_wxWindow, 0, 0},  {&_swigt__p_wxButton, _p_wxButtonTo_p_wxWindow, 0, 0},  {&_swigt__p_wxSpinButton, _p_wxSpinButtonTo_p_wxWindow, 0, 0},  {&_swigt__p_wxFontPickerCtrl, _p_wxFontPickerCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxDirPickerCtrl, _p_wxDirPickerCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxFilePickerCtrl, _p_wxFilePickerCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxColourPickerCtrl, _p_wxColourPickerCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxDatePickerCtrl, _p_wxDatePickerCtrlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxTextCtrl, _p_wxTextCtrlTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
 
54550
static swig_cast_info _swigc__p_wxWindowBase[] = {  {&_swigt__p_wxWindowBase, 0, 0, 0},{0, 0, 0, 0}};
 
54551
static swig_cast_info _swigc__p_wxWithImages[] = {  {&_swigt__p_wxChoicebook, _p_wxChoicebookTo_p_wxWithImages, 0, 0},  {&_swigt__p_wxListbook, _p_wxListbookTo_p_wxWithImages, 0, 0},  {&_swigt__p_wxWithImages, 0, 0, 0},  {&_swigt__p_wxBookCtrlBase, _p_wxBookCtrlBaseTo_p_wxWithImages, 0, 0},  {&_swigt__p_wxToolbook, _p_wxToolbookTo_p_wxWithImages, 0, 0},  {&_swigt__p_wxTreebook, _p_wxTreebookTo_p_wxWithImages, 0, 0},  {&_swigt__p_wxNotebook, _p_wxNotebookTo_p_wxWithImages, 0, 0},{0, 0, 0, 0}};
 
54552
 
 
54553
static swig_cast_info *swig_cast_initial[] = {
 
54554
  _swigc__p_bool,
 
54555
  _swigc__p_char,
 
54556
  _swigc__p_double,
 
54557
  _swigc__p_int,
 
54558
  _swigc__p_long,
 
54559
  _swigc__p_unsigned_char,
 
54560
  _swigc__p_unsigned_int,
 
54561
  _swigc__p_unsigned_long,
 
54562
  _swigc__p_void,
 
54563
  _swigc__p_wxANIHandler,
 
54564
  _swigc__p_wxAcceleratorTable,
 
54565
  _swigc__p_wxActivateEvent,
 
54566
  _swigc__p_wxAnyButton,
 
54567
  _swigc__p_wxArrayInt,
 
54568
  _swigc__p_wxArrayString,
 
54569
  _swigc__p_wxBMPHandler,
 
54570
  _swigc__p_wxBitmap,
 
54571
  _swigc__p_wxBitmapButton,
 
54572
  _swigc__p_wxBookCtrlBase,
 
54573
  _swigc__p_wxBookCtrlEvent,
 
54574
  _swigc__p_wxBoxSizer,
 
54575
  _swigc__p_wxButton,
 
54576
  _swigc__p_wxCURHandler,
 
54577
  _swigc__p_wxCheckBox,
 
54578
  _swigc__p_wxCheckListBox,
 
54579
  _swigc__p_wxChildFocusEvent,
 
54580
  _swigc__p_wxChoice,
 
54581
  _swigc__p_wxChoicebook,
 
54582
  _swigc__p_wxClipboardTextEvent,
 
54583
  _swigc__p_wxCloseEvent,
 
54584
  _swigc__p_wxCollapsiblePane,
 
54585
  _swigc__p_wxCollapsiblePaneEvent,
 
54586
  _swigc__p_wxColour,
 
54587
  _swigc__p_wxColourPickerCtrl,
 
54588
  _swigc__p_wxColourPickerEvent,
 
54589
  _swigc__p_wxComboBox,
 
54590
  _swigc__p_wxCommandEvent,
 
54591
  _swigc__p_wxCommandLinkButton,
 
54592
  _swigc__p_wxContextHelp,
 
54593
  _swigc__p_wxContextHelpButton,
 
54594
  _swigc__p_wxContextMenuEvent,
 
54595
  _swigc__p_wxControl,
 
54596
  _swigc__p_wxControlWithItems,
 
54597
  _swigc__p_wxCursor,
 
54598
  _swigc__p_wxDC,
 
54599
  _swigc__p_wxDateEvent,
 
54600
  _swigc__p_wxDatePickerCtrl,
 
54601
  _swigc__p_wxDatePickerCtrlBase,
 
54602
  _swigc__p_wxDatePickerCtrlGeneric,
 
54603
  _swigc__p_wxDateTime,
 
54604
  _swigc__p_wxDirFilterListCtrl,
 
54605
  _swigc__p_wxDirItemData,
 
54606
  _swigc__p_wxDirPickerCtrl,
 
54607
  _swigc__p_wxDisplayChangedEvent,
 
54608
  _swigc__p_wxDropFilesEvent,
 
54609
  _swigc__p_wxDuplexMode,
 
54610
  _swigc__p_wxEraseEvent,
 
54611
  _swigc__p_wxEvent,
 
54612
  _swigc__p_wxEventBlocker,
 
54613
  _swigc__p_wxEvtHandler,
 
54614
  _swigc__p_wxFSFile,
 
54615
  _swigc__p_wxFileCtrl,
 
54616
  _swigc__p_wxFileCtrlEvent,
 
54617
  _swigc__p_wxFileDirPickerEvent,
 
54618
  _swigc__p_wxFilePickerCtrl,
 
54619
  _swigc__p_wxFileSystem,
 
54620
  _swigc__p_wxFlexGridSizer,
 
54621
  _swigc__p_wxFocusEvent,
 
54622
  _swigc__p_wxFont,
 
54623
  _swigc__p_wxFontPickerCtrl,
 
54624
  _swigc__p_wxFontPickerEvent,
 
54625
  _swigc__p_wxGBSizerItem,
 
54626
  _swigc__p_wxGIFHandler,
 
54627
  _swigc__p_wxGauge,
 
54628
  _swigc__p_wxGenericDirCtrl,
 
54629
  _swigc__p_wxGenericDragImage,
 
54630
  _swigc__p_wxGridBagSizer,
 
54631
  _swigc__p_wxGridSizer,
 
54632
  _swigc__p_wxHelpEvent,
 
54633
  _swigc__p_wxHelpProvider,
 
54634
  _swigc__p_wxHyperlinkCtrl,
 
54635
  _swigc__p_wxHyperlinkEvent,
 
54636
  _swigc__p_wxICOHandler,
 
54637
  _swigc__p_wxIcon,
 
54638
  _swigc__p_wxIconizeEvent,
 
54639
  _swigc__p_wxIdleEvent,
 
54640
  _swigc__p_wxImage,
 
54641
  _swigc__p_wxImageHandler,
 
54642
  _swigc__p_wxImageList,
 
54643
  _swigc__p_wxIndividualLayoutConstraint,
 
54644
  _swigc__p_wxInfoBar,
 
54645
  _swigc__p_wxInitDialogEvent,
 
54646
  _swigc__p_wxItemContainer,
 
54647
  _swigc__p_wxJPEGHandler,
 
54648
  _swigc__p_wxKeyEvent,
 
54649
  _swigc__p_wxLayoutConstraints,
 
54650
  _swigc__p_wxListBox,
 
54651
  _swigc__p_wxListEvent,
 
54652
  _swigc__p_wxListItem,
 
54653
  _swigc__p_wxListItemAttr,
 
54654
  _swigc__p_wxListView,
 
54655
  _swigc__p_wxListbook,
 
54656
  _swigc__p_wxMaximizeEvent,
 
54657
  _swigc__p_wxMemoryDC,
 
54658
  _swigc__p_wxMenu,
 
54659
  _swigc__p_wxMenuBar,
 
54660
  _swigc__p_wxMenuEvent,
 
54661
  _swigc__p_wxMenuItem,
 
54662
  _swigc__p_wxMouseCaptureChangedEvent,
 
54663
  _swigc__p_wxMouseCaptureLostEvent,
 
54664
  _swigc__p_wxMouseEvent,
 
54665
  _swigc__p_wxMoveEvent,
 
54666
  _swigc__p_wxNavigationKeyEvent,
 
54667
  _swigc__p_wxNcPaintEvent,
 
54668
  _swigc__p_wxNotebook,
 
54669
  _swigc__p_wxNotifyEvent,
 
54670
  _swigc__p_wxObject,
 
54671
  _swigc__p_wxPCXHandler,
 
54672
  _swigc__p_wxPNGHandler,
 
54673
  _swigc__p_wxPNMHandler,
 
54674
  _swigc__p_wxPaintEvent,
 
54675
  _swigc__p_wxPaletteChangedEvent,
 
54676
  _swigc__p_wxPaperSize,
 
54677
  _swigc__p_wxPickerBase,
 
54678
  _swigc__p_wxPoint,
 
54679
  _swigc__p_wxPyApp,
 
54680
  _swigc__p_wxPyCommandEvent,
 
54681
  _swigc__p_wxPyControl,
 
54682
  _swigc__p_wxPyEvent,
 
54683
  _swigc__p_wxPyEvtHandler,
 
54684
  _swigc__p_wxPyImageHandler,
 
54685
  _swigc__p_wxPyListCtrl,
 
54686
  _swigc__p_wxPyPickerBase,
 
54687
  _swigc__p_wxPySizer,
 
54688
  _swigc__p_wxPyTreeCtrl,
 
54689
  _swigc__p_wxPyTreeItemData,
 
54690
  _swigc__p_wxPyValidator,
 
54691
  _swigc__p_wxQueryNewPaletteEvent,
 
54692
  _swigc__p_wxRadioBox,
 
54693
  _swigc__p_wxRadioButton,
 
54694
  _swigc__p_wxRect,
 
54695
  _swigc__p_wxRefCounter,
 
54696
  _swigc__p_wxScrollBar,
 
54697
  _swigc__p_wxScrollEvent,
 
54698
  _swigc__p_wxScrollWinEvent,
 
54699
  _swigc__p_wxSearchCtrl,
 
54700
  _swigc__p_wxSearchCtrlBase,
 
54701
  _swigc__p_wxSetCursorEvent,
 
54702
  _swigc__p_wxShowEvent,
 
54703
  _swigc__p_wxSimpleHelpProvider,
 
54704
  _swigc__p_wxSize,
 
54705
  _swigc__p_wxSizeEvent,
 
54706
  _swigc__p_wxSizer,
 
54707
  _swigc__p_wxSizerItem,
 
54708
  _swigc__p_wxSlider,
 
54709
  _swigc__p_wxSpinButton,
 
54710
  _swigc__p_wxSpinCtrl,
 
54711
  _swigc__p_wxSpinCtrlDouble,
 
54712
  _swigc__p_wxSpinDoubleEvent,
 
54713
  _swigc__p_wxSpinEvent,
 
54714
  _swigc__p_wxStaticBitmap,
 
54715
  _swigc__p_wxStaticBox,
 
54716
  _swigc__p_wxStaticBoxSizer,
 
54717
  _swigc__p_wxStaticLine,
 
54718
  _swigc__p_wxStaticText,
 
54719
  _swigc__p_wxStdDialogButtonSizer,
 
54720
  _swigc__p_wxString,
 
54721
  _swigc__p_wxSysColourChangedEvent,
 
54722
  _swigc__p_wxTGAHandler,
 
54723
  _swigc__p_wxTIFFHandler,
 
54724
  _swigc__p_wxTextAreaBase,
 
54725
  _swigc__p_wxTextAttr,
 
54726
  _swigc__p_wxTextCtrl,
 
54727
  _swigc__p_wxTextCtrlBase,
 
54728
  _swigc__p_wxTextCtrlIface,
 
54729
  _swigc__p_wxTextEntry,
 
54730
  _swigc__p_wxTextEntryBase,
 
54731
  _swigc__p_wxTextUrlEvent,
 
54732
  _swigc__p_wxThreadEvent,
 
54733
  _swigc__p_wxToggleButton,
 
54734
  _swigc__p_wxToolBar,
 
54735
  _swigc__p_wxToolBarBase,
 
54736
  _swigc__p_wxToolBarToolBase,
 
54737
  _swigc__p_wxToolbook,
 
54738
  _swigc__p_wxTreeEvent,
 
54739
  _swigc__p_wxTreeItemId,
 
54740
  _swigc__p_wxTreebook,
 
54741
  _swigc__p_wxUpdateUIEvent,
 
54742
  _swigc__p_wxValidator,
 
54743
  _swigc__p_wxVisualAttributes,
 
54744
  _swigc__p_wxWindow,
 
54745
  _swigc__p_wxWindowBase,
 
54746
  _swigc__p_wxWindowCreateEvent,
 
54747
  _swigc__p_wxWindowDestroyEvent,
 
54748
  _swigc__p_wxWithImages,
 
54749
  _swigc__p_wxWrapSizer,
 
54750
  _swigc__p_wxXPMHandler,
 
54751
};
 
54752
 
 
54753
 
 
54754
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
 
54755
 
 
54756
static swig_const_info swig_const_table[] = {
 
54757
{0, 0, 0, 0.0, 0, 0}};
 
54758
 
 
54759
#ifdef __cplusplus
 
54760
}
 
54761
#endif
 
54762
/* -----------------------------------------------------------------------------
 
54763
 * Type initialization:
 
54764
 * This problem is tough by the requirement that no dynamic 
 
54765
 * memory is used. Also, since swig_type_info structures store pointers to 
 
54766
 * swig_cast_info structures and swig_cast_info structures store pointers back
 
54767
 * to swig_type_info structures, we need some lookup code at initialization. 
 
54768
 * The idea is that swig generates all the structures that are needed. 
 
54769
 * The runtime then collects these partially filled structures. 
 
54770
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
54771
 * swig_module, and does all the lookup, filling in the swig_module.types
 
54772
 * array with the correct data and linking the correct swig_cast_info
 
54773
 * structures together.
 
54774
 *
 
54775
 * The generated swig_type_info structures are assigned staticly to an initial 
 
54776
 * array. We just loop though that array, and handle each type individually.
 
54777
 * First we lookup if this type has been already loaded, and if so, use the
 
54778
 * loaded structure instead of the generated one. Then we have to fill in the
 
54779
 * cast linked list. The cast data is initially stored in something like a
 
54780
 * two-dimensional array. Each row corresponds to a type (there are the same
 
54781
 * number of rows as there are in the swig_type_initial array). Each entry in
 
54782
 * a column is one of the swig_cast_info structures for that type.
 
54783
 * The cast_initial array is actually an array of arrays, because each row has
 
54784
 * a variable number of columns. So to actually build the cast linked list,
 
54785
 * we find the array of casts associated with the type, and loop through it 
 
54786
 * adding the casts to the list. The one last trick we need to do is making
 
54787
 * sure the type pointer in the swig_cast_info struct is correct.
 
54788
 *
 
54789
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
54790
 * There are three cases to handle:
 
54791
 *  1) If the cast->type has already been loaded AND the type we are adding
 
54792
 *     casting info to has not been loaded (it is in this module), THEN we
 
54793
 *     replace the cast->type pointer with the type pointer that has already
 
54794
 *     been loaded.
 
54795
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
54796
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 
54797
 *     the previous module so we just ignore it.
 
54798
 *  3) Finally, if cast->type has not already been loaded, then we add that
 
54799
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 
54800
 *     be correct.
 
54801
 * ----------------------------------------------------------------------------- */
 
54802
 
 
54803
#ifdef __cplusplus
 
54804
extern "C" {
 
54805
#if 0
 
54806
} /* c-mode */
 
54807
#endif
 
54808
#endif
 
54809
 
 
54810
#if 0
 
54811
#define SWIGRUNTIME_DEBUG
 
54812
#endif
 
54813
 
 
54814
SWIGRUNTIME void
 
54815
SWIG_InitializeModule(void *clientdata) {
 
54816
  size_t i;
 
54817
  swig_module_info *module_head;
 
54818
  static int init_run = 0;
 
54819
  
 
54820
  clientdata = clientdata;
 
54821
  
 
54822
  if (init_run) return;
 
54823
  init_run = 1;
 
54824
  
 
54825
  /* Initialize the swig_module */
 
54826
  swig_module.type_initial = swig_type_initial;
 
54827
  swig_module.cast_initial = swig_cast_initial;
 
54828
  
 
54829
  /* Try and load any already created modules */
 
54830
  module_head = SWIG_GetModule(clientdata);
 
54831
  if (module_head) {
 
54832
    swig_module.next = module_head->next;
 
54833
    module_head->next = &swig_module;
 
54834
  } else {
 
54835
    /* This is the first module loaded */
 
54836
    swig_module.next = &swig_module;
 
54837
    SWIG_SetModule(clientdata, &swig_module);
 
54838
  }
 
54839
  
 
54840
  /* Now work on filling in swig_module.types */
 
54841
#ifdef SWIGRUNTIME_DEBUG
 
54842
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
 
54843
#endif
 
54844
  for (i = 0; i < swig_module.size; ++i) {
 
54845
    swig_type_info *type = 0;
 
54846
    swig_type_info *ret;
 
54847
    swig_cast_info *cast;
 
54848
    
 
54849
#ifdef SWIGRUNTIME_DEBUG
 
54850
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
 
54851
#endif
 
54852
    
 
54853
    /* if there is another module already loaded */
 
54854
    if (swig_module.next != &swig_module) {
 
54855
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
 
54856
    }
 
54857
    if (type) {
 
54858
      /* Overwrite clientdata field */
 
54859
#ifdef SWIGRUNTIME_DEBUG
 
54860
      printf("SWIG_InitializeModule: found type %s\n", type->name);
 
54861
#endif
 
54862
      if (swig_module.type_initial[i]->clientdata) {
 
54863
        type->clientdata = swig_module.type_initial[i]->clientdata;
 
54864
#ifdef SWIGRUNTIME_DEBUG
 
54865
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
 
54866
#endif
 
54867
      }
 
54868
    } else {
 
54869
      type = swig_module.type_initial[i];
 
54870
    }
 
54871
    
 
54872
    /* Insert casting types */
 
54873
    cast = swig_module.cast_initial[i];
 
54874
    while (cast->type) {
 
54875
      /* Don't need to add information already in the list */
 
54876
      ret = 0;
 
54877
#ifdef SWIGRUNTIME_DEBUG
 
54878
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
 
54879
#endif
 
54880
      if (swig_module.next != &swig_module) {
 
54881
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
 
54882
#ifdef SWIGRUNTIME_DEBUG
 
54883
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
 
54884
#endif
 
54885
      }
 
54886
      if (ret) {
 
54887
        if (type == swig_module.type_initial[i]) {
 
54888
#ifdef SWIGRUNTIME_DEBUG
 
54889
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
 
54890
#endif
 
54891
          cast->type = ret;
 
54892
          ret = 0;
 
54893
        } else {
 
54894
          /* Check for casting already in the list */
 
54895
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
 
54896
#ifdef SWIGRUNTIME_DEBUG
 
54897
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
 
54898
#endif
 
54899
          if (!ocast) ret = 0;
 
54900
        }
 
54901
      }
 
54902
      
 
54903
      if (!ret) {
 
54904
#ifdef SWIGRUNTIME_DEBUG
 
54905
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
 
54906
#endif
 
54907
        if (type->cast) {
 
54908
          type->cast->prev = cast;
 
54909
          cast->next = type->cast;
 
54910
        }
 
54911
        type->cast = cast;
 
54912
      }
 
54913
      cast++;
 
54914
    }
 
54915
    /* Set entry in modules->types array equal to the type */
 
54916
    swig_module.types[i] = type;
 
54917
  }
 
54918
  swig_module.types[i] = 0;
 
54919
  
 
54920
#ifdef SWIGRUNTIME_DEBUG
 
54921
  printf("**** SWIG_InitializeModule: Cast List ******\n");
 
54922
  for (i = 0; i < swig_module.size; ++i) {
 
54923
    int j = 0;
 
54924
    swig_cast_info *cast = swig_module.cast_initial[i];
 
54925
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
 
54926
    while (cast->type) {
 
54927
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
 
54928
      cast++;
 
54929
      ++j;
 
54930
    }
 
54931
    printf("---- Total casts: %d\n",j);
 
54932
  }
 
54933
  printf("**** SWIG_InitializeModule: Cast List ******\n");
 
54934
#endif
 
54935
}
 
54936
 
 
54937
/* This function will propagate the clientdata field of type to
 
54938
* any new swig_type_info structures that have been added into the list
 
54939
* of equivalent types.  It is like calling
 
54940
* SWIG_TypeClientData(type, clientdata) a second time.
 
54941
*/
 
54942
SWIGRUNTIME void
 
54943
SWIG_PropagateClientData(void) {
 
54944
  size_t i;
 
54945
  swig_cast_info *equiv;
 
54946
  static int init_run = 0;
 
54947
  
 
54948
  if (init_run) return;
 
54949
  init_run = 1;
 
54950
  
 
54951
  for (i = 0; i < swig_module.size; i++) {
 
54952
    if (swig_module.types[i]->clientdata) {
 
54953
      equiv = swig_module.types[i]->cast;
 
54954
      while (equiv) {
 
54955
        if (!equiv->converter) {
 
54956
          if (equiv->type && !equiv->type->clientdata)
 
54957
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
 
54958
        }
 
54959
        equiv = equiv->next;
 
54960
      }
 
54961
    }
 
54962
  }
 
54963
}
 
54964
 
 
54965
#ifdef __cplusplus
 
54966
#if 0
 
54967
{
 
54968
  /* c-mode */
 
54969
#endif
 
54970
}
 
54971
#endif
 
54972
 
 
54973
 
 
54974
 
 
54975
#ifdef __cplusplus
 
54976
extern "C" {
 
54977
#endif
 
54978
  
 
54979
  /* Python-specific SWIG API */
 
54980
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
 
54981
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
 
54982
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
54983
  
 
54984
  /* -----------------------------------------------------------------------------
 
54985
   * global variable support code.
 
54986
   * ----------------------------------------------------------------------------- */
 
54987
  
 
54988
  typedef struct swig_globalvar {
 
54989
    char       *name;                  /* Name of global variable */
 
54990
    PyObject *(*get_attr)(void);       /* Return the current value */
 
54991
    int       (*set_attr)(PyObject *); /* Set the value */
 
54992
    struct swig_globalvar *next;
 
54993
  } swig_globalvar;
 
54994
  
 
54995
  typedef struct swig_varlinkobject {
 
54996
    PyObject_HEAD
 
54997
    swig_globalvar *vars;
 
54998
  } swig_varlinkobject;
 
54999
  
 
55000
  SWIGINTERN PyObject *
 
55001
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
 
55002
    return PyString_FromString("<Swig global variables>");
 
55003
  }
 
55004
  
 
55005
  SWIGINTERN PyObject *
 
55006
  swig_varlink_str(swig_varlinkobject *v) {
 
55007
    PyObject *str = PyString_FromString("(");
 
55008
    swig_globalvar  *var;
 
55009
    for (var = v->vars; var; var=var->next) {
 
55010
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
 
55011
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
 
55012
    }
 
55013
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
 
55014
    return str;
 
55015
  }
 
55016
  
 
55017
  SWIGINTERN int
 
55018
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
 
55019
    PyObject *str = swig_varlink_str(v);
 
55020
    fprintf(fp,"Swig global variables ");
 
55021
    fprintf(fp,"%s\n", PyString_AsString(str));
 
55022
    Py_DECREF(str);
 
55023
    return 0;
 
55024
  }
 
55025
  
 
55026
  SWIGINTERN void
 
55027
  swig_varlink_dealloc(swig_varlinkobject *v) {
 
55028
    swig_globalvar *var = v->vars;
 
55029
    while (var) {
 
55030
      swig_globalvar *n = var->next;
 
55031
      free(var->name);
 
55032
      free(var);
 
55033
      var = n;
 
55034
    }
 
55035
  }
 
55036
  
 
55037
  SWIGINTERN PyObject *
 
55038
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
 
55039
    PyObject *res = NULL;
 
55040
    swig_globalvar *var = v->vars;
 
55041
    while (var) {
 
55042
      if (strcmp(var->name,n) == 0) {
 
55043
        res = (*var->get_attr)();
 
55044
        break;
 
55045
      }
 
55046
      var = var->next;
 
55047
    }
 
55048
    if (res == NULL && !PyErr_Occurred()) {
 
55049
      PyErr_SetString(PyExc_NameError,"Unknown C global variable");
 
55050
    }
 
55051
    return res;
 
55052
  }
 
55053
  
 
55054
  SWIGINTERN int
 
55055
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
 
55056
    int res = 1;
 
55057
    swig_globalvar *var = v->vars;
 
55058
    while (var) {
 
55059
      if (strcmp(var->name,n) == 0) {
 
55060
        res = (*var->set_attr)(p);
 
55061
        break;
 
55062
      }
 
55063
      var = var->next;
 
55064
    }
 
55065
    if (res == 1 && !PyErr_Occurred()) {
 
55066
      PyErr_SetString(PyExc_NameError,"Unknown C global variable");
 
55067
    }
 
55068
    return res;
 
55069
  }
 
55070
  
 
55071
  SWIGINTERN PyTypeObject*
 
55072
  swig_varlink_type(void) {
 
55073
    static char varlink__doc__[] = "Swig var link object";
 
55074
    static PyTypeObject varlink_type;
 
55075
    static int type_init = 0;  
 
55076
    if (!type_init) {
 
55077
      const PyTypeObject tmp
 
55078
      = {
 
55079
        PyObject_HEAD_INIT(NULL)
 
55080
        0,                                  /* Number of items in variable part (ob_size) */
 
55081
        (char *)"swigvarlink",              /* Type name (tp_name) */
 
55082
        sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
 
55083
        0,                                  /* Itemsize (tp_itemsize) */
 
55084
        (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */ 
 
55085
        (printfunc) swig_varlink_print,     /* Print (tp_print) */
 
55086
        (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
 
55087
        (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
 
55088
        0,                                  /* tp_compare */
 
55089
        (reprfunc) swig_varlink_repr,       /* tp_repr */
 
55090
        0,                                  /* tp_as_number */
 
55091
        0,                                  /* tp_as_sequence */
 
55092
        0,                                  /* tp_as_mapping */
 
55093
        0,                                  /* tp_hash */
 
55094
        0,                                  /* tp_call */
 
55095
        (reprfunc)swig_varlink_str,        /* tp_str */
 
55096
        0,                                  /* tp_getattro */
 
55097
        0,                                  /* tp_setattro */
 
55098
        0,                                  /* tp_as_buffer */
 
55099
        0,                                  /* tp_flags */
 
55100
        varlink__doc__,                     /* tp_doc */
 
55101
        0,                                  /* tp_traverse */
 
55102
        0,                                  /* tp_clear */
 
55103
        0,                                  /* tp_richcompare */
 
55104
        0,                                  /* tp_weaklistoffset */
 
55105
#if PY_VERSION_HEX >= 0x02020000
 
55106
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
 
55107
#endif
 
55108
#if PY_VERSION_HEX >= 0x02030000
 
55109
        0,                                  /* tp_del */
 
55110
#endif
 
55111
#ifdef COUNT_ALLOCS
 
55112
        0,0,0,0                             /* tp_alloc -> tp_next */
 
55113
#endif
 
55114
      };
 
55115
      varlink_type = tmp;
 
55116
      varlink_type.ob_type = &PyType_Type;
 
55117
      type_init = 1;
 
55118
    }
 
55119
    return &varlink_type;
 
55120
  }
 
55121
  
 
55122
  /* Create a variable linking object for use later */
 
55123
  SWIGINTERN PyObject *
 
55124
  SWIG_Python_newvarlink(void) {
 
55125
    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
 
55126
    if (result) {
 
55127
      result->vars = 0;
 
55128
    }
 
55129
    return ((PyObject*) result);
 
55130
  }
 
55131
  
 
55132
  SWIGINTERN void 
 
55133
  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
 
55134
    swig_varlinkobject *v = (swig_varlinkobject *) p;
 
55135
    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
 
55136
    if (gv) {
 
55137
      size_t size = strlen(name)+1;
 
55138
      gv->name = (char *)malloc(size);
 
55139
      if (gv->name) {
 
55140
        strncpy(gv->name,name,size);
 
55141
        gv->get_attr = get_attr;
 
55142
        gv->set_attr = set_attr;
 
55143
        gv->next = v->vars;
 
55144
      }
 
55145
    }
 
55146
    v->vars = gv;
 
55147
  }
 
55148
  
 
55149
  SWIGINTERN PyObject *
 
55150
  SWIG_globals() {
 
55151
    static PyObject *_SWIG_globals = 0; 
 
55152
    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
 
55153
    return _SWIG_globals;
 
55154
  }
 
55155
  
 
55156
  /* -----------------------------------------------------------------------------
 
55157
   * constants/methods manipulation
 
55158
   * ----------------------------------------------------------------------------- */
 
55159
  
 
55160
  /* Install Constants */
 
55161
  SWIGINTERN void
 
55162
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
 
55163
    PyObject *obj = 0;
 
55164
    size_t i;
 
55165
    for (i = 0; constants[i].type; ++i) {
 
55166
      switch(constants[i].type) {
 
55167
      case SWIG_PY_POINTER:
 
55168
        obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
 
55169
        break;
 
55170
      case SWIG_PY_BINARY:
 
55171
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
 
55172
        break;
 
55173
      default:
 
55174
        obj = 0;
 
55175
        break;
 
55176
      }
 
55177
      if (obj) {
 
55178
        PyDict_SetItemString(d, constants[i].name, obj);
 
55179
        Py_DECREF(obj);
 
55180
      }
 
55181
    }
 
55182
  }
 
55183
  
 
55184
  /* -----------------------------------------------------------------------------*/
 
55185
  /* Fix SwigMethods to carry the callback ptrs when needed */
 
55186
  /* -----------------------------------------------------------------------------*/
 
55187
  
 
55188
  SWIGINTERN void
 
55189
  SWIG_Python_FixMethods(PyMethodDef *methods,
 
55190
    swig_const_info *const_table,
 
55191
    swig_type_info **types,
 
55192
    swig_type_info **types_initial) {
 
55193
    size_t i;
 
55194
    for (i = 0; methods[i].ml_name; ++i) {
 
55195
      const char *c = methods[i].ml_doc;
 
55196
      if (c && (c = strstr(c, "swig_ptr: "))) {
 
55197
        int j;
 
55198
        swig_const_info *ci = 0;
 
55199
        const char *name = c + 10;
 
55200
        for (j = 0; const_table[j].type; ++j) {
 
55201
          if (strncmp(const_table[j].name, name, 
 
55202
              strlen(const_table[j].name)) == 0) {
 
55203
            ci = &(const_table[j]);
 
55204
            break;
 
55205
          }
 
55206
        }
 
55207
        if (ci) {
 
55208
          size_t shift = (ci->ptype) - types;
 
55209
          swig_type_info *ty = types_initial[shift];
 
55210
          size_t ldoc = (c - methods[i].ml_doc);
 
55211
          size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
 
55212
          char *ndoc = (char*)malloc(ldoc + lptr + 10);
 
55213
          if (ndoc) {
 
55214
            char *buff = ndoc;
 
55215
            void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
 
55216
            if (ptr) {
 
55217
              strncpy(buff, methods[i].ml_doc, ldoc);
 
55218
              buff += ldoc;
 
55219
              strncpy(buff, "swig_ptr: ", 10);
 
55220
              buff += 10;
 
55221
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
 
55222
              methods[i].ml_doc = ndoc;
 
55223
            }
 
55224
          }
 
55225
        }
 
55226
      }
 
55227
    }
 
55228
  } 
 
55229
  
 
55230
#ifdef __cplusplus
 
55231
}
 
55232
#endif
 
55233
 
 
55234
/* -----------------------------------------------------------------------------*
 
55235
 *  Partial Init method
 
55236
 * -----------------------------------------------------------------------------*/
 
55237
 
 
55238
#ifdef __cplusplus
 
55239
extern "C"
 
55240
#endif
 
55241
SWIGEXPORT void SWIG_init(void) {
 
55242
  PyObject *m, *d;
 
55243
  
 
55244
  /* Fix SwigMethods to carry the callback ptrs when needed */
 
55245
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
 
55246
  
 
55247
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
 
55248
  d = PyModule_GetDict(m);
 
55249
  
 
55250
  SWIG_InitializeModule(0);
 
55251
  SWIG_InstallConstants(d,swig_const_table);
 
55252
  
 
55253
  
 
55254
  PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
 
55255
  SWIG_addvarlink(SWIG_globals(),(char*)"ButtonNameStr",ButtonNameStr_get, ButtonNameStr_set);
 
55256
  SWIG_Python_SetConstant(d, "BU_LEFT",SWIG_From_int(static_cast< int >(wxBU_LEFT)));
 
55257
  SWIG_Python_SetConstant(d, "BU_TOP",SWIG_From_int(static_cast< int >(wxBU_TOP)));
 
55258
  SWIG_Python_SetConstant(d, "BU_RIGHT",SWIG_From_int(static_cast< int >(wxBU_RIGHT)));
 
55259
  SWIG_Python_SetConstant(d, "BU_BOTTOM",SWIG_From_int(static_cast< int >(wxBU_BOTTOM)));
 
55260
  SWIG_Python_SetConstant(d, "BU_ALIGN_MASK",SWIG_From_int(static_cast< int >(wxBU_ALIGN_MASK)));
 
55261
  SWIG_Python_SetConstant(d, "BU_EXACTFIT",SWIG_From_int(static_cast< int >(wxBU_EXACTFIT)));
 
55262
  SWIG_Python_SetConstant(d, "BU_AUTODRAW",SWIG_From_int(static_cast< int >(wxBU_AUTODRAW)));
 
55263
  SWIG_Python_SetConstant(d, "BU_NOTEXT",SWIG_From_int(static_cast< int >(wxBU_NOTEXT)));
 
55264
  SWIG_addvarlink(SWIG_globals(),(char*)"CheckBoxNameStr",CheckBoxNameStr_get, CheckBoxNameStr_set);
 
55265
  SWIG_Python_SetConstant(d, "CHK_2STATE",SWIG_From_int(static_cast< int >(wxCHK_2STATE)));
 
55266
  SWIG_Python_SetConstant(d, "CHK_3STATE",SWIG_From_int(static_cast< int >(wxCHK_3STATE)));
 
55267
  SWIG_Python_SetConstant(d, "CHK_ALLOW_3RD_STATE_FOR_USER",SWIG_From_int(static_cast< int >(wxCHK_ALLOW_3RD_STATE_FOR_USER)));
 
55268
  SWIG_addvarlink(SWIG_globals(),(char*)"ChoiceNameStr",ChoiceNameStr_get, ChoiceNameStr_set);
 
55269
  SWIG_addvarlink(SWIG_globals(),(char*)"ComboBoxNameStr",ComboBoxNameStr_get, ComboBoxNameStr_set);
 
55270
  SWIG_addvarlink(SWIG_globals(),(char*)"GaugeNameStr",GaugeNameStr_get, GaugeNameStr_set);
 
55271
  SWIG_Python_SetConstant(d, "GA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxGA_HORIZONTAL)));
 
55272
  SWIG_Python_SetConstant(d, "GA_VERTICAL",SWIG_From_int(static_cast< int >(wxGA_VERTICAL)));
 
55273
  SWIG_Python_SetConstant(d, "GA_SMOOTH",SWIG_From_int(static_cast< int >(wxGA_SMOOTH)));
 
55274
  SWIG_addvarlink(SWIG_globals(),(char*)"StaticBitmapNameStr",StaticBitmapNameStr_get, StaticBitmapNameStr_set);
 
55275
  SWIG_addvarlink(SWIG_globals(),(char*)"StaticBoxNameStr",StaticBoxNameStr_get, StaticBoxNameStr_set);
 
55276
  SWIG_addvarlink(SWIG_globals(),(char*)"StaticTextNameStr",StaticTextNameStr_get, StaticTextNameStr_set);
 
55277
  SWIG_addvarlink(SWIG_globals(),(char*)"StaticLineNameStr",StaticLineNameStr_get, StaticLineNameStr_set);
 
55278
  SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
 
55279
  SWIG_Python_SetConstant(d, "ST_ELLIPSIZE_START",SWIG_From_int(static_cast< int >(wxST_ELLIPSIZE_START)));
 
55280
  SWIG_Python_SetConstant(d, "ST_ELLIPSIZE_MIDDLE",SWIG_From_int(static_cast< int >(wxST_ELLIPSIZE_MIDDLE)));
 
55281
  SWIG_Python_SetConstant(d, "ST_ELLIPSIZE_END",SWIG_From_int(static_cast< int >(wxST_ELLIPSIZE_END)));
 
55282
  SWIG_addvarlink(SWIG_globals(),(char*)"ListBoxNameStr",ListBoxNameStr_get, ListBoxNameStr_set);
 
55283
  SWIG_addvarlink(SWIG_globals(),(char*)"TextCtrlNameStr",TextCtrlNameStr_get, TextCtrlNameStr_set);
 
55284
  SWIG_Python_SetConstant(d, "TE_NO_VSCROLL",SWIG_From_int(static_cast< int >(wxTE_NO_VSCROLL)));
 
55285
  SWIG_Python_SetConstant(d, "TE_AUTO_SCROLL",SWIG_From_int(static_cast< int >(wxTE_AUTO_SCROLL)));
 
55286
  SWIG_Python_SetConstant(d, "TE_READONLY",SWIG_From_int(static_cast< int >(wxTE_READONLY)));
 
55287
  SWIG_Python_SetConstant(d, "TE_MULTILINE",SWIG_From_int(static_cast< int >(wxTE_MULTILINE)));
 
55288
  SWIG_Python_SetConstant(d, "TE_PROCESS_TAB",SWIG_From_int(static_cast< int >(wxTE_PROCESS_TAB)));
 
55289
  SWIG_Python_SetConstant(d, "TE_LEFT",SWIG_From_int(static_cast< int >(wxTE_LEFT)));
 
55290
  SWIG_Python_SetConstant(d, "TE_CENTER",SWIG_From_int(static_cast< int >(wxTE_CENTER)));
 
55291
  SWIG_Python_SetConstant(d, "TE_RIGHT",SWIG_From_int(static_cast< int >(wxTE_RIGHT)));
 
55292
  SWIG_Python_SetConstant(d, "TE_CENTRE",SWIG_From_int(static_cast< int >(wxTE_CENTRE)));
 
55293
  SWIG_Python_SetConstant(d, "TE_RICH",SWIG_From_int(static_cast< int >(wxTE_RICH)));
 
55294
  SWIG_Python_SetConstant(d, "TE_PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxTE_PROCESS_ENTER)));
 
55295
  SWIG_Python_SetConstant(d, "TE_PASSWORD",SWIG_From_int(static_cast< int >(wxTE_PASSWORD)));
 
55296
  SWIG_Python_SetConstant(d, "TE_AUTO_URL",SWIG_From_int(static_cast< int >(wxTE_AUTO_URL)));
 
55297
  SWIG_Python_SetConstant(d, "TE_NOHIDESEL",SWIG_From_int(static_cast< int >(wxTE_NOHIDESEL)));
 
55298
  SWIG_Python_SetConstant(d, "TE_DONTWRAP",SWIG_From_int(static_cast< int >(wxTE_DONTWRAP)));
 
55299
  SWIG_Python_SetConstant(d, "TE_CHARWRAP",SWIG_From_int(static_cast< int >(wxTE_CHARWRAP)));
 
55300
  SWIG_Python_SetConstant(d, "TE_WORDWRAP",SWIG_From_int(static_cast< int >(wxTE_WORDWRAP)));
 
55301
  SWIG_Python_SetConstant(d, "TE_BESTWRAP",SWIG_From_int(static_cast< int >(wxTE_BESTWRAP)));
 
55302
  SWIG_Python_SetConstant(d, "TE_RICH2",SWIG_From_int(static_cast< int >(wxTE_RICH2)));
 
55303
  SWIG_Python_SetConstant(d, "TE_CAPITALIZE",SWIG_From_int(static_cast< int >(wxTE_CAPITALIZE)));
 
55304
  SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_DEFAULT",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_DEFAULT)));
 
55305
  SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_LEFT",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_LEFT)));
 
55306
  SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_CENTRE",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_CENTRE)));
 
55307
  SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_CENTER",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_CENTER)));
 
55308
  SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_RIGHT",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_RIGHT)));
 
55309
  SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_JUSTIFIED",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_JUSTIFIED)));
 
55310
  SWIG_Python_SetConstant(d, "TEXT_ATTR_TEXT_COLOUR",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_TEXT_COLOUR)));
 
55311
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BACKGROUND_COLOUR",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BACKGROUND_COLOUR)));
 
55312
  SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_FACE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_FACE)));
 
55313
  SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_SIZE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_SIZE)));
 
55314
  SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_WEIGHT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_WEIGHT)));
 
55315
  SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_ITALIC",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_ITALIC)));
 
55316
  SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_UNDERLINE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_UNDERLINE)));
 
55317
  SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_STRIKETHROUGH",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_STRIKETHROUGH)));
 
55318
  SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_ENCODING",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_ENCODING)));
 
55319
  SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_FAMILY",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_FAMILY)));
 
55320
  SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT)));
 
55321
  SWIG_Python_SetConstant(d, "TEXT_ATTR_ALIGNMENT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_ALIGNMENT)));
 
55322
  SWIG_Python_SetConstant(d, "TEXT_ATTR_LEFT_INDENT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LEFT_INDENT)));
 
55323
  SWIG_Python_SetConstant(d, "TEXT_ATTR_RIGHT_INDENT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_RIGHT_INDENT)));
 
55324
  SWIG_Python_SetConstant(d, "TEXT_ATTR_TABS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_TABS)));
 
55325
  SWIG_Python_SetConstant(d, "TEXT_ATTR_PARA_SPACING_AFTER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_PARA_SPACING_AFTER)));
 
55326
  SWIG_Python_SetConstant(d, "TEXT_ATTR_LINE_SPACING",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LINE_SPACING)));
 
55327
  SWIG_Python_SetConstant(d, "TEXT_ATTR_CHARACTER_STYLE_NAME",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_CHARACTER_STYLE_NAME)));
 
55328
  SWIG_Python_SetConstant(d, "TEXT_ATTR_PARAGRAPH_STYLE_NAME",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME)));
 
55329
  SWIG_Python_SetConstant(d, "TEXT_ATTR_LIST_STYLE_NAME",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LIST_STYLE_NAME)));
 
55330
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE)));
 
55331
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_NUMBER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_NUMBER)));
 
55332
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_TEXT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_TEXT)));
 
55333
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_NAME",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_NAME)));
 
55334
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET)));
 
55335
  SWIG_Python_SetConstant(d, "TEXT_ATTR_URL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_URL)));
 
55336
  SWIG_Python_SetConstant(d, "TEXT_ATTR_PAGE_BREAK",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_PAGE_BREAK)));
 
55337
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECTS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECTS)));
 
55338
  SWIG_Python_SetConstant(d, "TEXT_ATTR_OUTLINE_LEVEL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_OUTLINE_LEVEL)));
 
55339
  SWIG_Python_SetConstant(d, "TEXT_ATTR_CHARACTER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_CHARACTER)));
 
55340
  SWIG_Python_SetConstant(d, "TEXT_ATTR_PARAGRAPH",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_PARAGRAPH)));
 
55341
  SWIG_Python_SetConstant(d, "TEXT_ATTR_ALL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_ALL)));
 
55342
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_NONE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_NONE)));
 
55343
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ARABIC",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ARABIC)));
 
55344
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_LETTERS_UPPER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER)));
 
55345
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_LETTERS_LOWER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER)));
 
55346
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ROMAN_UPPER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER)));
 
55347
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ROMAN_LOWER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER)));
 
55348
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_SYMBOL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_SYMBOL)));
 
55349
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_BITMAP",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_BITMAP)));
 
55350
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_PARENTHESES",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_PARENTHESES)));
 
55351
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_PERIOD",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_PERIOD)));
 
55352
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_STANDARD",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_STANDARD)));
 
55353
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS)));
 
55354
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_OUTLINE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_OUTLINE)));
 
55355
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ALIGN_LEFT)));
 
55356
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT)));
 
55357
  SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE)));
 
55358
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_NONE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_NONE)));
 
55359
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_CAPITALS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_CAPITALS)));
 
55360
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_SMALL_CAPITALS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_SMALL_CAPITALS)));
 
55361
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_STRIKETHROUGH",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_STRIKETHROUGH)));
 
55362
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_DOUBLE_STRIKETHROUGH",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_DOUBLE_STRIKETHROUGH)));
 
55363
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_SHADOW",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_SHADOW)));
 
55364
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_EMBOSS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_EMBOSS)));
 
55365
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_OUTLINE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_OUTLINE)));
 
55366
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_ENGRAVE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_ENGRAVE)));
 
55367
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_SUPERSCRIPT)));
 
55368
  SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_SUBSCRIPT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_SUBSCRIPT)));
 
55369
  SWIG_Python_SetConstant(d, "TEXT_ATTR_LINE_SPACING_NORMAL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LINE_SPACING_NORMAL)));
 
55370
  SWIG_Python_SetConstant(d, "TEXT_ATTR_LINE_SPACING_HALF",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LINE_SPACING_HALF)));
 
55371
  SWIG_Python_SetConstant(d, "TEXT_ATTR_LINE_SPACING_TWICE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LINE_SPACING_TWICE)));
 
55372
  SWIG_Python_SetConstant(d, "OutOfRangeTextCoord",SWIG_From_int(static_cast< int >(wxOutOfRangeTextCoord)));
 
55373
  SWIG_Python_SetConstant(d, "InvalidTextCoord",SWIG_From_int(static_cast< int >(wxInvalidTextCoord)));
 
55374
  SWIG_Python_SetConstant(d, "TEXT_TYPE_ANY",SWIG_From_int(static_cast< int >(wxTEXT_TYPE_ANY)));
 
55375
  PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_UPDATED", PyInt_FromLong(wxEVT_COMMAND_TEXT_UPDATED));
 
55376
  PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_ENTER", PyInt_FromLong(wxEVT_COMMAND_TEXT_ENTER));
 
55377
  PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_URL", PyInt_FromLong(wxEVT_COMMAND_TEXT_URL));
 
55378
  PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_MAXLEN", PyInt_FromLong(wxEVT_COMMAND_TEXT_MAXLEN));
 
55379
  SWIG_addvarlink(SWIG_globals(),(char*)"ScrollBarNameStr",ScrollBarNameStr_get, ScrollBarNameStr_set);
 
55380
  SWIG_addvarlink(SWIG_globals(),(char*)"SPIN_BUTTON_NAME",SPIN_BUTTON_NAME_get, SPIN_BUTTON_NAME_set);
 
55381
  SWIG_addvarlink(SWIG_globals(),(char*)"SpinCtrlNameStr",SpinCtrlNameStr_get, SpinCtrlNameStr_set);
 
55382
  SWIG_Python_SetConstant(d, "SP_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSP_HORIZONTAL)));
 
55383
  SWIG_Python_SetConstant(d, "SP_VERTICAL",SWIG_From_int(static_cast< int >(wxSP_VERTICAL)));
 
55384
  SWIG_Python_SetConstant(d, "SP_ARROW_KEYS",SWIG_From_int(static_cast< int >(wxSP_ARROW_KEYS)));
 
55385
  SWIG_Python_SetConstant(d, "SP_WRAP",SWIG_From_int(static_cast< int >(wxSP_WRAP)));
 
55386
  PyDict_SetItemString(d, "wxEVT_SPIN_UP", PyInt_FromLong(wxEVT_SPIN_UP));
 
55387
  PyDict_SetItemString(d, "wxEVT_SPIN_DOWN", PyInt_FromLong(wxEVT_SPIN_DOWN));
 
55388
  PyDict_SetItemString(d, "wxEVT_SPIN", PyInt_FromLong(wxEVT_SPIN));
 
55389
  PyDict_SetItemString(d, "wxEVT_COMMAND_SPINCTRL_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SPINCTRL_UPDATED));
 
55390
  PyDict_SetItemString(d, "wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED));
 
55391
  SWIG_addvarlink(SWIG_globals(),(char*)"RadioBoxNameStr",RadioBoxNameStr_get, RadioBoxNameStr_set);
 
55392
  SWIG_addvarlink(SWIG_globals(),(char*)"RadioButtonNameStr",RadioButtonNameStr_get, RadioButtonNameStr_set);
 
55393
  SWIG_addvarlink(SWIG_globals(),(char*)"SliderNameStr",SliderNameStr_get, SliderNameStr_set);
 
55394
  SWIG_Python_SetConstant(d, "SL_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSL_HORIZONTAL)));
 
55395
  SWIG_Python_SetConstant(d, "SL_VERTICAL",SWIG_From_int(static_cast< int >(wxSL_VERTICAL)));
 
55396
  SWIG_Python_SetConstant(d, "SL_TICKS",SWIG_From_int(static_cast< int >(wxSL_TICKS)));
 
55397
  SWIG_Python_SetConstant(d, "SL_AUTOTICKS",SWIG_From_int(static_cast< int >(wxSL_AUTOTICKS)));
 
55398
  SWIG_Python_SetConstant(d, "SL_LEFT",SWIG_From_int(static_cast< int >(wxSL_LEFT)));
 
55399
  SWIG_Python_SetConstant(d, "SL_TOP",SWIG_From_int(static_cast< int >(wxSL_TOP)));
 
55400
  SWIG_Python_SetConstant(d, "SL_RIGHT",SWIG_From_int(static_cast< int >(wxSL_RIGHT)));
 
55401
  SWIG_Python_SetConstant(d, "SL_BOTTOM",SWIG_From_int(static_cast< int >(wxSL_BOTTOM)));
 
55402
  SWIG_Python_SetConstant(d, "SL_BOTH",SWIG_From_int(static_cast< int >(wxSL_BOTH)));
 
55403
  SWIG_Python_SetConstant(d, "SL_SELRANGE",SWIG_From_int(static_cast< int >(wxSL_SELRANGE)));
 
55404
  SWIG_Python_SetConstant(d, "SL_INVERSE",SWIG_From_int(static_cast< int >(wxSL_INVERSE)));
 
55405
  SWIG_Python_SetConstant(d, "SL_MIN_MAX_LABELS",SWIG_From_int(static_cast< int >(wxSL_MIN_MAX_LABELS)));
 
55406
  SWIG_Python_SetConstant(d, "SL_VALUE_LABEL",SWIG_From_int(static_cast< int >(wxSL_VALUE_LABEL)));
 
55407
  SWIG_Python_SetConstant(d, "SL_LABELS",SWIG_From_int(static_cast< int >(wxSL_LABELS)));
 
55408
  SWIG_addvarlink(SWIG_globals(),(char*)"ToggleButtonNameStr",ToggleButtonNameStr_get, ToggleButtonNameStr_set);
 
55409
  PyDict_SetItemString(d, "wxEVT_COMMAND_TOGGLEBUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOGGLEBUTTON_CLICKED));
 
55410
  SWIG_addvarlink(SWIG_globals(),(char*)"NotebookNameStr",NotebookNameStr_get, NotebookNameStr_set);
 
55411
  SWIG_Python_SetConstant(d, "NB_FIXEDWIDTH",SWIG_From_int(static_cast< int >(wxNB_FIXEDWIDTH)));
 
55412
  SWIG_Python_SetConstant(d, "NB_TOP",SWIG_From_int(static_cast< int >(wxNB_TOP)));
 
55413
  SWIG_Python_SetConstant(d, "NB_LEFT",SWIG_From_int(static_cast< int >(wxNB_LEFT)));
 
55414
  SWIG_Python_SetConstant(d, "NB_RIGHT",SWIG_From_int(static_cast< int >(wxNB_RIGHT)));
 
55415
  SWIG_Python_SetConstant(d, "NB_BOTTOM",SWIG_From_int(static_cast< int >(wxNB_BOTTOM)));
 
55416
  SWIG_Python_SetConstant(d, "NB_MULTILINE",SWIG_From_int(static_cast< int >(wxNB_MULTILINE)));
 
55417
  SWIG_Python_SetConstant(d, "NB_NOPAGETHEME",SWIG_From_int(static_cast< int >(wxNB_NOPAGETHEME)));
 
55418
  SWIG_Python_SetConstant(d, "NB_HITTEST_NOWHERE",SWIG_From_int(static_cast< int >(wxNB_HITTEST_NOWHERE)));
 
55419
  SWIG_Python_SetConstant(d, "NB_HITTEST_ONICON",SWIG_From_int(static_cast< int >(wxNB_HITTEST_ONICON)));
 
55420
  SWIG_Python_SetConstant(d, "NB_HITTEST_ONLABEL",SWIG_From_int(static_cast< int >(wxNB_HITTEST_ONLABEL)));
 
55421
  SWIG_Python_SetConstant(d, "NB_HITTEST_ONITEM",SWIG_From_int(static_cast< int >(wxNB_HITTEST_ONITEM)));
 
55422
  SWIG_Python_SetConstant(d, "NB_HITTEST_ONPAGE",SWIG_From_int(static_cast< int >(wxNB_HITTEST_ONPAGE)));
 
55423
  PyDict_SetItemString(d, "wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED));
 
55424
  PyDict_SetItemString(d, "wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING));
 
55425
  SWIG_Python_SetConstant(d, "LB_DEFAULT",SWIG_From_int(static_cast< int >(wxLB_DEFAULT)));
 
55426
  SWIG_Python_SetConstant(d, "LB_TOP",SWIG_From_int(static_cast< int >(wxLB_TOP)));
 
55427
  SWIG_Python_SetConstant(d, "LB_BOTTOM",SWIG_From_int(static_cast< int >(wxLB_BOTTOM)));
 
55428
  SWIG_Python_SetConstant(d, "LB_LEFT",SWIG_From_int(static_cast< int >(wxLB_LEFT)));
 
55429
  SWIG_Python_SetConstant(d, "LB_RIGHT",SWIG_From_int(static_cast< int >(wxLB_RIGHT)));
 
55430
  SWIG_Python_SetConstant(d, "LB_ALIGN_MASK",SWIG_From_int(static_cast< int >(wxLB_ALIGN_MASK)));
 
55431
  PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED));
 
55432
  PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING));
 
55433
  SWIG_Python_SetConstant(d, "CHB_DEFAULT",SWIG_From_int(static_cast< int >(wxCHB_DEFAULT)));
 
55434
  SWIG_Python_SetConstant(d, "CHB_TOP",SWIG_From_int(static_cast< int >(wxCHB_TOP)));
 
55435
  SWIG_Python_SetConstant(d, "CHB_BOTTOM",SWIG_From_int(static_cast< int >(wxCHB_BOTTOM)));
 
55436
  SWIG_Python_SetConstant(d, "CHB_LEFT",SWIG_From_int(static_cast< int >(wxCHB_LEFT)));
 
55437
  SWIG_Python_SetConstant(d, "CHB_RIGHT",SWIG_From_int(static_cast< int >(wxCHB_RIGHT)));
 
55438
  SWIG_Python_SetConstant(d, "CHB_ALIGN_MASK",SWIG_From_int(static_cast< int >(wxCHB_ALIGN_MASK)));
 
55439
  PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGED));
 
55440
  PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGING));
 
55441
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREEBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_TREEBOOK_PAGE_CHANGED));
 
55442
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREEBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_TREEBOOK_PAGE_CHANGING));
 
55443
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREEBOOK_NODE_COLLAPSED", PyInt_FromLong(wxEVT_COMMAND_TREEBOOK_NODE_COLLAPSED));
 
55444
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREEBOOK_NODE_EXPANDED", PyInt_FromLong(wxEVT_COMMAND_TREEBOOK_NODE_EXPANDED));
 
55445
  PyDict_SetItemString(d, "wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGED));
 
55446
  PyDict_SetItemString(d, "wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGING));
 
55447
  SWIG_Python_SetConstant(d, "TOOL_STYLE_BUTTON",SWIG_From_int(static_cast< int >(wxTOOL_STYLE_BUTTON)));
 
55448
  SWIG_Python_SetConstant(d, "TOOL_STYLE_SEPARATOR",SWIG_From_int(static_cast< int >(wxTOOL_STYLE_SEPARATOR)));
 
55449
  SWIG_Python_SetConstant(d, "TOOL_STYLE_CONTROL",SWIG_From_int(static_cast< int >(wxTOOL_STYLE_CONTROL)));
 
55450
  SWIG_Python_SetConstant(d, "TB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxTB_HORIZONTAL)));
 
55451
  SWIG_Python_SetConstant(d, "TB_VERTICAL",SWIG_From_int(static_cast< int >(wxTB_VERTICAL)));
 
55452
  SWIG_Python_SetConstant(d, "TB_TOP",SWIG_From_int(static_cast< int >(wxTB_TOP)));
 
55453
  SWIG_Python_SetConstant(d, "TB_LEFT",SWIG_From_int(static_cast< int >(wxTB_LEFT)));
 
55454
  SWIG_Python_SetConstant(d, "TB_BOTTOM",SWIG_From_int(static_cast< int >(wxTB_BOTTOM)));
 
55455
  SWIG_Python_SetConstant(d, "TB_RIGHT",SWIG_From_int(static_cast< int >(wxTB_RIGHT)));
 
55456
  SWIG_Python_SetConstant(d, "TB_3DBUTTONS",SWIG_From_int(static_cast< int >(wxTB_3DBUTTONS)));
 
55457
  SWIG_Python_SetConstant(d, "TB_FLAT",SWIG_From_int(static_cast< int >(wxTB_FLAT)));
 
55458
  SWIG_Python_SetConstant(d, "TB_DOCKABLE",SWIG_From_int(static_cast< int >(wxTB_DOCKABLE)));
 
55459
  SWIG_Python_SetConstant(d, "TB_NOICONS",SWIG_From_int(static_cast< int >(wxTB_NOICONS)));
 
55460
  SWIG_Python_SetConstant(d, "TB_TEXT",SWIG_From_int(static_cast< int >(wxTB_TEXT)));
 
55461
  SWIG_Python_SetConstant(d, "TB_NODIVIDER",SWIG_From_int(static_cast< int >(wxTB_NODIVIDER)));
 
55462
  SWIG_Python_SetConstant(d, "TB_NOALIGN",SWIG_From_int(static_cast< int >(wxTB_NOALIGN)));
 
55463
  SWIG_Python_SetConstant(d, "TB_HORZ_LAYOUT",SWIG_From_int(static_cast< int >(wxTB_HORZ_LAYOUT)));
 
55464
  SWIG_Python_SetConstant(d, "TB_HORZ_TEXT",SWIG_From_int(static_cast< int >(wxTB_HORZ_TEXT)));
 
55465
  SWIG_Python_SetConstant(d, "TB_NO_TOOLTIPS",SWIG_From_int(static_cast< int >(wxTB_NO_TOOLTIPS)));
 
55466
  SWIG_addvarlink(SWIG_globals(),(char*)"ListCtrlNameStr",ListCtrlNameStr_get, ListCtrlNameStr_set);
 
55467
  SWIG_Python_SetConstant(d, "LC_VRULES",SWIG_From_int(static_cast< int >(wxLC_VRULES)));
 
55468
  SWIG_Python_SetConstant(d, "LC_HRULES",SWIG_From_int(static_cast< int >(wxLC_HRULES)));
 
55469
  SWIG_Python_SetConstant(d, "LC_ICON",SWIG_From_int(static_cast< int >(wxLC_ICON)));
 
55470
  SWIG_Python_SetConstant(d, "LC_SMALL_ICON",SWIG_From_int(static_cast< int >(wxLC_SMALL_ICON)));
 
55471
  SWIG_Python_SetConstant(d, "LC_LIST",SWIG_From_int(static_cast< int >(wxLC_LIST)));
 
55472
  SWIG_Python_SetConstant(d, "LC_REPORT",SWIG_From_int(static_cast< int >(wxLC_REPORT)));
 
55473
  SWIG_Python_SetConstant(d, "LC_ALIGN_TOP",SWIG_From_int(static_cast< int >(wxLC_ALIGN_TOP)));
 
55474
  SWIG_Python_SetConstant(d, "LC_ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxLC_ALIGN_LEFT)));
 
55475
  SWIG_Python_SetConstant(d, "LC_AUTOARRANGE",SWIG_From_int(static_cast< int >(wxLC_AUTOARRANGE)));
 
55476
  SWIG_Python_SetConstant(d, "LC_VIRTUAL",SWIG_From_int(static_cast< int >(wxLC_VIRTUAL)));
 
55477
  SWIG_Python_SetConstant(d, "LC_EDIT_LABELS",SWIG_From_int(static_cast< int >(wxLC_EDIT_LABELS)));
 
55478
  SWIG_Python_SetConstant(d, "LC_NO_HEADER",SWIG_From_int(static_cast< int >(wxLC_NO_HEADER)));
 
55479
  SWIG_Python_SetConstant(d, "LC_NO_SORT_HEADER",SWIG_From_int(static_cast< int >(wxLC_NO_SORT_HEADER)));
 
55480
  SWIG_Python_SetConstant(d, "LC_SINGLE_SEL",SWIG_From_int(static_cast< int >(wxLC_SINGLE_SEL)));
 
55481
  SWIG_Python_SetConstant(d, "LC_SORT_ASCENDING",SWIG_From_int(static_cast< int >(wxLC_SORT_ASCENDING)));
 
55482
  SWIG_Python_SetConstant(d, "LC_SORT_DESCENDING",SWIG_From_int(static_cast< int >(wxLC_SORT_DESCENDING)));
 
55483
  SWIG_Python_SetConstant(d, "LC_MASK_TYPE",SWIG_From_int(static_cast< int >(wxLC_MASK_TYPE)));
 
55484
  SWIG_Python_SetConstant(d, "LC_MASK_ALIGN",SWIG_From_int(static_cast< int >(wxLC_MASK_ALIGN)));
 
55485
  SWIG_Python_SetConstant(d, "LC_MASK_SORT",SWIG_From_int(static_cast< int >(wxLC_MASK_SORT)));
 
55486
  SWIG_Python_SetConstant(d, "LIST_MASK_STATE",SWIG_From_int(static_cast< int >(wxLIST_MASK_STATE)));
 
55487
  SWIG_Python_SetConstant(d, "LIST_MASK_TEXT",SWIG_From_int(static_cast< int >(wxLIST_MASK_TEXT)));
 
55488
  SWIG_Python_SetConstant(d, "LIST_MASK_IMAGE",SWIG_From_int(static_cast< int >(wxLIST_MASK_IMAGE)));
 
55489
  SWIG_Python_SetConstant(d, "LIST_MASK_DATA",SWIG_From_int(static_cast< int >(wxLIST_MASK_DATA)));
 
55490
  SWIG_Python_SetConstant(d, "LIST_SET_ITEM",SWIG_From_int(static_cast< int >(wxLIST_SET_ITEM)));
 
55491
  SWIG_Python_SetConstant(d, "LIST_MASK_WIDTH",SWIG_From_int(static_cast< int >(wxLIST_MASK_WIDTH)));
 
55492
  SWIG_Python_SetConstant(d, "LIST_MASK_FORMAT",SWIG_From_int(static_cast< int >(wxLIST_MASK_FORMAT)));
 
55493
  SWIG_Python_SetConstant(d, "LIST_STATE_DONTCARE",SWIG_From_int(static_cast< int >(wxLIST_STATE_DONTCARE)));
 
55494
  SWIG_Python_SetConstant(d, "LIST_STATE_DROPHILITED",SWIG_From_int(static_cast< int >(wxLIST_STATE_DROPHILITED)));
 
55495
  SWIG_Python_SetConstant(d, "LIST_STATE_FOCUSED",SWIG_From_int(static_cast< int >(wxLIST_STATE_FOCUSED)));
 
55496
  SWIG_Python_SetConstant(d, "LIST_STATE_SELECTED",SWIG_From_int(static_cast< int >(wxLIST_STATE_SELECTED)));
 
55497
  SWIG_Python_SetConstant(d, "LIST_STATE_CUT",SWIG_From_int(static_cast< int >(wxLIST_STATE_CUT)));
 
55498
  SWIG_Python_SetConstant(d, "LIST_STATE_DISABLED",SWIG_From_int(static_cast< int >(wxLIST_STATE_DISABLED)));
 
55499
  SWIG_Python_SetConstant(d, "LIST_STATE_FILTERED",SWIG_From_int(static_cast< int >(wxLIST_STATE_FILTERED)));
 
55500
  SWIG_Python_SetConstant(d, "LIST_STATE_INUSE",SWIG_From_int(static_cast< int >(wxLIST_STATE_INUSE)));
 
55501
  SWIG_Python_SetConstant(d, "LIST_STATE_PICKED",SWIG_From_int(static_cast< int >(wxLIST_STATE_PICKED)));
 
55502
  SWIG_Python_SetConstant(d, "LIST_STATE_SOURCE",SWIG_From_int(static_cast< int >(wxLIST_STATE_SOURCE)));
 
55503
  SWIG_Python_SetConstant(d, "LIST_HITTEST_ABOVE",SWIG_From_int(static_cast< int >(wxLIST_HITTEST_ABOVE)));
 
55504
  SWIG_Python_SetConstant(d, "LIST_HITTEST_BELOW",SWIG_From_int(static_cast< int >(wxLIST_HITTEST_BELOW)));
 
55505
  SWIG_Python_SetConstant(d, "LIST_HITTEST_NOWHERE",SWIG_From_int(static_cast< int >(wxLIST_HITTEST_NOWHERE)));
 
55506
  SWIG_Python_SetConstant(d, "LIST_HITTEST_ONITEMICON",SWIG_From_int(static_cast< int >(wxLIST_HITTEST_ONITEMICON)));
 
55507
  SWIG_Python_SetConstant(d, "LIST_HITTEST_ONITEMLABEL",SWIG_From_int(static_cast< int >(wxLIST_HITTEST_ONITEMLABEL)));
 
55508
  SWIG_Python_SetConstant(d, "LIST_HITTEST_ONITEMRIGHT",SWIG_From_int(static_cast< int >(wxLIST_HITTEST_ONITEMRIGHT)));
 
55509
  SWIG_Python_SetConstant(d, "LIST_HITTEST_ONITEMSTATEICON",SWIG_From_int(static_cast< int >(wxLIST_HITTEST_ONITEMSTATEICON)));
 
55510
  SWIG_Python_SetConstant(d, "LIST_HITTEST_TOLEFT",SWIG_From_int(static_cast< int >(wxLIST_HITTEST_TOLEFT)));
 
55511
  SWIG_Python_SetConstant(d, "LIST_HITTEST_TORIGHT",SWIG_From_int(static_cast< int >(wxLIST_HITTEST_TORIGHT)));
 
55512
  SWIG_Python_SetConstant(d, "LIST_HITTEST_ONITEM",SWIG_From_int(static_cast< int >(wxLIST_HITTEST_ONITEM)));
 
55513
  SWIG_Python_SetConstant(d, "LIST_GETSUBITEMRECT_WHOLEITEM",SWIG_From_int(static_cast< int >(wxLIST_GETSUBITEMRECT_WHOLEITEM)));
 
55514
  SWIG_Python_SetConstant(d, "LIST_NEXT_ABOVE",SWIG_From_int(static_cast< int >(wxLIST_NEXT_ABOVE)));
 
55515
  SWIG_Python_SetConstant(d, "LIST_NEXT_ALL",SWIG_From_int(static_cast< int >(wxLIST_NEXT_ALL)));
 
55516
  SWIG_Python_SetConstant(d, "LIST_NEXT_BELOW",SWIG_From_int(static_cast< int >(wxLIST_NEXT_BELOW)));
 
55517
  SWIG_Python_SetConstant(d, "LIST_NEXT_LEFT",SWIG_From_int(static_cast< int >(wxLIST_NEXT_LEFT)));
 
55518
  SWIG_Python_SetConstant(d, "LIST_NEXT_RIGHT",SWIG_From_int(static_cast< int >(wxLIST_NEXT_RIGHT)));
 
55519
  SWIG_Python_SetConstant(d, "LIST_ALIGN_DEFAULT",SWIG_From_int(static_cast< int >(wxLIST_ALIGN_DEFAULT)));
 
55520
  SWIG_Python_SetConstant(d, "LIST_ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxLIST_ALIGN_LEFT)));
 
55521
  SWIG_Python_SetConstant(d, "LIST_ALIGN_TOP",SWIG_From_int(static_cast< int >(wxLIST_ALIGN_TOP)));
 
55522
  SWIG_Python_SetConstant(d, "LIST_ALIGN_SNAP_TO_GRID",SWIG_From_int(static_cast< int >(wxLIST_ALIGN_SNAP_TO_GRID)));
 
55523
  SWIG_Python_SetConstant(d, "LIST_FORMAT_LEFT",SWIG_From_int(static_cast< int >(wxLIST_FORMAT_LEFT)));
 
55524
  SWIG_Python_SetConstant(d, "LIST_FORMAT_RIGHT",SWIG_From_int(static_cast< int >(wxLIST_FORMAT_RIGHT)));
 
55525
  SWIG_Python_SetConstant(d, "LIST_FORMAT_CENTRE",SWIG_From_int(static_cast< int >(wxLIST_FORMAT_CENTRE)));
 
55526
  SWIG_Python_SetConstant(d, "LIST_FORMAT_CENTER",SWIG_From_int(static_cast< int >(wxLIST_FORMAT_CENTER)));
 
55527
  SWIG_Python_SetConstant(d, "LIST_AUTOSIZE",SWIG_From_int(static_cast< int >(wxLIST_AUTOSIZE)));
 
55528
  SWIG_Python_SetConstant(d, "LIST_AUTOSIZE_USEHEADER",SWIG_From_int(static_cast< int >(wxLIST_AUTOSIZE_USEHEADER)));
 
55529
  SWIG_Python_SetConstant(d, "LIST_RECT_BOUNDS",SWIG_From_int(static_cast< int >(wxLIST_RECT_BOUNDS)));
 
55530
  SWIG_Python_SetConstant(d, "LIST_RECT_ICON",SWIG_From_int(static_cast< int >(wxLIST_RECT_ICON)));
 
55531
  SWIG_Python_SetConstant(d, "LIST_RECT_LABEL",SWIG_From_int(static_cast< int >(wxLIST_RECT_LABEL)));
 
55532
  SWIG_Python_SetConstant(d, "LIST_FIND_UP",SWIG_From_int(static_cast< int >(wxLIST_FIND_UP)));
 
55533
  SWIG_Python_SetConstant(d, "LIST_FIND_DOWN",SWIG_From_int(static_cast< int >(wxLIST_FIND_DOWN)));
 
55534
  SWIG_Python_SetConstant(d, "LIST_FIND_LEFT",SWIG_From_int(static_cast< int >(wxLIST_FIND_LEFT)));
 
55535
  SWIG_Python_SetConstant(d, "LIST_FIND_RIGHT",SWIG_From_int(static_cast< int >(wxLIST_FIND_RIGHT)));
 
55536
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_DRAG));
 
55537
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_RDRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_RDRAG));
 
55538
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT));
 
55539
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_END_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_LIST_END_LABEL_EDIT));
 
55540
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_DELETE_ITEM", PyInt_FromLong(wxEVT_COMMAND_LIST_DELETE_ITEM));
 
55541
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS", PyInt_FromLong(wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS));
 
55542
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_SELECTED));
 
55543
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_DESELECTED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_DESELECTED));
 
55544
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_KEY_DOWN", PyInt_FromLong(wxEVT_COMMAND_LIST_KEY_DOWN));
 
55545
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_INSERT_ITEM", PyInt_FromLong(wxEVT_COMMAND_LIST_INSERT_ITEM));
 
55546
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_CLICK));
 
55547
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK));
 
55548
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK));
 
55549
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_ACTIVATED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_ACTIVATED));
 
55550
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_CACHE_HINT", PyInt_FromLong(wxEVT_COMMAND_LIST_CACHE_HINT));
 
55551
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_RIGHT_CLICK));
 
55552
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG));
 
55553
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_DRAGGING", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_DRAGGING));
 
55554
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_COL_END_DRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_COL_END_DRAG));
 
55555
  PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_ITEM_FOCUSED", PyInt_FromLong(wxEVT_COMMAND_LIST_ITEM_FOCUSED));
 
55556
  
 
55557
  // Map renamed classes back to their common name for OOR
 
55558
  wxPyPtrTypeMap_Add("wxListCtrl", "wxPyListCtrl");
 
55559
  
 
55560
  SWIG_addvarlink(SWIG_globals(),(char*)"TreeCtrlNameStr",TreeCtrlNameStr_get, TreeCtrlNameStr_set);
 
55561
  SWIG_Python_SetConstant(d, "TR_NO_BUTTONS",SWIG_From_int(static_cast< int >(wxTR_NO_BUTTONS)));
 
55562
  SWIG_Python_SetConstant(d, "TR_HAS_BUTTONS",SWIG_From_int(static_cast< int >(wxTR_HAS_BUTTONS)));
 
55563
  SWIG_Python_SetConstant(d, "TR_NO_LINES",SWIG_From_int(static_cast< int >(wxTR_NO_LINES)));
 
55564
  SWIG_Python_SetConstant(d, "TR_LINES_AT_ROOT",SWIG_From_int(static_cast< int >(wxTR_LINES_AT_ROOT)));
 
55565
  SWIG_Python_SetConstant(d, "TR_SINGLE",SWIG_From_int(static_cast< int >(wxTR_SINGLE)));
 
55566
  SWIG_Python_SetConstant(d, "TR_MULTIPLE",SWIG_From_int(static_cast< int >(wxTR_MULTIPLE)));
 
55567
  SWIG_Python_SetConstant(d, "TR_EXTENDED",SWIG_From_int(static_cast< int >(wxTR_EXTENDED)));
 
55568
  SWIG_Python_SetConstant(d, "TR_HAS_VARIABLE_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxTR_HAS_VARIABLE_ROW_HEIGHT)));
 
55569
  SWIG_Python_SetConstant(d, "TR_EDIT_LABELS",SWIG_From_int(static_cast< int >(wxTR_EDIT_LABELS)));
 
55570
  SWIG_Python_SetConstant(d, "TR_HIDE_ROOT",SWIG_From_int(static_cast< int >(wxTR_HIDE_ROOT)));
 
55571
  SWIG_Python_SetConstant(d, "TR_ROW_LINES",SWIG_From_int(static_cast< int >(wxTR_ROW_LINES)));
 
55572
  SWIG_Python_SetConstant(d, "TR_FULL_ROW_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxTR_FULL_ROW_HIGHLIGHT)));
 
55573
  SWIG_Python_SetConstant(d, "TR_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxTR_DEFAULT_STYLE)));
 
55574
  SWIG_Python_SetConstant(d, "TR_TWIST_BUTTONS",SWIG_From_int(static_cast< int >(wxTR_TWIST_BUTTONS)));
 
55575
  SWIG_Python_SetConstant(d, "TreeItemIcon_Normal",SWIG_From_int(static_cast< int >(wxTreeItemIcon_Normal)));
 
55576
  SWIG_Python_SetConstant(d, "TreeItemIcon_Selected",SWIG_From_int(static_cast< int >(wxTreeItemIcon_Selected)));
 
55577
  SWIG_Python_SetConstant(d, "TreeItemIcon_Expanded",SWIG_From_int(static_cast< int >(wxTreeItemIcon_Expanded)));
 
55578
  SWIG_Python_SetConstant(d, "TreeItemIcon_SelectedExpanded",SWIG_From_int(static_cast< int >(wxTreeItemIcon_SelectedExpanded)));
 
55579
  SWIG_Python_SetConstant(d, "TreeItemIcon_Max",SWIG_From_int(static_cast< int >(wxTreeItemIcon_Max)));
 
55580
  SWIG_Python_SetConstant(d, "TREE_ITEMSTATE_NONE",SWIG_From_int(static_cast< int >(wxTREE_ITEMSTATE_NONE)));
 
55581
  SWIG_Python_SetConstant(d, "TREE_ITEMSTATE_NEXT",SWIG_From_int(static_cast< int >(wxTREE_ITEMSTATE_NEXT)));
 
55582
  SWIG_Python_SetConstant(d, "TREE_ITEMSTATE_PREV",SWIG_From_int(static_cast< int >(wxTREE_ITEMSTATE_PREV)));
 
55583
  SWIG_Python_SetConstant(d, "TREE_HITTEST_ABOVE",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_ABOVE)));
 
55584
  SWIG_Python_SetConstant(d, "TREE_HITTEST_BELOW",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_BELOW)));
 
55585
  SWIG_Python_SetConstant(d, "TREE_HITTEST_NOWHERE",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_NOWHERE)));
 
55586
  SWIG_Python_SetConstant(d, "TREE_HITTEST_ONITEMBUTTON",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_ONITEMBUTTON)));
 
55587
  SWIG_Python_SetConstant(d, "TREE_HITTEST_ONITEMICON",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_ONITEMICON)));
 
55588
  SWIG_Python_SetConstant(d, "TREE_HITTEST_ONITEMINDENT",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_ONITEMINDENT)));
 
55589
  SWIG_Python_SetConstant(d, "TREE_HITTEST_ONITEMLABEL",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_ONITEMLABEL)));
 
55590
  SWIG_Python_SetConstant(d, "TREE_HITTEST_ONITEMRIGHT",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_ONITEMRIGHT)));
 
55591
  SWIG_Python_SetConstant(d, "TREE_HITTEST_ONITEMSTATEICON",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_ONITEMSTATEICON)));
 
55592
  SWIG_Python_SetConstant(d, "TREE_HITTEST_TOLEFT",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_TOLEFT)));
 
55593
  SWIG_Python_SetConstant(d, "TREE_HITTEST_TORIGHT",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_TORIGHT)));
 
55594
  SWIG_Python_SetConstant(d, "TREE_HITTEST_ONITEMUPPERPART",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_ONITEMUPPERPART)));
 
55595
  SWIG_Python_SetConstant(d, "TREE_HITTEST_ONITEMLOWERPART",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_ONITEMLOWERPART)));
 
55596
  SWIG_Python_SetConstant(d, "TREE_HITTEST_ONITEM",SWIG_From_int(static_cast< int >(wxTREE_HITTEST_ONITEM)));
 
55597
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_DRAG));
 
55598
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_RDRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_RDRAG));
 
55599
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT));
 
55600
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_END_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_TREE_END_LABEL_EDIT));
 
55601
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_DELETE_ITEM", PyInt_FromLong(wxEVT_COMMAND_TREE_DELETE_ITEM));
 
55602
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_GET_INFO", PyInt_FromLong(wxEVT_COMMAND_TREE_GET_INFO));
 
55603
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_SET_INFO", PyInt_FromLong(wxEVT_COMMAND_TREE_SET_INFO));
 
55604
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_EXPANDED", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_EXPANDED));
 
55605
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_EXPANDING", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_EXPANDING));
 
55606
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_COLLAPSED", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_COLLAPSED));
 
55607
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_COLLAPSING", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_COLLAPSING));
 
55608
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_SEL_CHANGED", PyInt_FromLong(wxEVT_COMMAND_TREE_SEL_CHANGED));
 
55609
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_SEL_CHANGING", PyInt_FromLong(wxEVT_COMMAND_TREE_SEL_CHANGING));
 
55610
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_KEY_DOWN", PyInt_FromLong(wxEVT_COMMAND_TREE_KEY_DOWN));
 
55611
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_ACTIVATED", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_ACTIVATED));
 
55612
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK));
 
55613
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK));
 
55614
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_END_DRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_END_DRAG));
 
55615
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK", PyInt_FromLong(wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK));
 
55616
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP));
 
55617
  PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_ITEM_MENU", PyInt_FromLong(wxEVT_COMMAND_TREE_ITEM_MENU));
 
55618
  SWIG_addvarlink(SWIG_globals(),(char*)"NullTreeItemId",NullTreeItemId_get, NullTreeItemId_set);
 
55619
  
 
55620
  // Map renamed classes back to their common name for OOR
 
55621
  wxPyPtrTypeMap_Add("wxTreeItemData", "wxPyTreeItemData");
 
55622
  wxPyPtrTypeMap_Add("wxTreeCtrl", "wxPyTreeCtrl");
 
55623
  
 
55624
  SWIG_addvarlink(SWIG_globals(),(char*)"DirDialogDefaultFolderStr",DirDialogDefaultFolderStr_get, DirDialogDefaultFolderStr_set);
 
55625
  SWIG_Python_SetConstant(d, "DIRCTRL_DIR_ONLY",SWIG_From_int(static_cast< int >(wxDIRCTRL_DIR_ONLY)));
 
55626
  SWIG_Python_SetConstant(d, "DIRCTRL_SELECT_FIRST",SWIG_From_int(static_cast< int >(wxDIRCTRL_SELECT_FIRST)));
 
55627
  SWIG_Python_SetConstant(d, "DIRCTRL_SHOW_FILTERS",SWIG_From_int(static_cast< int >(wxDIRCTRL_SHOW_FILTERS)));
 
55628
  SWIG_Python_SetConstant(d, "DIRCTRL_3D_INTERNAL",SWIG_From_int(static_cast< int >(wxDIRCTRL_3D_INTERNAL)));
 
55629
  SWIG_Python_SetConstant(d, "DIRCTRL_EDIT_LABELS",SWIG_From_int(static_cast< int >(wxDIRCTRL_EDIT_LABELS)));
 
55630
  SWIG_Python_SetConstant(d, "DIRCTRL_MULTIPLE",SWIG_From_int(static_cast< int >(wxDIRCTRL_MULTIPLE)));
 
55631
  PyDict_SetItemString(d, "wxEVT_HELP", PyInt_FromLong(wxEVT_HELP));
 
55632
  PyDict_SetItemString(d, "wxEVT_DETAILED_HELP", PyInt_FromLong(wxEVT_DETAILED_HELP));
 
55633
  SWIG_Python_SetConstant(d, "HelpEvent_Origin_Unknown",SWIG_From_int(static_cast< int >(wxHelpEvent::Origin_Unknown)));
 
55634
  SWIG_Python_SetConstant(d, "HelpEvent_Origin_Keyboard",SWIG_From_int(static_cast< int >(wxHelpEvent::Origin_Keyboard)));
 
55635
  SWIG_Python_SetConstant(d, "HelpEvent_Origin_HelpButton",SWIG_From_int(static_cast< int >(wxHelpEvent::Origin_HelpButton)));
 
55636
  
 
55637
  wxPyPtrTypeMap_Add("wxDragImage", "wxGenericDragImage");
 
55638
  
 
55639
  SWIG_addvarlink(SWIG_globals(),(char*)"DatePickerCtrlNameStr",DatePickerCtrlNameStr_get, DatePickerCtrlNameStr_set);
 
55640
  SWIG_Python_SetConstant(d, "DP_DEFAULT",SWIG_From_int(static_cast< int >(wxDP_DEFAULT)));
 
55641
  SWIG_Python_SetConstant(d, "DP_SPIN",SWIG_From_int(static_cast< int >(wxDP_SPIN)));
 
55642
  SWIG_Python_SetConstant(d, "DP_DROPDOWN",SWIG_From_int(static_cast< int >(wxDP_DROPDOWN)));
 
55643
  SWIG_Python_SetConstant(d, "DP_SHOWCENTURY",SWIG_From_int(static_cast< int >(wxDP_SHOWCENTURY)));
 
55644
  SWIG_Python_SetConstant(d, "DP_ALLOWNONE",SWIG_From_int(static_cast< int >(wxDP_ALLOWNONE)));
 
55645
  SWIG_addvarlink(SWIG_globals(),(char*)"HyperlinkCtrlNameStr",HyperlinkCtrlNameStr_get, HyperlinkCtrlNameStr_set);
 
55646
  SWIG_Python_SetConstant(d, "HL_CONTEXTMENU",SWIG_From_int(static_cast< int >(wxHL_CONTEXTMENU)));
 
55647
  SWIG_Python_SetConstant(d, "HL_ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxHL_ALIGN_LEFT)));
 
55648
  SWIG_Python_SetConstant(d, "HL_ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxHL_ALIGN_RIGHT)));
 
55649
  SWIG_Python_SetConstant(d, "HL_ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxHL_ALIGN_CENTRE)));
 
55650
  SWIG_Python_SetConstant(d, "HL_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxHL_DEFAULT_STYLE)));
 
55651
  PyDict_SetItemString(d, "wxEVT_COMMAND_HYPERLINK", PyInt_FromLong(wxEVT_COMMAND_HYPERLINK));
 
55652
  SWIG_Python_SetConstant(d, "PB_USE_TEXTCTRL",SWIG_From_int(static_cast< int >(wxPB_USE_TEXTCTRL)));
 
55653
  SWIG_addvarlink(SWIG_globals(),(char*)"ColourPickerCtrlNameStr",ColourPickerCtrlNameStr_get, ColourPickerCtrlNameStr_set);
 
55654
  SWIG_Python_SetConstant(d, "CLRP_SHOW_LABEL",SWIG_From_int(static_cast< int >(wxCLRP_SHOW_LABEL)));
 
55655
  SWIG_Python_SetConstant(d, "CLRP_USE_TEXTCTRL",SWIG_From_int(static_cast< int >(wxCLRP_USE_TEXTCTRL)));
 
55656
  SWIG_Python_SetConstant(d, "CLRP_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxCLRP_DEFAULT_STYLE)));
 
55657
  PyDict_SetItemString(d, "wxEVT_COMMAND_COLOURPICKER_CHANGED", PyInt_FromLong(wxEVT_COMMAND_COLOURPICKER_CHANGED));
 
55658
  SWIG_addvarlink(SWIG_globals(),(char*)"FilePickerCtrlNameStr",FilePickerCtrlNameStr_get, FilePickerCtrlNameStr_set);
 
55659
  SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
 
55660
  SWIG_addvarlink(SWIG_globals(),(char*)"DirPickerCtrlNameStr",DirPickerCtrlNameStr_get, DirPickerCtrlNameStr_set);
 
55661
  SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
 
55662
  SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
 
55663
  SWIG_Python_SetConstant(d, "FLP_OPEN",SWIG_From_int(static_cast< int >(wxFLP_OPEN)));
 
55664
  SWIG_Python_SetConstant(d, "FLP_SAVE",SWIG_From_int(static_cast< int >(wxFLP_SAVE)));
 
55665
  SWIG_Python_SetConstant(d, "FLP_OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxFLP_OVERWRITE_PROMPT)));
 
55666
  SWIG_Python_SetConstant(d, "FLP_FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFLP_FILE_MUST_EXIST)));
 
55667
  SWIG_Python_SetConstant(d, "FLP_CHANGE_DIR",SWIG_From_int(static_cast< int >(wxFLP_CHANGE_DIR)));
 
55668
  SWIG_Python_SetConstant(d, "FLP_SMALL",SWIG_From_int(static_cast< int >(wxFLP_SMALL)));
 
55669
  SWIG_Python_SetConstant(d, "DIRP_DIR_MUST_EXIST",SWIG_From_int(static_cast< int >(wxDIRP_DIR_MUST_EXIST)));
 
55670
  SWIG_Python_SetConstant(d, "DIRP_CHANGE_DIR",SWIG_From_int(static_cast< int >(wxDIRP_CHANGE_DIR)));
 
55671
  SWIG_Python_SetConstant(d, "DIRP_SMALL",SWIG_From_int(static_cast< int >(wxDIRP_SMALL)));
 
55672
  SWIG_Python_SetConstant(d, "FLP_USE_TEXTCTRL",SWIG_From_int(static_cast< int >(wxFLP_USE_TEXTCTRL)));
 
55673
  SWIG_Python_SetConstant(d, "FLP_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxFLP_DEFAULT_STYLE)));
 
55674
  SWIG_Python_SetConstant(d, "DIRP_USE_TEXTCTRL",SWIG_From_int(static_cast< int >(wxDIRP_USE_TEXTCTRL)));
 
55675
  SWIG_Python_SetConstant(d, "DIRP_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDIRP_DEFAULT_STYLE)));
 
55676
  PyDict_SetItemString(d, "wxEVT_COMMAND_FILEPICKER_CHANGED", PyInt_FromLong(wxEVT_COMMAND_FILEPICKER_CHANGED));
 
55677
  PyDict_SetItemString(d, "wxEVT_COMMAND_DIRPICKER_CHANGED", PyInt_FromLong(wxEVT_COMMAND_DIRPICKER_CHANGED));
 
55678
  SWIG_addvarlink(SWIG_globals(),(char*)"FontPickerCtrlNameStr",FontPickerCtrlNameStr_get, FontPickerCtrlNameStr_set);
 
55679
  SWIG_Python_SetConstant(d, "FNTP_FONTDESC_AS_LABEL",SWIG_From_int(static_cast< int >(wxFNTP_FONTDESC_AS_LABEL)));
 
55680
  SWIG_Python_SetConstant(d, "FNTP_USEFONT_FOR_LABEL",SWIG_From_int(static_cast< int >(wxFNTP_USEFONT_FOR_LABEL)));
 
55681
  SWIG_Python_SetConstant(d, "FNTP_USE_TEXTCTRL",SWIG_From_int(static_cast< int >(wxFNTP_USE_TEXTCTRL)));
 
55682
  SWIG_Python_SetConstant(d, "FNTP_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxFNTP_DEFAULT_STYLE)));
 
55683
  PyDict_SetItemString(d, "wxEVT_COMMAND_FONTPICKER_CHANGED", PyInt_FromLong(wxEVT_COMMAND_FONTPICKER_CHANGED));
 
55684
  SWIG_addvarlink(SWIG_globals(),(char*)"CollapsiblePaneNameStr",CollapsiblePaneNameStr_get, CollapsiblePaneNameStr_set);
 
55685
  SWIG_Python_SetConstant(d, "CP_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxCP_DEFAULT_STYLE)));
 
55686
  SWIG_Python_SetConstant(d, "CP_NO_TLW_RESIZE",SWIG_From_int(static_cast< int >(wxCP_NO_TLW_RESIZE)));
 
55687
  PyDict_SetItemString(d, "wxEVT_COMMAND_COLLPANE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_COLLPANE_CHANGED));
 
55688
  SWIG_addvarlink(SWIG_globals(),(char*)"SearchCtrlNameStr",SearchCtrlNameStr_get, SearchCtrlNameStr_set);
 
55689
  PyDict_SetItemString(d, "wxEVT_COMMAND_SEARCHCTRL_CANCEL_BTN", PyInt_FromLong(wxEVT_COMMAND_SEARCHCTRL_CANCEL_BTN));
 
55690
  PyDict_SetItemString(d, "wxEVT_COMMAND_SEARCHCTRL_SEARCH_BTN", PyInt_FromLong(wxEVT_COMMAND_SEARCHCTRL_SEARCH_BTN));
 
55691
  SWIG_addvarlink(SWIG_globals(),(char*)"FileCtrlNameStr",FileCtrlNameStr_get, FileCtrlNameStr_set);
 
55692
  SWIG_Python_SetConstant(d, "FC_OPEN",SWIG_From_int(static_cast< int >(wxFC_OPEN)));
 
55693
  SWIG_Python_SetConstant(d, "FC_SAVE",SWIG_From_int(static_cast< int >(wxFC_SAVE)));
 
55694
  SWIG_Python_SetConstant(d, "FC_MULTIPLE",SWIG_From_int(static_cast< int >(wxFC_MULTIPLE)));
 
55695
  SWIG_Python_SetConstant(d, "FC_NOSHOWHIDDEN",SWIG_From_int(static_cast< int >(wxFC_NOSHOWHIDDEN)));
 
55696
  SWIG_Python_SetConstant(d, "FC_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxFC_DEFAULT_STYLE)));
 
55697
  PyDict_SetItemString(d, "wxEVT_FILECTRL_SELECTIONCHANGED", PyInt_FromLong(wxEVT_FILECTRL_SELECTIONCHANGED));
 
55698
  PyDict_SetItemString(d, "wxEVT_FILECTRL_FILEACTIVATED", PyInt_FromLong(wxEVT_FILECTRL_FILEACTIVATED));
 
55699
  PyDict_SetItemString(d, "wxEVT_FILECTRL_FOLDERCHANGED", PyInt_FromLong(wxEVT_FILECTRL_FOLDERCHANGED));
 
55700
  PyDict_SetItemString(d, "wxEVT_FILECTRL_FILTERCHANGED", PyInt_FromLong(wxEVT_FILECTRL_FILTERCHANGED));
 
55701
}
 
55702