← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to wxPython/contrib/glcanvas/gtk/glcanvas_wrap.cpp

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
wxPython/contrib/glcanvas/gtk/glcanvas_wrap.cpp
 
1
/* ----------------------------------------------------------------------------
 
2
 * This file was automatically generated by SWIG (http://www.swig.org).
 
3
 * Version 1.3.27
 
4
 * 
 
5
 * This file is not intended to be easily readable and contains a number of 
 
6
 * coding conventions designed to improve portability and efficiency. Do not make
 
7
 * changes to this file unless you know what you are doing--modify the SWIG 
 
8
 * interface file instead. 
 
9
 * ----------------------------------------------------------------------------- */
 
10
 
 
11
#define SWIGPYTHON
 
12
 
 
13
#ifdef __cplusplus
 
14
template<class T> class SwigValueWrapper {
 
15
    T *tt;
 
16
public:
 
17
    SwigValueWrapper() : tt(0) { }
 
18
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
 
19
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
 
20
    ~SwigValueWrapper() { delete tt; } 
 
21
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
 
22
    operator T&() const { return *tt; }
 
23
    T *operator&() { return tt; }
 
24
private:
 
25
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
 
26
};
 
27
#endif
 
28
 
 
29
/***********************************************************************
 
30
 *
 
31
 *  This section contains generic SWIG labels for method/variable
 
32
 *  declarations/attributes, and other compiler dependent labels.
 
33
 *
 
34
 ************************************************************************/
 
35
 
 
36
/* template workaround for compilers that cannot correctly implement the C++ standard */
 
37
#ifndef SWIGTEMPLATEDISAMBIGUATOR
 
38
#  if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
 
39
#    define SWIGTEMPLATEDISAMBIGUATOR template
 
40
#  else
 
41
#    define SWIGTEMPLATEDISAMBIGUATOR 
 
42
#  endif
 
43
#endif
 
44
 
 
45
/* inline attribute */
 
46
#ifndef SWIGINLINE
 
47
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
 
48
#   define SWIGINLINE inline
 
49
# else
 
50
#   define SWIGINLINE
 
51
# endif
 
52
#endif
 
53
 
 
54
/* attribute recognised by some compilers to avoid 'unused' warnings */
 
55
#ifndef SWIGUNUSED
 
56
# if defined(__GNUC__) || defined(__ICC)
 
57
#   define SWIGUNUSED __attribute__ ((unused)) 
 
58
# else
 
59
#   define SWIGUNUSED 
 
60
# endif
 
61
#endif
 
62
 
 
63
/* internal SWIG method */
 
64
#ifndef SWIGINTERN
 
65
# define SWIGINTERN static SWIGUNUSED
 
66
#endif
 
67
 
 
68
/* internal inline SWIG method */
 
69
#ifndef SWIGINTERNINLINE
 
70
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 
71
#endif
 
72
 
 
73
/* exporting methods for Windows DLLs */
 
74
#ifndef SWIGEXPORT
 
75
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 
76
#   if defined(STATIC_LINKED)
 
77
#     define SWIGEXPORT
 
78
#   else
 
79
#     define SWIGEXPORT __declspec(dllexport)
 
80
#   endif
 
81
# else
 
82
#   define SWIGEXPORT
 
83
# endif
 
84
#endif
 
85
 
 
86
/* calling conventions for Windows */
 
87
#ifndef SWIGSTDCALL
 
88
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 
89
#   define SWIGSTDCALL __stdcall
 
90
# else
 
91
#   define SWIGSTDCALL
 
92
# endif 
 
93
#endif
 
94
 
 
95
 
 
96
 
 
97
#include <Python.h>
 
98
 
 
99
/***********************************************************************
 
100
 * swigrun.swg
 
101
 *
 
102
 *     This file contains generic CAPI SWIG runtime support for pointer
 
103
 *     type checking.
 
104
 *
 
105
 ************************************************************************/
 
106
 
 
107
/* This should only be incremented when either the layout of swig_type_info changes,
 
108
   or for whatever reason, the runtime changes incompatibly */
 
109
#define SWIG_RUNTIME_VERSION "2"
 
110
 
 
111
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 
112
#ifdef SWIG_TYPE_TABLE
 
113
# define SWIG_QUOTE_STRING(x) #x
 
114
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 
115
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 
116
#else
 
117
# define SWIG_TYPE_TABLE_NAME
 
118
#endif
 
119
 
 
120
/*
 
121
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 
122
  creating a static or dynamic library from the swig runtime code.
 
123
  In 99.9% of the cases, swig just needs to declare them as 'static'.
 
124
  
 
125
  But only do this if is strictly necessary, ie, if you have problems
 
126
  with your compiler or so.
 
127
*/
 
128
 
 
129
#ifndef SWIGRUNTIME
 
130
# define SWIGRUNTIME SWIGINTERN
 
131
#endif
 
132
 
 
133
#ifndef SWIGRUNTIMEINLINE
 
134
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 
135
#endif
 
136
 
 
137
#include <string.h>
 
138
 
 
139
#ifdef __cplusplus
 
140
extern "C" {
 
141
#endif
 
142
 
 
143
typedef void *(*swig_converter_func)(void *);
 
144
typedef struct swig_type_info *(*swig_dycast_func)(void **);
 
145
 
 
146
/* Structure to store inforomation on one type */
 
147
typedef struct swig_type_info {
 
148
  const char             *name;                 /* mangled name of this type */
 
149
  const char             *str;                  /* human readable name of this type */
 
150
  swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 
151
  struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 
152
  void                   *clientdata;           /* language specific type data */
 
153
} swig_type_info;
 
154
 
 
155
/* Structure to store a type and conversion function used for casting */
 
156
typedef struct swig_cast_info {
 
157
  swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 
158
  swig_converter_func     converter;            /* function to cast the void pointers */
 
159
  struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 
160
  struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 
161
} swig_cast_info;
 
162
 
 
163
/* Structure used to store module information
 
164
 * Each module generates one structure like this, and the runtime collects
 
165
 * all of these structures and stores them in a circularly linked list.*/
 
166
typedef struct swig_module_info {
 
167
  swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 
168
  size_t                 size;                  /* Number of types in this module */
 
169
  struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 
170
  swig_type_info         **type_initial;        /* Array of initially generated type structures */
 
171
  swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 
172
  void                    *clientdata;          /* Language specific module data */
 
173
} swig_module_info;
 
174
 
 
175
 
 
176
/* 
 
177
  Compare two type names skipping the space characters, therefore
 
178
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 
179
 
 
180
  Return 0 when the two name types are equivalent, as in
 
181
  strncmp, but skipping ' '.
 
182
*/
 
183
SWIGRUNTIME int
 
184
SWIG_TypeNameComp(const char *f1, const char *l1,
 
185
                  const char *f2, const char *l2) {
 
186
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 
187
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
 
188
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
 
189
    if (*f1 != *f2) return (int)(*f1 - *f2);
 
190
  }
 
191
  return (l1 - f1) - (l2 - f2);
 
192
}
 
193
 
 
194
/*
 
195
  Check type equivalence in a name list like <name1>|<name2>|...
 
196
  Return 0 if not equal, 1 if equal
 
197
*/
 
198
SWIGRUNTIME int
 
199
SWIG_TypeEquiv(const char *nb, const char *tb) {
 
200
  int equiv = 0;
 
201
  const char* te = tb + strlen(tb);
 
202
  const char* ne = nb;
 
203
  while (!equiv && *ne) {
 
204
    for (nb = ne; *ne; ++ne) {
 
205
      if (*ne == '|') break;
 
206
    }
 
207
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 
208
    if (*ne) ++ne;
 
209
  }
 
210
  return equiv;
 
211
}
 
212
 
 
213
/*
 
214
  Check type equivalence in a name list like <name1>|<name2>|...
 
215
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 
216
*/
 
217
SWIGRUNTIME int
 
218
SWIG_TypeCompare(const char *nb, const char *tb) {
 
219
  int equiv = 0;
 
220
  const char* te = tb + strlen(tb);
 
221
  const char* ne = nb;
 
222
  while (!equiv && *ne) {
 
223
    for (nb = ne; *ne; ++ne) {
 
224
      if (*ne == '|') break;
 
225
    }
 
226
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 
227
    if (*ne) ++ne;
 
228
  }
 
229
  return equiv;
 
230
}
 
231
 
 
232
 
 
233
/* think of this as a c++ template<> or a scheme macro */
 
234
#define SWIG_TypeCheck_Template(comparison, ty)         \
 
235
  if (ty) {                                             \
 
236
    swig_cast_info *iter = ty->cast;                    \
 
237
    while (iter) {                                      \
 
238
      if (comparison) {                                 \
 
239
        if (iter == ty->cast) return iter;              \
 
240
        /* Move iter to the top of the linked list */   \
 
241
        iter->prev->next = iter->next;                  \
 
242
        if (iter->next)                                 \
 
243
          iter->next->prev = iter->prev;                \
 
244
        iter->next = ty->cast;                          \
 
245
        iter->prev = 0;                                 \
 
246
        if (ty->cast) ty->cast->prev = iter;            \
 
247
        ty->cast = iter;                                \
 
248
        return iter;                                    \
 
249
      }                                                 \
 
250
      iter = iter->next;                                \
 
251
    }                                                   \
 
252
  }                                                     \
 
253
  return 0
 
254
 
 
255
/*
 
256
  Check the typename
 
257
*/
 
258
SWIGRUNTIME swig_cast_info *
 
259
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 
260
  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 
261
}
 
262
 
 
263
/* Same as previous function, except strcmp is replaced with a pointer comparison */
 
264
SWIGRUNTIME swig_cast_info *
 
265
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
 
266
  SWIG_TypeCheck_Template(iter->type == from, into);
 
267
}
 
268
 
 
269
/*
 
270
  Cast a pointer up an inheritance hierarchy
 
271
*/
 
272
SWIGRUNTIMEINLINE void *
 
273
SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
 
274
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
 
275
}
 
276
 
 
277
/* 
 
278
   Dynamic pointer casting. Down an inheritance hierarchy
 
279
*/
 
280
SWIGRUNTIME swig_type_info *
 
281
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 
282
  swig_type_info *lastty = ty;
 
283
  if (!ty || !ty->dcast) return ty;
 
284
  while (ty && (ty->dcast)) {
 
285
    ty = (*ty->dcast)(ptr);
 
286
    if (ty) lastty = ty;
 
287
  }
 
288
  return lastty;
 
289
}
 
290
 
 
291
/*
 
292
  Return the name associated with this type
 
293
*/
 
294
SWIGRUNTIMEINLINE const char *
 
295
SWIG_TypeName(const swig_type_info *ty) {
 
296
  return ty->name;
 
297
}
 
298
 
 
299
/*
 
300
  Return the pretty name associated with this type,
 
301
  that is an unmangled type name in a form presentable to the user.
 
302
*/
 
303
SWIGRUNTIME const char *
 
304
SWIG_TypePrettyName(const swig_type_info *type) {
 
305
  /* The "str" field contains the equivalent pretty names of the
 
306
     type, separated by vertical-bar characters.  We choose
 
307
     to print the last name, as it is often (?) the most
 
308
     specific. */
 
309
  if (type->str != NULL) {
 
310
    const char *last_name = type->str;
 
311
    const char *s;
 
312
    for (s = type->str; *s; s++)
 
313
      if (*s == '|') last_name = s+1;
 
314
    return last_name;
 
315
  }
 
316
  else
 
317
    return type->name;
 
318
}
 
319
 
 
320
/* 
 
321
   Set the clientdata field for a type
 
322
*/
 
323
SWIGRUNTIME void
 
324
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 
325
  swig_cast_info *cast = ti->cast;
 
326
  /* if (ti->clientdata == clientdata) return; */
 
327
  ti->clientdata = clientdata;
 
328
  
 
329
  while (cast) {
 
330
    if (!cast->converter) {
 
331
      swig_type_info *tc = cast->type;
 
332
      if (!tc->clientdata) {
 
333
        SWIG_TypeClientData(tc, clientdata);
 
334
      }
 
335
    }    
 
336
    cast = cast->next;
 
337
  }
 
338
}
 
339
 
 
340
/*
 
341
  Search for a swig_type_info structure only by mangled name
 
342
  Search is a O(log #types)
 
343
  
 
344
  We start searching at module start, and finish searching when start == end.  
 
345
  Note: if start == end at the beginning of the function, we go all the way around
 
346
  the circular list.
 
347
*/
 
348
SWIGRUNTIME swig_type_info *
 
349
SWIG_MangledTypeQueryModule(swig_module_info *start, 
 
350
                            swig_module_info *end, 
 
351
                            const char *name) {
 
352
  swig_module_info *iter = start;
 
353
  do {
 
354
    if (iter->size) {
 
355
      register size_t l = 0;
 
356
      register size_t r = iter->size - 1;
 
357
      do {
 
358
        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 
359
        register size_t i = (l + r) >> 1; 
 
360
        const char *iname = iter->types[i]->name;
 
361
        if (iname) {
 
362
          register int compare = strcmp(name, iname);
 
363
          if (compare == 0) {       
 
364
            return iter->types[i];
 
365
          } else if (compare < 0) {
 
366
            if (i) {
 
367
              r = i - 1;
 
368
            } else {
 
369
              break;
 
370
            }
 
371
          } else if (compare > 0) {
 
372
            l = i + 1;
 
373
          }
 
374
        } else {
 
375
          break; /* should never happen */
 
376
        }
 
377
      } while (l <= r);
 
378
    }
 
379
    iter = iter->next;
 
380
  } while (iter != end);
 
381
  return 0;
 
382
}
 
383
 
 
384
/*
 
385
  Search for a swig_type_info structure for either a mangled name or a human readable name.
 
386
  It first searches the mangled names of the types, which is a O(log #types)
 
387
  If a type is not found it then searches the human readable names, which is O(#types).
 
388
  
 
389
  We start searching at module start, and finish searching when start == end.  
 
390
  Note: if start == end at the beginning of the function, we go all the way around
 
391
  the circular list.
 
392
*/
 
393
SWIGRUNTIME swig_type_info *
 
394
SWIG_TypeQueryModule(swig_module_info *start, 
 
395
                     swig_module_info *end, 
 
396
                     const char *name) {
 
397
  /* STEP 1: Search the name field using binary search */
 
398
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 
399
  if (ret) {
 
400
    return ret;
 
401
  } else {
 
402
    /* STEP 2: If the type hasn't been found, do a complete search
 
403
       of the str field (the human readable name) */
 
404
    swig_module_info *iter = start;
 
405
    do {
 
406
      register size_t i = 0;
 
407
      for (; i < iter->size; ++i) {
 
408
        if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 
409
          return iter->types[i];
 
410
      }
 
411
      iter = iter->next;
 
412
    } while (iter != end);
 
413
  }
 
414
  
 
415
  /* neither found a match */
 
416
  return 0;
 
417
}
 
418
 
 
419
 
 
420
/* 
 
421
   Pack binary data into a string
 
422
*/
 
423
SWIGRUNTIME char *
 
424
SWIG_PackData(char *c, void *ptr, size_t sz) {
 
425
  static const char hex[17] = "0123456789abcdef";
 
426
  register const unsigned char *u = (unsigned char *) ptr;
 
427
  register const unsigned char *eu =  u + sz;
 
428
  for (; u != eu; ++u) {
 
429
    register unsigned char uu = *u;
 
430
    *(c++) = hex[(uu & 0xf0) >> 4];
 
431
    *(c++) = hex[uu & 0xf];
 
432
  }
 
433
  return c;
 
434
}
 
435
 
 
436
/* 
 
437
   Unpack binary data from a string
 
438
*/
 
439
SWIGRUNTIME const char *
 
440
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 
441
  register unsigned char *u = (unsigned char *) ptr;
 
442
  register const unsigned char *eu = u + sz;
 
443
  for (; u != eu; ++u) {
 
444
    register char d = *(c++);
 
445
    register unsigned char uu = 0;
 
446
    if ((d >= '0') && (d <= '9'))
 
447
      uu = ((d - '0') << 4);
 
448
    else if ((d >= 'a') && (d <= 'f'))
 
449
      uu = ((d - ('a'-10)) << 4);
 
450
    else 
 
451
      return (char *) 0;
 
452
    d = *(c++);
 
453
    if ((d >= '0') && (d <= '9'))
 
454
      uu |= (d - '0');
 
455
    else if ((d >= 'a') && (d <= 'f'))
 
456
      uu |= (d - ('a'-10));
 
457
    else 
 
458
      return (char *) 0;
 
459
    *u = uu;
 
460
  }
 
461
  return c;
 
462
}
 
463
 
 
464
/* 
 
465
   Pack 'void *' into a string buffer.
 
466
*/
 
467
SWIGRUNTIME char *
 
468
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 
469
  char *r = buff;
 
470
  if ((2*sizeof(void *) + 2) > bsz) return 0;
 
471
  *(r++) = '_';
 
472
  r = SWIG_PackData(r,&ptr,sizeof(void *));
 
473
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 
474
  strcpy(r,name);
 
475
  return buff;
 
476
}
 
477
 
 
478
SWIGRUNTIME const char *
 
479
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 
480
  if (*c != '_') {
 
481
    if (strcmp(c,"NULL") == 0) {
 
482
      *ptr = (void *) 0;
 
483
      return name;
 
484
    } else {
 
485
      return 0;
 
486
    }
 
487
  }
 
488
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
 
489
}
 
490
 
 
491
SWIGRUNTIME char *
 
492
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 
493
  char *r = buff;
 
494
  size_t lname = (name ? strlen(name) : 0);
 
495
  if ((2*sz + 2 + lname) > bsz) return 0;
 
496
  *(r++) = '_';
 
497
  r = SWIG_PackData(r,ptr,sz);
 
498
  if (lname) {
 
499
    strncpy(r,name,lname+1);
 
500
  } else {
 
501
    *r = 0;
 
502
  }
 
503
  return buff;
 
504
}
 
505
 
 
506
SWIGRUNTIME const char *
 
507
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 
508
  if (*c != '_') {
 
509
    if (strcmp(c,"NULL") == 0) {
 
510
      memset(ptr,0,sz);
 
511
      return name;
 
512
    } else {
 
513
      return 0;
 
514
    }
 
515
  }
 
516
  return SWIG_UnpackData(++c,ptr,sz);
 
517
}
 
518
 
 
519
#ifdef __cplusplus
 
520
}
 
521
#endif
 
522
 
 
523
/* -----------------------------------------------------------------------------
 
524
 * SWIG API. Portion that goes into the runtime
 
525
 * ----------------------------------------------------------------------------- */
 
526
 
 
527
#ifdef __cplusplus
 
528
extern "C" {
 
529
#endif
 
530
 
 
531
/* -----------------------------------------------------------------------------
 
532
 * for internal method declarations
 
533
 * ----------------------------------------------------------------------------- */
 
534
 
 
535
#ifndef SWIGINTERN
 
536
#  define SWIGINTERN static SWIGUNUSED
 
537
#endif
 
538
 
 
539
#ifndef SWIGINTERNINLINE
 
540
#  define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 
541
#endif
 
542
 
 
543
/*
 
544
  Exception handling in wrappers
 
545
*/
 
546
#define SWIG_fail                goto fail
 
547
#define SWIG_arg_fail(arg)       SWIG_Python_ArgFail(arg)
 
548
#define SWIG_append_errmsg(msg)   SWIG_Python_AddErrMesg(msg,0)
 
549
#define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
 
550
#define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
 
551
#define SWIG_null_ref(type)       SWIG_Python_NullRef(type)
 
552
 
 
553
/*
 
554
  Contract support
 
555
*/
 
556
#define SWIG_contract_assert(expr, msg) \
 
557
 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
 
558
 
 
559
/* -----------------------------------------------------------------------------
 
560
 * Constant declarations
 
561
 * ----------------------------------------------------------------------------- */
 
562
 
 
563
/* Constant Types */
 
564
#define SWIG_PY_INT     1
 
565
#define SWIG_PY_FLOAT   2
 
566
#define SWIG_PY_STRING  3
 
567
#define SWIG_PY_POINTER 4
 
568
#define SWIG_PY_BINARY  5
 
569
 
 
570
/* Constant information structure */
 
571
typedef struct swig_const_info {
 
572
    int type;
 
573
    char *name;
 
574
    long lvalue;
 
575
    double dvalue;
 
576
    void   *pvalue;
 
577
    swig_type_info **ptype;
 
578
} swig_const_info;
 
579
 
 
580
 
 
581
/* -----------------------------------------------------------------------------
 
582
 * Alloc. memory flags
 
583
 * ----------------------------------------------------------------------------- */
 
584
#define SWIG_OLDOBJ  1
 
585
#define SWIG_NEWOBJ  SWIG_OLDOBJ + 1
 
586
#define SWIG_PYSTR   SWIG_NEWOBJ + 1
 
587
 
 
588
#ifdef __cplusplus
 
589
}
 
590
#endif
 
591
 
 
592
 
 
593
/***********************************************************************
 
594
 * pyrun.swg
 
595
 *
 
596
 *     This file contains the runtime support for Python modules
 
597
 *     and includes code for managing global variables and pointer
 
598
 *     type checking.
 
599
 *
 
600
 * Author : David Beazley (beazley@cs.uchicago.edu)
 
601
 ************************************************************************/
 
602
 
 
603
/* Common SWIG API */
 
604
#define SWIG_ConvertPtr(obj, pp, type, flags)    SWIG_Python_ConvertPtr(obj, pp, type, flags)
 
605
#define SWIG_NewPointerObj(p, type, flags)       SWIG_Python_NewPointerObj(p, type, flags)
 
606
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
 
607
 
 
608
 
 
609
/* Python-specific SWIG API */
 
610
#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags)   SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
 
611
#define SWIG_NewPackedObj(ptr, sz, type)              SWIG_Python_NewPackedObj(ptr, sz, type)
 
612
 
 
613
/* Runtime API */
 
614
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
 
615
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
 
616
 
 
617
/* -----------------------------------------------------------------------------
 
618
 * Pointer declarations
 
619
 * ----------------------------------------------------------------------------- */
 
620
/*
 
621
  Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
 
622
  C/C++ pointers in the python side. Very useful for debugging, but
 
623
  not always safe.
 
624
*/
 
625
#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
 
626
#  define SWIG_COBJECT_TYPES
 
627
#endif
 
628
 
 
629
/* Flags for pointer conversion */
 
630
#define SWIG_POINTER_EXCEPTION     0x1
 
631
#define SWIG_POINTER_DISOWN        0x2
 
632
 
 
633
 
 
634
/* Add PyOS_snprintf for old Pythons */
 
635
#if PY_VERSION_HEX < 0x02020000
 
636
#define PyOS_snprintf snprintf
 
637
#endif
 
638
 
 
639
#ifdef __cplusplus
 
640
extern "C" {
 
641
#endif
 
642
 
 
643
/* -----------------------------------------------------------------------------
 
644
 * Create a new pointer string 
 
645
 * ----------------------------------------------------------------------------- */
 
646
#ifndef SWIG_BUFFER_SIZE
 
647
#define SWIG_BUFFER_SIZE 1024
 
648
#endif
 
649
 
 
650
/* A crude PyString_FromFormat implementation for old Pythons */
 
651
#if PY_VERSION_HEX < 0x02020000
 
652
static PyObject *
 
653
PyString_FromFormat(const char *fmt, ...) {
 
654
  va_list ap;
 
655
  char buf[SWIG_BUFFER_SIZE * 2];
 
656
  int res;
 
657
  va_start(ap, fmt);
 
658
  res = vsnprintf(buf, sizeof(buf), fmt, ap);
 
659
  va_end(ap);
 
660
  return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
 
661
}
 
662
#endif
 
663
 
 
664
#if PY_VERSION_HEX < 0x01060000
 
665
#define PyObject_Del(op) PyMem_DEL((op))
 
666
#endif
 
667
 
 
668
#if defined(SWIG_COBJECT_TYPES)
 
669
#if !defined(SWIG_COBJECT_PYTHON)
 
670
/* -----------------------------------------------------------------------------
 
671
 * Implements a simple Swig Object type, and use it instead of PyCObject
 
672
 * ----------------------------------------------------------------------------- */
 
673
 
 
674
typedef struct {
 
675
  PyObject_HEAD
 
676
  void *ptr;
 
677
  const char *desc;
 
678
} PySwigObject;
 
679
 
 
680
/* Declarations for objects of type PySwigObject */
 
681
 
 
682
SWIGRUNTIME int
 
683
PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
 
684
{
 
685
  char result[SWIG_BUFFER_SIZE];
 
686
  flags = flags;
 
687
  if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
 
688
    fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
 
689
    return 0; 
 
690
  } else {
 
691
    return 1; 
 
692
  }
 
693
}
 
694
  
 
695
SWIGRUNTIME PyObject *
 
696
PySwigObject_repr(PySwigObject *v)
 
697
{
 
698
  char result[SWIG_BUFFER_SIZE];
 
699
  return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
 
700
    PyString_FromFormat("<Swig Object at %s>", result) : 0;
 
701
}
 
702
 
 
703
SWIGRUNTIME PyObject *
 
704
PySwigObject_str(PySwigObject *v)
 
705
{
 
706
  char result[SWIG_BUFFER_SIZE];
 
707
  return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
 
708
    PyString_FromString(result) : 0;
 
709
}
 
710
 
 
711
SWIGRUNTIME PyObject *
 
712
PySwigObject_long(PySwigObject *v)
 
713
{
 
714
  return PyLong_FromVoidPtr(v->ptr);
 
715
}
 
716
 
 
717
SWIGRUNTIME PyObject *
 
718
PySwigObject_format(const char* fmt, PySwigObject *v)
 
719
{
 
720
  PyObject *res = NULL;
 
721
  PyObject *args = PyTuple_New(1);
 
722
  if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
 
723
    PyObject *ofmt = PyString_FromString(fmt);
 
724
    if (ofmt) {
 
725
      res = PyString_Format(ofmt,args);
 
726
      Py_DECREF(ofmt);
 
727
    }
 
728
    Py_DECREF(args);
 
729
  }  
 
730
  return res;
 
731
}
 
732
 
 
733
SWIGRUNTIME PyObject *
 
734
PySwigObject_oct(PySwigObject *v)
 
735
{
 
736
  return PySwigObject_format("%o",v);
 
737
}
 
738
 
 
739
SWIGRUNTIME PyObject *
 
740
PySwigObject_hex(PySwigObject *v)
 
741
{
 
742
  return PySwigObject_format("%x",v);
 
743
}
 
744
 
 
745
SWIGRUNTIME int
 
746
PySwigObject_compare(PySwigObject *v, PySwigObject *w)
 
747
{
 
748
  int c = strcmp(v->desc, w->desc);
 
749
  if (c) {
 
750
    return (c > 0) ? 1 : -1;
 
751
  } else {
 
752
    void *i = v->ptr;
 
753
    void *j = w->ptr;
 
754
    return (i < j) ? -1 : ((i > j) ? 1 : 0);
 
755
  }
 
756
}
 
757
 
 
758
SWIGRUNTIME void
 
759
PySwigObject_dealloc(PySwigObject *self)
 
760
{
 
761
  PyObject_Del(self);
 
762
}
 
763
 
 
764
SWIGRUNTIME PyTypeObject*
 
765
PySwigObject_type(void) {
 
766
  static char pyswigobject_type__doc__[] = 
 
767
    "Swig object carries a C/C++ instance pointer";
 
768
  
 
769
  static PyNumberMethods PySwigObject_as_number = {
 
770
    (binaryfunc)0, /*nb_add*/
 
771
    (binaryfunc)0, /*nb_subtract*/
 
772
    (binaryfunc)0, /*nb_multiply*/
 
773
    (binaryfunc)0, /*nb_divide*/
 
774
    (binaryfunc)0, /*nb_remainder*/
 
775
    (binaryfunc)0, /*nb_divmod*/
 
776
    (ternaryfunc)0,/*nb_power*/
 
777
    (unaryfunc)0,  /*nb_negative*/
 
778
    (unaryfunc)0,  /*nb_positive*/
 
779
    (unaryfunc)0,  /*nb_absolute*/
 
780
    (inquiry)0,    /*nb_nonzero*/
 
781
    0,             /*nb_invert*/
 
782
    0,             /*nb_lshift*/
 
783
    0,             /*nb_rshift*/
 
784
    0,             /*nb_and*/
 
785
    0,             /*nb_xor*/
 
786
    0,             /*nb_or*/
 
787
    (coercion)0,   /*nb_coerce*/
 
788
    (unaryfunc)PySwigObject_long, /*nb_int*/
 
789
    (unaryfunc)PySwigObject_long, /*nb_long*/
 
790
    (unaryfunc)0,                 /*nb_float*/
 
791
    (unaryfunc)PySwigObject_oct,  /*nb_oct*/
 
792
    (unaryfunc)PySwigObject_hex,  /*nb_hex*/
 
793
#if PY_VERSION_HEX >= 0x02020000
 
794
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 
 
795
#elif PY_VERSION_HEX >= 0x02000000
 
796
    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
 
797
#endif
 
798
  };
 
799
 
 
800
  static PyTypeObject pyswigobject_type
 
801
#if !defined(__cplusplus)
 
802
  ;  
 
803
  static int type_init = 0;
 
804
  if (!type_init) {
 
805
    PyTypeObject tmp
 
806
#endif
 
807
    = {
 
808
    PyObject_HEAD_INIT(&PyType_Type)
 
809
    0,                                  /*ob_size*/
 
810
    (char *)"PySwigObject",             /*tp_name*/
 
811
    sizeof(PySwigObject),               /*tp_basicsize*/
 
812
    0,                                  /*tp_itemsize*/
 
813
    /* methods */
 
814
    (destructor)PySwigObject_dealloc,   /*tp_dealloc*/
 
815
    (printfunc)PySwigObject_print,      /*tp_print*/
 
816
    (getattrfunc)0,                     /*tp_getattr*/
 
817
    (setattrfunc)0,                     /*tp_setattr*/
 
818
    (cmpfunc)PySwigObject_compare,      /*tp_compare*/
 
819
    (reprfunc)PySwigObject_repr,        /*tp_repr*/
 
820
    &PySwigObject_as_number,            /*tp_as_number*/
 
821
    0,                                  /*tp_as_sequence*/
 
822
    0,                                  /*tp_as_mapping*/
 
823
    (hashfunc)0,                        /*tp_hash*/
 
824
    (ternaryfunc)0,                     /*tp_call*/
 
825
    (reprfunc)PySwigObject_str,         /*tp_str*/
 
826
    /* Space for future expansion */
 
827
    0,0,0,0,
 
828
    pyswigobject_type__doc__,           /* Documentation string */
 
829
#if PY_VERSION_HEX >= 0x02000000
 
830
    0,                                  /* tp_traverse */
 
831
    0,                                  /* tp_clear */
 
832
#endif
 
833
#if PY_VERSION_HEX >= 0x02010000
 
834
    0,                                  /* tp_richcompare */
 
835
    0,                                  /* tp_weaklistoffset */
 
836
#endif
 
837
#if PY_VERSION_HEX >= 0x02020000
 
838
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
 
839
#endif
 
840
#if PY_VERSION_HEX >= 0x02030000
 
841
    0,                                  /* tp_del */
 
842
#endif
 
843
#ifdef COUNT_ALLOCS
 
844
    0,0,0,0                             /* tp_alloc -> tp_next */
 
845
#endif
 
846
    };
 
847
#if !defined(__cplusplus)
 
848
    pyswigobject_type = tmp;
 
849
    type_init = 1;
 
850
  }
 
851
#endif
 
852
  return &pyswigobject_type;
 
853
}
 
854
 
 
855
SWIGRUNTIME PyObject *
 
856
PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
 
857
{
 
858
  PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
 
859
  if (self) {
 
860
    self->ptr = ptr;
 
861
    self->desc = desc;
 
862
  }
 
863
  return (PyObject *)self;
 
864
}
 
865
 
 
866
SWIGRUNTIMEINLINE void *
 
867
PySwigObject_AsVoidPtr(PyObject *self)
 
868
{
 
869
  return ((PySwigObject *)self)->ptr;
 
870
}
 
871
 
 
872
SWIGRUNTIMEINLINE const char *
 
873
PySwigObject_GetDesc(PyObject *self)
 
874
{
 
875
  return ((PySwigObject *)self)->desc;
 
876
}
 
877
 
 
878
SWIGRUNTIMEINLINE int
 
879
PySwigObject_Check(PyObject *op) {
 
880
  return ((op)->ob_type == PySwigObject_type()) 
 
881
    || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
 
882
}
 
883
 
 
884
/* -----------------------------------------------------------------------------
 
885
 * Implements a simple Swig Packed type, and use it instead of string
 
886
 * ----------------------------------------------------------------------------- */
 
887
 
 
888
typedef struct {
 
889
  PyObject_HEAD
 
890
  void *pack;
 
891
  const char *desc;
 
892
  size_t size;
 
893
} PySwigPacked;
 
894
 
 
895
SWIGRUNTIME int
 
896
PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
 
897
{
 
898
  char result[SWIG_BUFFER_SIZE];
 
899
  flags = flags;
 
900
  fputs("<Swig Packed ", fp); 
 
901
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
 
902
    fputs("at ", fp); 
 
903
    fputs(result, fp); 
 
904
  }
 
905
  fputs(v->desc,fp); 
 
906
  fputs(">", fp);
 
907
  return 0; 
 
908
}
 
909
  
 
910
SWIGRUNTIME PyObject *
 
911
PySwigPacked_repr(PySwigPacked *v)
 
912
{
 
913
  char result[SWIG_BUFFER_SIZE];
 
914
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
 
915
    return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
 
916
  } else {
 
917
    return PyString_FromFormat("<Swig Packed %s>", v->desc);
 
918
  }  
 
919
}
 
920
 
 
921
SWIGRUNTIME PyObject *
 
922
PySwigPacked_str(PySwigPacked *v)
 
923
{
 
924
  char result[SWIG_BUFFER_SIZE];
 
925
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
 
926
    return PyString_FromFormat("%s%s", result, v->desc);
 
927
  } else {
 
928
    return PyString_FromString(v->desc);
 
929
  }  
 
930
}
 
931
 
 
932
SWIGRUNTIME int
 
933
PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
 
934
{
 
935
  int c = strcmp(v->desc, w->desc);
 
936
  if (c) {
 
937
    return (c > 0) ? 1 : -1;
 
938
  } else {
 
939
    size_t i = v->size;
 
940
    size_t j = w->size;
 
941
    int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
 
942
    return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
 
943
  }
 
944
}
 
945
 
 
946
SWIGRUNTIME void
 
947
PySwigPacked_dealloc(PySwigPacked *self)
 
948
{
 
949
  free(self->pack);
 
950
  PyObject_Del(self);
 
951
}
 
952
 
 
953
SWIGRUNTIME PyTypeObject*
 
954
PySwigPacked_type(void) {
 
955
  static char pyswigpacked_type__doc__[] = 
 
956
    "Swig object carries a C/C++ instance pointer";
 
957
  static PyTypeObject pyswigpacked_type
 
958
#if !defined(__cplusplus)
 
959
  ;
 
960
  static int type_init = 0;  
 
961
  if (!type_init) {
 
962
    PyTypeObject tmp
 
963
#endif
 
964
    = {
 
965
    PyObject_HEAD_INIT(&PyType_Type)
 
966
    0,                                  /*ob_size*/
 
967
    (char *)"PySwigPacked",             /*tp_name*/
 
968
    sizeof(PySwigPacked),               /*tp_basicsize*/
 
969
    0,                                  /*tp_itemsize*/
 
970
    /* methods */
 
971
    (destructor)PySwigPacked_dealloc,   /*tp_dealloc*/
 
972
    (printfunc)PySwigPacked_print,      /*tp_print*/
 
973
    (getattrfunc)0,                     /*tp_getattr*/
 
974
    (setattrfunc)0,                     /*tp_setattr*/
 
975
    (cmpfunc)PySwigPacked_compare,      /*tp_compare*/
 
976
    (reprfunc)PySwigPacked_repr,        /*tp_repr*/
 
977
    0,                                  /*tp_as_number*/
 
978
    0,                                  /*tp_as_sequence*/
 
979
    0,                                  /*tp_as_mapping*/
 
980
    (hashfunc)0,                        /*tp_hash*/
 
981
    (ternaryfunc)0,                     /*tp_call*/
 
982
    (reprfunc)PySwigPacked_str,         /*tp_str*/
 
983
    /* Space for future expansion */
 
984
    0,0,0,0,
 
985
    pyswigpacked_type__doc__,           /* Documentation string */
 
986
#if PY_VERSION_HEX >= 0x02000000
 
987
    0,                                  /* tp_traverse */
 
988
    0,                                  /* tp_clear */
 
989
#endif
 
990
#if PY_VERSION_HEX >= 0x02010000
 
991
    0,                                  /* tp_richcompare */
 
992
    0,                                  /* tp_weaklistoffset */
 
993
#endif
 
994
#if PY_VERSION_HEX >= 0x02020000         
 
995
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
 
996
#endif
 
997
#if PY_VERSION_HEX >= 0x02030000
 
998
    0,                                  /* tp_del */
 
999
#endif
 
1000
#ifdef COUNT_ALLOCS
 
1001
    0,0,0,0                             /* tp_alloc -> tp_next */
 
1002
#endif
 
1003
    };
 
1004
#if !defined(__cplusplus)
 
1005
    pyswigpacked_type = tmp;
 
1006
    type_init = 1;
 
1007
  }
 
1008
#endif
 
1009
  return &pyswigpacked_type;
 
1010
}
 
1011
 
 
1012
SWIGRUNTIME PyObject *
 
1013
PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
 
1014
{
 
1015
  PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
 
1016
  if (self == NULL) {
 
1017
    return NULL;
 
1018
  } else {
 
1019
    void *pack = malloc(size);
 
1020
    if (pack) {
 
1021
      memcpy(pack, ptr, size);
 
1022
      self->pack = pack;
 
1023
      self->desc = desc;
 
1024
      self->size = size;
 
1025
      return (PyObject *) self;
 
1026
    }
 
1027
    return NULL;
 
1028
  }
 
1029
}
 
1030
 
 
1031
SWIGRUNTIMEINLINE const char *
 
1032
PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
 
1033
{
 
1034
  PySwigPacked *self = (PySwigPacked *)obj;
 
1035
  if (self->size != size) return 0;
 
1036
  memcpy(ptr, self->pack, size);
 
1037
  return self->desc;
 
1038
}
 
1039
 
 
1040
SWIGRUNTIMEINLINE const char *
 
1041
PySwigPacked_GetDesc(PyObject *self)
 
1042
{
 
1043
  return ((PySwigPacked *)self)->desc;
 
1044
}
 
1045
 
 
1046
SWIGRUNTIMEINLINE int
 
1047
PySwigPacked_Check(PyObject *op) {
 
1048
  return ((op)->ob_type == PySwigPacked_type()) 
 
1049
    || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
 
1050
}
 
1051
 
 
1052
#else
 
1053
/* -----------------------------------------------------------------------------
 
1054
 * Use the old Python PyCObject instead of PySwigObject
 
1055
 * ----------------------------------------------------------------------------- */
 
1056
 
 
1057
#define PySwigObject_GetDesc(obj)                  PyCObject_GetDesc(obj)
 
1058
#define PySwigObject_Check(obj)            PyCObject_Check(obj)
 
1059
#define PySwigObject_AsVoidPtr(obj)        PyCObject_AsVoidPtr(obj)
 
1060
#define PySwigObject_FromVoidPtrAndDesc(p, d)  PyCObject_FromVoidPtrAndDesc(p, d, NULL)
 
1061
 
 
1062
#endif
 
1063
 
 
1064
#endif
 
1065
 
 
1066
/* -----------------------------------------------------------------------------
 
1067
 * errors manipulation
 
1068
 * ----------------------------------------------------------------------------- */
 
1069
 
 
1070
SWIGRUNTIME void
 
1071
SWIG_Python_TypeError(const char *type, PyObject *obj)
 
1072
{
 
1073
  if (type) {
 
1074
#if defined(SWIG_COBJECT_TYPES)
 
1075
    if (obj && PySwigObject_Check(obj)) {
 
1076
      const char *otype = (const char *) PySwigObject_GetDesc(obj);
 
1077
      if (otype) {
 
1078
        PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
 
1079
                     type, otype);
 
1080
        return;
 
1081
      }
 
1082
    } else 
 
1083
#endif      
 
1084
    {
 
1085
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
 
1086
      if (otype) {
 
1087
        PyObject *str = PyObject_Str(obj);
 
1088
        const char *cstr = str ? PyString_AsString(str) : 0;
 
1089
        if (cstr) {
 
1090
          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
 
1091
                       type, otype, cstr);
 
1092
        } else {
 
1093
          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
 
1094
                       type, otype);
 
1095
        }
 
1096
        Py_XDECREF(str);
 
1097
        return;
 
1098
      }
 
1099
    }   
 
1100
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
 
1101
  } else {
 
1102
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
 
1103
  }
 
1104
}
 
1105
 
 
1106
SWIGRUNTIMEINLINE void
 
1107
SWIG_Python_NullRef(const char *type)
 
1108
{
 
1109
  if (type) {
 
1110
    PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
 
1111
  } else {
 
1112
    PyErr_Format(PyExc_TypeError, "null reference was received");
 
1113
  }
 
1114
}
 
1115
 
 
1116
SWIGRUNTIME int
 
1117
SWIG_Python_AddErrMesg(const char* mesg, int infront)
 
1118
{
 
1119
  if (PyErr_Occurred()) {
 
1120
    PyObject *type = 0;
 
1121
    PyObject *value = 0;
 
1122
    PyObject *traceback = 0;
 
1123
    PyErr_Fetch(&type, &value, &traceback);
 
1124
    if (value) {
 
1125
      PyObject *old_str = PyObject_Str(value);
 
1126
      Py_XINCREF(type);
 
1127
      PyErr_Clear();
 
1128
      if (infront) {
 
1129
        PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
 
1130
      } else {
 
1131
        PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
 
1132
      }
 
1133
      Py_DECREF(old_str);
 
1134
    }
 
1135
    return 1;
 
1136
  } else {
 
1137
    return 0;
 
1138
  }
 
1139
}
 
1140
 
 
1141
SWIGRUNTIME int
 
1142
SWIG_Python_ArgFail(int argnum)
 
1143
{
 
1144
  if (PyErr_Occurred()) {
 
1145
    /* add information about failing argument */
 
1146
    char mesg[256];
 
1147
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
 
1148
    return SWIG_Python_AddErrMesg(mesg, 1);
 
1149
  } else {
 
1150
    return 0;
 
1151
  }
 
1152
}
 
1153
 
 
1154
 
 
1155
/* -----------------------------------------------------------------------------
 
1156
 * pointers/data manipulation
 
1157
 * ----------------------------------------------------------------------------- */
 
1158
 
 
1159
/* Convert a pointer value */
 
1160
SWIGRUNTIME int
 
1161
SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
 
1162
  swig_cast_info *tc;
 
1163
  const char *c = 0;
 
1164
  static PyObject *SWIG_this = 0;
 
1165
  int    newref = 0;
 
1166
  PyObject  *pyobj = 0;
 
1167
  void *vptr;
 
1168
  
 
1169
  if (!obj) return 0;
 
1170
  if (obj == Py_None) {
 
1171
    *ptr = 0;
 
1172
    return 0;
 
1173
  }
 
1174
 
 
1175
#ifdef SWIG_COBJECT_TYPES
 
1176
  if (!(PySwigObject_Check(obj))) {
 
1177
    if (!SWIG_this)
 
1178
      SWIG_this = PyString_FromString("this");
 
1179
    pyobj = obj;
 
1180
    obj = PyObject_GetAttr(obj,SWIG_this);
 
1181
    newref = 1;
 
1182
    if (!obj) goto type_error;
 
1183
    if (!PySwigObject_Check(obj)) {
 
1184
      Py_DECREF(obj);
 
1185
      goto type_error;
 
1186
    }
 
1187
  }  
 
1188
  vptr = PySwigObject_AsVoidPtr(obj);
 
1189
  c = (const char *) PySwigObject_GetDesc(obj);
 
1190
  if (newref) { Py_DECREF(obj); }
 
1191
  goto type_check;
 
1192
#else
 
1193
  if (!(PyString_Check(obj))) {
 
1194
    if (!SWIG_this)
 
1195
      SWIG_this = PyString_FromString("this");
 
1196
    pyobj = obj;
 
1197
    obj = PyObject_GetAttr(obj,SWIG_this);
 
1198
    newref = 1;
 
1199
    if (!obj) goto type_error;
 
1200
    if (!PyString_Check(obj)) {
 
1201
      Py_DECREF(obj);
 
1202
      goto type_error;
 
1203
    }
 
1204
  } 
 
1205
  c = PyString_AsString(obj);
 
1206
  /* Pointer values must start with leading underscore */
 
1207
  c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
 
1208
  if (newref) { Py_DECREF(obj); }
 
1209
  if (!c) goto type_error;
 
1210
#endif
 
1211
 
 
1212
type_check:
 
1213
  if (ty) {
 
1214
    tc = SWIG_TypeCheck(c,ty);
 
1215
    if (!tc) goto type_error;
 
1216
    *ptr = SWIG_TypeCast(tc,vptr);
 
1217
  } else {
 
1218
    *ptr = vptr;
 
1219
  }
 
1220
  if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
 
1221
    PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
 
1222
  }
 
1223
  return 0;
 
1224
 
 
1225
type_error:
 
1226
  PyErr_Clear();
 
1227
  if (pyobj && !obj) {    
 
1228
    obj = pyobj;
 
1229
    if (PyCFunction_Check(obj)) {
 
1230
      /* here we get the method pointer for callbacks */
 
1231
      char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
 
1232
      c = doc ? strstr(doc, "swig_ptr: ") : 0;
 
1233
      if (c) {
 
1234
        c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
 
1235
        if (!c) goto type_error;
 
1236
        goto type_check;
 
1237
      }
 
1238
    }
 
1239
  }
 
1240
  if (flags & SWIG_POINTER_EXCEPTION) {
 
1241
    if (ty) {
 
1242
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
 
1243
    } else {
 
1244
      SWIG_Python_TypeError("C/C++ pointer", obj);
 
1245
    }
 
1246
  }
 
1247
  return -1;
 
1248
}
 
1249
 
 
1250
/* Convert a pointer value, signal an exception on a type mismatch */
 
1251
SWIGRUNTIME void *
 
1252
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
 
1253
  void *result;
 
1254
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
 
1255
    PyErr_Clear();
 
1256
    if (flags & SWIG_POINTER_EXCEPTION) {
 
1257
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
 
1258
      SWIG_Python_ArgFail(argnum);
 
1259
    }
 
1260
  }
 
1261
  return result;
 
1262
}
 
1263
 
 
1264
/* Convert a packed value value */
 
1265
SWIGRUNTIME int
 
1266
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
 
1267
  swig_cast_info *tc;
 
1268
  const char *c = 0;
 
1269
 
 
1270
#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
 
1271
  c = PySwigPacked_UnpackData(obj, ptr, sz);
 
1272
#else
 
1273
  if ((!obj) || (!PyString_Check(obj))) goto type_error;
 
1274
  c = PyString_AsString(obj);
 
1275
  /* Pointer values must start with leading underscore */
 
1276
  c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
 
1277
#endif
 
1278
  if (!c) goto type_error;
 
1279
  if (ty) {
 
1280
    tc = SWIG_TypeCheck(c,ty);
 
1281
    if (!tc) goto type_error;
 
1282
  }
 
1283
  return 0;
 
1284
 
 
1285
type_error:
 
1286
  PyErr_Clear();
 
1287
  if (flags & SWIG_POINTER_EXCEPTION) {
 
1288
    if (ty) {
 
1289
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
 
1290
    } else {
 
1291
      SWIG_Python_TypeError("C/C++ packed data", obj);
 
1292
    }
 
1293
  }
 
1294
  return -1;
 
1295
}  
 
1296
 
 
1297
/* Create a new array object */
 
1298
SWIGRUNTIME PyObject *
 
1299
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
 
1300
  PyObject *robj = 0;
 
1301
  if (!type) {
 
1302
    if (!PyErr_Occurred()) {
 
1303
      PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
 
1304
    }
 
1305
    return robj;
 
1306
  }
 
1307
  if (!ptr) {
 
1308
    Py_INCREF(Py_None);
 
1309
    return Py_None;
 
1310
  }
 
1311
#ifdef SWIG_COBJECT_TYPES
 
1312
  robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
 
1313
#else
 
1314
  {
 
1315
    char result[SWIG_BUFFER_SIZE];
 
1316
    robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
 
1317
      PyString_FromString(result) : 0;
 
1318
  }
 
1319
#endif
 
1320
  if (!robj || (robj == Py_None)) return robj;
 
1321
  if (type->clientdata) {
 
1322
    PyObject *inst;
 
1323
    PyObject *args = Py_BuildValue((char*)"(O)", robj);
 
1324
    Py_DECREF(robj);
 
1325
    inst = PyObject_CallObject((PyObject *) type->clientdata, args);
 
1326
    Py_DECREF(args);
 
1327
    if (inst) {
 
1328
      if (own) {
 
1329
        PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
 
1330
      }
 
1331
      robj = inst;
 
1332
    }
 
1333
  }
 
1334
  return robj;
 
1335
}
 
1336
 
 
1337
SWIGRUNTIME PyObject *
 
1338
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
 
1339
  PyObject *robj = 0;
 
1340
  if (!ptr) {
 
1341
    Py_INCREF(Py_None);
 
1342
    return Py_None;
 
1343
  }
 
1344
#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
 
1345
  robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
 
1346
#else
 
1347
  {
 
1348
    char result[SWIG_BUFFER_SIZE];
 
1349
    robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
 
1350
      PyString_FromString(result) : 0;
 
1351
  }
 
1352
#endif
 
1353
  return robj;
 
1354
}
 
1355
 
 
1356
/* -----------------------------------------------------------------------------*
 
1357
 *  Get type list 
 
1358
 * -----------------------------------------------------------------------------*/
 
1359
 
 
1360
#ifdef SWIG_LINK_RUNTIME
 
1361
void *SWIG_ReturnGlobalTypeList(void *);
 
1362
#endif
 
1363
 
 
1364
SWIGRUNTIME swig_module_info *
 
1365
SWIG_Python_GetModule(void) {
 
1366
  static void *type_pointer = (void *)0;
 
1367
  /* first check if module already created */
 
1368
  if (!type_pointer) {
 
1369
#ifdef SWIG_LINK_RUNTIME
 
1370
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
 
1371
#else
 
1372
    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
 
1373
                                    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
 
1374
    if (PyErr_Occurred()) {
 
1375
      PyErr_Clear();
 
1376
      type_pointer = (void *)0;
 
1377
    }
 
1378
#endif
 
1379
  }
 
1380
  return (swig_module_info *) type_pointer;
 
1381
}
 
1382
 
 
1383
#if PY_MAJOR_VERSION < 2
 
1384
/* PyModule_AddObject function was introduced in Python 2.0.  The following function
 
1385
is copied out of Python/modsupport.c in python version 2.3.4 */
 
1386
SWIGINTERN int
 
1387
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
 
1388
{
 
1389
  PyObject *dict;
 
1390
  if (!PyModule_Check(m)) {
 
1391
    PyErr_SetString(PyExc_TypeError,
 
1392
                    "PyModule_AddObject() needs module as first arg");
 
1393
    return -1;
 
1394
  }
 
1395
  if (!o) {
 
1396
    PyErr_SetString(PyExc_TypeError,
 
1397
                    "PyModule_AddObject() needs non-NULL value");
 
1398
    return -1;
 
1399
  }
 
1400
  
 
1401
  dict = PyModule_GetDict(m);
 
1402
  if (dict == NULL) {
 
1403
    /* Internal error -- modules must have a dict! */
 
1404
    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
 
1405
                 PyModule_GetName(m));
 
1406
    return -1;
 
1407
  }
 
1408
  if (PyDict_SetItemString(dict, name, o))
 
1409
    return -1;
 
1410
  Py_DECREF(o);
 
1411
  return 0;
 
1412
}
 
1413
#endif
 
1414
 
 
1415
SWIGRUNTIME void
 
1416
SWIG_Python_SetModule(swig_module_info *swig_module) {
 
1417
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
 
1418
 
 
1419
  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
 
1420
                                   swig_empty_runtime_method_table);
 
1421
  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
 
1422
  if (pointer && module) {
 
1423
    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
 
1424
  }
 
1425
}
 
1426
 
 
1427
#ifdef __cplusplus
 
1428
}
 
1429
#endif
 
1430
 
 
1431
 
 
1432
/* -------- TYPES TABLE (BEGIN) -------- */
 
1433
 
 
1434
#define SWIGTYPE_p_char swig_types[0]
 
1435
#define SWIGTYPE_p_form_ops_t swig_types[1]
 
1436
#define SWIGTYPE_p_int swig_types[2]
 
1437
#define SWIGTYPE_p_unsigned_char swig_types[3]
 
1438
#define SWIGTYPE_p_unsigned_int swig_types[4]
 
1439
#define SWIGTYPE_p_unsigned_long swig_types[5]
 
1440
#define SWIGTYPE_p_wxANIHandler swig_types[6]
 
1441
#define SWIGTYPE_p_wxAcceleratorTable swig_types[7]
 
1442
#define SWIGTYPE_p_wxActivateEvent swig_types[8]
 
1443
#define SWIGTYPE_p_wxBMPHandler swig_types[9]
 
1444
#define SWIGTYPE_p_wxBoxSizer swig_types[10]
 
1445
#define SWIGTYPE_p_wxCURHandler swig_types[11]
 
1446
#define SWIGTYPE_p_wxChildFocusEvent swig_types[12]
 
1447
#define SWIGTYPE_p_wxCloseEvent swig_types[13]
 
1448
#define SWIGTYPE_p_wxCommandEvent swig_types[14]
 
1449
#define SWIGTYPE_p_wxContextMenuEvent swig_types[15]
 
1450
#define SWIGTYPE_p_wxControl swig_types[16]
 
1451
#define SWIGTYPE_p_wxControlWithItems swig_types[17]
 
1452
#define SWIGTYPE_p_wxDateEvent swig_types[18]
 
1453
#define SWIGTYPE_p_wxDisplayChangedEvent swig_types[19]
 
1454
#define SWIGTYPE_p_wxDropFilesEvent swig_types[20]
 
1455
#define SWIGTYPE_p_wxDuplexMode swig_types[21]
 
1456
#define SWIGTYPE_p_wxEraseEvent swig_types[22]
 
1457
#define SWIGTYPE_p_wxEvent swig_types[23]
 
1458
#define SWIGTYPE_p_wxEvtHandler swig_types[24]
 
1459
#define SWIGTYPE_p_wxFSFile swig_types[25]
 
1460
#define SWIGTYPE_p_wxFileSystem swig_types[26]
 
1461
#define SWIGTYPE_p_wxFlexGridSizer swig_types[27]
 
1462
#define SWIGTYPE_p_wxFocusEvent swig_types[28]
 
1463
#define SWIGTYPE_p_wxGBSizerItem swig_types[29]
 
1464
#define SWIGTYPE_p_wxGIFHandler swig_types[30]
 
1465
#define SWIGTYPE_p_wxGLCanvas swig_types[31]
 
1466
#define SWIGTYPE_p_wxGLContext swig_types[32]
 
1467
#define SWIGTYPE_p_wxGridBagSizer swig_types[33]
 
1468
#define SWIGTYPE_p_wxGridSizer swig_types[34]
 
1469
#define SWIGTYPE_p_wxICOHandler swig_types[35]
 
1470
#define SWIGTYPE_p_wxIconizeEvent swig_types[36]
 
1471
#define SWIGTYPE_p_wxIdleEvent swig_types[37]
 
1472
#define SWIGTYPE_p_wxImage swig_types[38]
 
1473
#define SWIGTYPE_p_wxImageHandler swig_types[39]
 
1474
#define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[40]
 
1475
#define SWIGTYPE_p_wxInitDialogEvent swig_types[41]
 
1476
#define SWIGTYPE_p_wxJPEGHandler swig_types[42]
 
1477
#define SWIGTYPE_p_wxKeyEvent swig_types[43]
 
1478
#define SWIGTYPE_p_wxLayoutConstraints swig_types[44]
 
1479
#define SWIGTYPE_p_wxMaximizeEvent swig_types[45]
 
1480
#define SWIGTYPE_p_wxMenu swig_types[46]
 
1481
#define SWIGTYPE_p_wxMenuBar swig_types[47]
 
1482
#define SWIGTYPE_p_wxMenuEvent swig_types[48]
 
1483
#define SWIGTYPE_p_wxMenuItem swig_types[49]
 
1484
#define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[50]
 
1485
#define SWIGTYPE_p_wxMouseEvent swig_types[51]
 
1486
#define SWIGTYPE_p_wxMoveEvent swig_types[52]
 
1487
#define SWIGTYPE_p_wxNavigationKeyEvent swig_types[53]
 
1488
#define SWIGTYPE_p_wxNcPaintEvent swig_types[54]
 
1489
#define SWIGTYPE_p_wxNotifyEvent swig_types[55]
 
1490
#define SWIGTYPE_p_wxObject swig_types[56]
 
1491
#define SWIGTYPE_p_wxPCXHandler swig_types[57]
 
1492
#define SWIGTYPE_p_wxPNGHandler swig_types[58]
 
1493
#define SWIGTYPE_p_wxPNMHandler swig_types[59]
 
1494
#define SWIGTYPE_p_wxPaintEvent swig_types[60]
 
1495
#define SWIGTYPE_p_wxPalette swig_types[61]
 
1496
#define SWIGTYPE_p_wxPaletteChangedEvent swig_types[62]
 
1497
#define SWIGTYPE_p_wxPaperSize swig_types[63]
 
1498
#define SWIGTYPE_p_wxPyApp swig_types[64]
 
1499
#define SWIGTYPE_p_wxPyCommandEvent swig_types[65]
 
1500
#define SWIGTYPE_p_wxPyEvent swig_types[66]
 
1501
#define SWIGTYPE_p_wxPyImageHandler swig_types[67]
 
1502
#define SWIGTYPE_p_wxPySizer swig_types[68]
 
1503
#define SWIGTYPE_p_wxPyValidator swig_types[69]
 
1504
#define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[70]
 
1505
#define SWIGTYPE_p_wxScrollEvent swig_types[71]
 
1506
#define SWIGTYPE_p_wxScrollWinEvent swig_types[72]
 
1507
#define SWIGTYPE_p_wxSetCursorEvent swig_types[73]
 
1508
#define SWIGTYPE_p_wxShowEvent swig_types[74]
 
1509
#define SWIGTYPE_p_wxSizeEvent swig_types[75]
 
1510
#define SWIGTYPE_p_wxSizer swig_types[76]
 
1511
#define SWIGTYPE_p_wxSizerItem swig_types[77]
 
1512
#define SWIGTYPE_p_wxStaticBoxSizer swig_types[78]
 
1513
#define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[79]
 
1514
#define SWIGTYPE_p_wxSysColourChangedEvent swig_types[80]
 
1515
#define SWIGTYPE_p_wxTIFFHandler swig_types[81]
 
1516
#define SWIGTYPE_p_wxUpdateUIEvent swig_types[82]
 
1517
#define SWIGTYPE_p_wxValidator swig_types[83]
 
1518
#define SWIGTYPE_p_wxWindow swig_types[84]
 
1519
#define SWIGTYPE_p_wxWindowCreateEvent swig_types[85]
 
1520
#define SWIGTYPE_p_wxWindowDestroyEvent swig_types[86]
 
1521
#define SWIGTYPE_p_wxXPMHandler swig_types[87]
 
1522
#define SWIGTYPE_ptrdiff_t swig_types[88]
 
1523
#define SWIGTYPE_std__ptrdiff_t swig_types[89]
 
1524
#define SWIGTYPE_unsigned_int swig_types[90]
 
1525
static swig_type_info *swig_types[92];
 
1526
static swig_module_info swig_module = {swig_types, 91, 0, 0, 0, 0};
 
1527
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 
1528
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
1529
 
 
1530
/* -------- TYPES TABLE (END) -------- */
 
1531
 
 
1532
 
 
1533
/*-----------------------------------------------
 
1534
              @(target):= _glcanvas.so
 
1535
  ------------------------------------------------*/
 
1536
#define SWIG_init    init_glcanvas
 
1537
 
 
1538
#define SWIG_name    "_glcanvas"
 
1539
 
 
1540
#include "wx/wxPython/wxPython.h"
 
1541
#include "wx/wxPython/pyclasses.h"
 
1542
 
 
1543
#include <wx/glcanvas.h>
 
1544
 
 
1545
 
 
1546
 static const wxString wxPyGLCanvasNameStr(wxT("GLCanvas")); 
 
1547
 static const wxString wxPyEmptyString(wxEmptyString); 
 
1548
 
 
1549
#include <limits.h>
 
1550
 
 
1551
 
 
1552
SWIGINTERN int
 
1553
  SWIG_CheckLongInRange(long value, long min_value, long max_value,
 
1554
                        const char *errmsg)
 
1555
{
 
1556
  if (value < min_value) {
 
1557
    if (errmsg) {
 
1558
      PyErr_Format(PyExc_OverflowError, 
 
1559
                   "value %ld is less than '%s' minimum %ld", 
 
1560
                   value, errmsg, min_value);
 
1561
    }
 
1562
    return 0;    
 
1563
  } else if (value > max_value) {
 
1564
    if (errmsg) {
 
1565
      PyErr_Format(PyExc_OverflowError,
 
1566
                   "value %ld is greater than '%s' maximum %ld", 
 
1567
                   value, errmsg, max_value);
 
1568
    }
 
1569
    return 0;
 
1570
  }
 
1571
  return 1;
 
1572
}
 
1573
 
 
1574
 
 
1575
SWIGINTERN int
 
1576
SWIG_AsVal_long(PyObject* obj, long* val)
 
1577
{
 
1578
    if (PyNumber_Check(obj)) {
 
1579
        if (val) *val = PyInt_AsLong(obj);
 
1580
        return 1;
 
1581
    }
 
1582
    else {
 
1583
        SWIG_type_error("number", obj);
 
1584
    }
 
1585
    return 0;
 
1586
}
 
1587
 
 
1588
 
 
1589
#if INT_MAX != LONG_MAX
 
1590
SWIGINTERN int
 
1591
  SWIG_AsVal_int(PyObject *obj, int *val)
 
1592
{ 
 
1593
  const char* errmsg = val ? "int" : (char*)0;
 
1594
  long v;
 
1595
  if (SWIG_AsVal_long(obj, &v)) {
 
1596
    if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
 
1597
      if (val) *val = static_cast<int >(v);
 
1598
      return 1;
 
1599
    } else {
 
1600
      return 0;
 
1601
    }
 
1602
  } else {
 
1603
    PyErr_Clear();
 
1604
  }
 
1605
  if (val) {
 
1606
    SWIG_type_error(errmsg, obj);
 
1607
  }
 
1608
  return 0;    
 
1609
}
 
1610
#else
 
1611
SWIGINTERNINLINE int
 
1612
  SWIG_AsVal_int(PyObject *obj, int *val)
 
1613
{
 
1614
  return SWIG_AsVal_long(obj,(long*)val);
 
1615
}
 
1616
#endif
 
1617
 
 
1618
 
 
1619
SWIGINTERN int
 
1620
  SWIG_AsVal_bool(PyObject *obj, bool *val)
 
1621
{
 
1622
  if (obj == Py_True) {
 
1623
    if (val) *val = true;
 
1624
    return 1;
 
1625
  }
 
1626
  if (obj == Py_False) {
 
1627
    if (val) *val = false;
 
1628
    return 1;
 
1629
  }
 
1630
  int res = 0;
 
1631
  if (SWIG_AsVal_int(obj, &res)) {    
 
1632
    if (val) *val = res ? true : false;
 
1633
    return 1;
 
1634
  } else {
 
1635
    PyErr_Clear();
 
1636
  }  
 
1637
  if (val) {
 
1638
    SWIG_type_error("bool", obj);
 
1639
  }
 
1640
  return 0;
 
1641
}
 
1642
 
 
1643
 
 
1644
SWIGINTERNINLINE bool
 
1645
SWIG_As_bool(PyObject* obj)
 
1646
{
 
1647
  bool v;
 
1648
  if (!SWIG_AsVal_bool(obj, &v)) {
 
1649
    /*
 
1650
      this is needed to make valgrind/purify happier. 
 
1651
     */
 
1652
    memset((void*)&v, 0, sizeof(bool));
 
1653
  }
 
1654
  return v;
 
1655
}
 
1656
 
 
1657
  
 
1658
SWIGINTERNINLINE int
 
1659
SWIG_Check_bool(PyObject* obj)
 
1660
{
 
1661
  return SWIG_AsVal_bool(obj, (bool*)0);
 
1662
}
 
1663
 
 
1664
 
 
1665
  /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
 
1666
#define SWIG_From_int PyInt_FromLong
 
1667
/*@@*/
 
1668
 
 
1669
 
 
1670
SWIGINTERNINLINE int
 
1671
SWIG_As_int(PyObject* obj)
 
1672
{
 
1673
  int v;
 
1674
  if (!SWIG_AsVal_int(obj, &v)) {
 
1675
    /*
 
1676
      this is needed to make valgrind/purify happier. 
 
1677
     */
 
1678
    memset((void*)&v, 0, sizeof(int));
 
1679
  }
 
1680
  return v;
 
1681
}
 
1682
 
 
1683
 
 
1684
SWIGINTERNINLINE long
 
1685
SWIG_As_long(PyObject* obj)
 
1686
{
 
1687
  long v;
 
1688
  if (!SWIG_AsVal_long(obj, &v)) {
 
1689
    /*
 
1690
      this is needed to make valgrind/purify happier. 
 
1691
     */
 
1692
    memset((void*)&v, 0, sizeof(long));
 
1693
  }
 
1694
  return v;
 
1695
}
 
1696
 
 
1697
  
 
1698
SWIGINTERNINLINE int
 
1699
SWIG_Check_int(PyObject* obj)
 
1700
{
 
1701
  return SWIG_AsVal_int(obj, (int*)0);
 
1702
}
 
1703
 
 
1704
  
 
1705
SWIGINTERNINLINE int
 
1706
SWIG_Check_long(PyObject* obj)
 
1707
{
 
1708
  return SWIG_AsVal_long(obj, (long*)0);
 
1709
}
 
1710
 
 
1711
#ifdef __cplusplus
 
1712
extern "C" {
 
1713
#endif
 
1714
static int _wrap_GLCanvasNameStr_set(PyObject *) {
 
1715
    PyErr_SetString(PyExc_TypeError,"Variable GLCanvasNameStr is read-only.");
 
1716
    return 1;
 
1717
}
 
1718
 
 
1719
 
 
1720
static PyObject *_wrap_GLCanvasNameStr_get(void) {
 
1721
    PyObject *pyobj = NULL;
 
1722
    
 
1723
    {
 
1724
#if wxUSE_UNICODE
 
1725
        pyobj = PyUnicode_FromWideChar((&wxPyGLCanvasNameStr)->c_str(), (&wxPyGLCanvasNameStr)->Len());
 
1726
#else
 
1727
        pyobj = PyString_FromStringAndSize((&wxPyGLCanvasNameStr)->c_str(), (&wxPyGLCanvasNameStr)->Len());
 
1728
#endif
 
1729
    }
 
1730
    return pyobj;
 
1731
}
 
1732
 
 
1733
 
 
1734
static PyObject *_wrap_new_GLContext(PyObject *, PyObject *args, PyObject *kwargs) {
 
1735
    PyObject *resultobj = NULL;
 
1736
    bool arg1 ;
 
1737
    wxGLCanvas *arg2 = (wxGLCanvas *) 0 ;
 
1738
    wxPalette const &arg3_defvalue = wxNullPalette ;
 
1739
    wxPalette *arg3 = (wxPalette *) &arg3_defvalue ;
 
1740
    wxGLContext *arg4 = (wxGLContext *) NULL ;
 
1741
    wxGLContext *result;
 
1742
    PyObject * obj0 = 0 ;
 
1743
    PyObject * obj1 = 0 ;
 
1744
    PyObject * obj2 = 0 ;
 
1745
    PyObject * obj3 = 0 ;
 
1746
    char *kwnames[] = {
 
1747
        (char *) "isRGB",(char *) "win",(char *) "palette",(char *) "other", NULL 
 
1748
    };
 
1749
    
 
1750
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GLContext",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
 
1751
    {
 
1752
        arg1 = static_cast<bool >(SWIG_As_bool(obj0)); 
 
1753
        if (SWIG_arg_fail(1)) SWIG_fail;
 
1754
    }
 
1755
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGLCanvas, SWIG_POINTER_EXCEPTION | 0);
 
1756
    if (SWIG_arg_fail(2)) SWIG_fail;
 
1757
    if (obj2) {
 
1758
        {
 
1759
            SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
 
1760
            if (SWIG_arg_fail(3)) SWIG_fail;
 
1761
            if (arg3 == NULL) {
 
1762
                SWIG_null_ref("wxPalette");
 
1763
            }
 
1764
            if (SWIG_arg_fail(3)) SWIG_fail;
 
1765
        }
 
1766
    }
 
1767
    if (obj3) {
 
1768
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
1769
        if (SWIG_arg_fail(4)) SWIG_fail;
 
1770
    }
 
1771
    {
 
1772
        if (!wxPyCheckForApp()) SWIG_fail;
 
1773
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
1774
        result = (wxGLContext *)new wxGLContext(arg1,arg2,(wxPalette const &)*arg3,(wxGLContext const *)arg4);
 
1775
        
 
1776
        wxPyEndAllowThreads(__tstate);
 
1777
        if (PyErr_Occurred()) SWIG_fail;
 
1778
    }
 
1779
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGLContext, 1);
 
1780
    return resultobj;
 
1781
    fail:
 
1782
    return NULL;
 
1783
}
 
1784
 
 
1785
 
 
1786
static PyObject *_wrap_delete_GLContext(PyObject *, PyObject *args, PyObject *kwargs) {
 
1787
    PyObject *resultobj = NULL;
 
1788
    wxGLContext *arg1 = (wxGLContext *) 0 ;
 
1789
    PyObject * obj0 = 0 ;
 
1790
    char *kwnames[] = {
 
1791
        (char *) "self", NULL 
 
1792
    };
 
1793
    
 
1794
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GLContext",kwnames,&obj0)) goto fail;
 
1795
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
1796
    if (SWIG_arg_fail(1)) SWIG_fail;
 
1797
    {
 
1798
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
1799
        delete arg1;
 
1800
        
 
1801
        wxPyEndAllowThreads(__tstate);
 
1802
        if (PyErr_Occurred()) SWIG_fail;
 
1803
    }
 
1804
    Py_INCREF(Py_None); resultobj = Py_None;
 
1805
    return resultobj;
 
1806
    fail:
 
1807
    return NULL;
 
1808
}
 
1809
 
 
1810
 
 
1811
static PyObject *_wrap_GLContext_SetCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
 
1812
    PyObject *resultobj = NULL;
 
1813
    wxGLContext *arg1 = (wxGLContext *) 0 ;
 
1814
    PyObject * obj0 = 0 ;
 
1815
    char *kwnames[] = {
 
1816
        (char *) "self", NULL 
 
1817
    };
 
1818
    
 
1819
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GLContext_SetCurrent",kwnames,&obj0)) goto fail;
 
1820
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
1821
    if (SWIG_arg_fail(1)) SWIG_fail;
 
1822
    {
 
1823
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
1824
        (arg1)->SetCurrent();
 
1825
        
 
1826
        wxPyEndAllowThreads(__tstate);
 
1827
        if (PyErr_Occurred()) SWIG_fail;
 
1828
    }
 
1829
    Py_INCREF(Py_None); resultobj = Py_None;
 
1830
    return resultobj;
 
1831
    fail:
 
1832
    return NULL;
 
1833
}
 
1834
 
 
1835
 
 
1836
static PyObject *_wrap_GLContext_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
 
1837
    PyObject *resultobj = NULL;
 
1838
    wxGLContext *arg1 = (wxGLContext *) 0 ;
 
1839
    wxString *arg2 = 0 ;
 
1840
    bool temp2 = false ;
 
1841
    PyObject * obj0 = 0 ;
 
1842
    PyObject * obj1 = 0 ;
 
1843
    char *kwnames[] = {
 
1844
        (char *) "self",(char *) "colour", NULL 
 
1845
    };
 
1846
    
 
1847
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GLContext_SetColour",kwnames,&obj0,&obj1)) goto fail;
 
1848
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
1849
    if (SWIG_arg_fail(1)) SWIG_fail;
 
1850
    {
 
1851
        arg2 = wxString_in_helper(obj1);
 
1852
        if (arg2 == NULL) SWIG_fail;
 
1853
        temp2 = true;
 
1854
    }
 
1855
    {
 
1856
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
1857
        (arg1)->SetColour((wxString const &)*arg2);
 
1858
        
 
1859
        wxPyEndAllowThreads(__tstate);
 
1860
        if (PyErr_Occurred()) SWIG_fail;
 
1861
    }
 
1862
    Py_INCREF(Py_None); resultobj = Py_None;
 
1863
    {
 
1864
        if (temp2)
 
1865
        delete arg2;
 
1866
    }
 
1867
    return resultobj;
 
1868
    fail:
 
1869
    {
 
1870
        if (temp2)
 
1871
        delete arg2;
 
1872
    }
 
1873
    return NULL;
 
1874
}
 
1875
 
 
1876
 
 
1877
static PyObject *_wrap_GLContext_SwapBuffers(PyObject *, PyObject *args, PyObject *kwargs) {
 
1878
    PyObject *resultobj = NULL;
 
1879
    wxGLContext *arg1 = (wxGLContext *) 0 ;
 
1880
    PyObject * obj0 = 0 ;
 
1881
    char *kwnames[] = {
 
1882
        (char *) "self", NULL 
 
1883
    };
 
1884
    
 
1885
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GLContext_SwapBuffers",kwnames,&obj0)) goto fail;
 
1886
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
1887
    if (SWIG_arg_fail(1)) SWIG_fail;
 
1888
    {
 
1889
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
1890
        (arg1)->SwapBuffers();
 
1891
        
 
1892
        wxPyEndAllowThreads(__tstate);
 
1893
        if (PyErr_Occurred()) SWIG_fail;
 
1894
    }
 
1895
    Py_INCREF(Py_None); resultobj = Py_None;
 
1896
    return resultobj;
 
1897
    fail:
 
1898
    return NULL;
 
1899
}
 
1900
 
 
1901
 
 
1902
static PyObject *_wrap_GLContext_SetupPixelFormat(PyObject *, PyObject *args, PyObject *kwargs) {
 
1903
    PyObject *resultobj = NULL;
 
1904
    wxGLContext *arg1 = (wxGLContext *) 0 ;
 
1905
    PyObject * obj0 = 0 ;
 
1906
    char *kwnames[] = {
 
1907
        (char *) "self", NULL 
 
1908
    };
 
1909
    
 
1910
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GLContext_SetupPixelFormat",kwnames,&obj0)) goto fail;
 
1911
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
1912
    if (SWIG_arg_fail(1)) SWIG_fail;
 
1913
    {
 
1914
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
1915
        (arg1)->SetupPixelFormat();
 
1916
        
 
1917
        wxPyEndAllowThreads(__tstate);
 
1918
        if (PyErr_Occurred()) SWIG_fail;
 
1919
    }
 
1920
    Py_INCREF(Py_None); resultobj = Py_None;
 
1921
    return resultobj;
 
1922
    fail:
 
1923
    return NULL;
 
1924
}
 
1925
 
 
1926
 
 
1927
static PyObject *_wrap_GLContext_SetupPalette(PyObject *, PyObject *args, PyObject *kwargs) {
 
1928
    PyObject *resultobj = NULL;
 
1929
    wxGLContext *arg1 = (wxGLContext *) 0 ;
 
1930
    wxPalette *arg2 = 0 ;
 
1931
    PyObject * obj0 = 0 ;
 
1932
    PyObject * obj1 = 0 ;
 
1933
    char *kwnames[] = {
 
1934
        (char *) "self",(char *) "palette", NULL 
 
1935
    };
 
1936
    
 
1937
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GLContext_SetupPalette",kwnames,&obj0,&obj1)) goto fail;
 
1938
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
1939
    if (SWIG_arg_fail(1)) SWIG_fail;
 
1940
    {
 
1941
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
 
1942
        if (SWIG_arg_fail(2)) SWIG_fail;
 
1943
        if (arg2 == NULL) {
 
1944
            SWIG_null_ref("wxPalette");
 
1945
        }
 
1946
        if (SWIG_arg_fail(2)) SWIG_fail;
 
1947
    }
 
1948
    {
 
1949
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
1950
        (arg1)->SetupPalette((wxPalette const &)*arg2);
 
1951
        
 
1952
        wxPyEndAllowThreads(__tstate);
 
1953
        if (PyErr_Occurred()) SWIG_fail;
 
1954
    }
 
1955
    Py_INCREF(Py_None); resultobj = Py_None;
 
1956
    return resultobj;
 
1957
    fail:
 
1958
    return NULL;
 
1959
}
 
1960
 
 
1961
 
 
1962
static PyObject *_wrap_GLContext_CreateDefaultPalette(PyObject *, PyObject *args, PyObject *kwargs) {
 
1963
    PyObject *resultobj = NULL;
 
1964
    wxGLContext *arg1 = (wxGLContext *) 0 ;
 
1965
    wxPalette result;
 
1966
    PyObject * obj0 = 0 ;
 
1967
    char *kwnames[] = {
 
1968
        (char *) "self", NULL 
 
1969
    };
 
1970
    
 
1971
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GLContext_CreateDefaultPalette",kwnames,&obj0)) goto fail;
 
1972
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
1973
    if (SWIG_arg_fail(1)) SWIG_fail;
 
1974
    {
 
1975
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
1976
        result = (arg1)->CreateDefaultPalette();
 
1977
        
 
1978
        wxPyEndAllowThreads(__tstate);
 
1979
        if (PyErr_Occurred()) SWIG_fail;
 
1980
    }
 
1981
    {
 
1982
        wxPalette * resultptr;
 
1983
        resultptr = new wxPalette(static_cast<wxPalette & >(result));
 
1984
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPalette, 1);
 
1985
    }
 
1986
    return resultobj;
 
1987
    fail:
 
1988
    return NULL;
 
1989
}
 
1990
 
 
1991
 
 
1992
static PyObject *_wrap_GLContext_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
 
1993
    PyObject *resultobj = NULL;
 
1994
    wxGLContext *arg1 = (wxGLContext *) 0 ;
 
1995
    wxPalette *result;
 
1996
    PyObject * obj0 = 0 ;
 
1997
    char *kwnames[] = {
 
1998
        (char *) "self", NULL 
 
1999
    };
 
2000
    
 
2001
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GLContext_GetPalette",kwnames,&obj0)) goto fail;
 
2002
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
2003
    if (SWIG_arg_fail(1)) SWIG_fail;
 
2004
    {
 
2005
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
2006
        result = (wxPalette *)(arg1)->GetPalette();
 
2007
        
 
2008
        wxPyEndAllowThreads(__tstate);
 
2009
        if (PyErr_Occurred()) SWIG_fail;
 
2010
    }
 
2011
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
 
2012
    return resultobj;
 
2013
    fail:
 
2014
    return NULL;
 
2015
}
 
2016
 
 
2017
 
 
2018
static PyObject *_wrap_GLContext_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
 
2019
    PyObject *resultobj = NULL;
 
2020
    wxGLContext *arg1 = (wxGLContext *) 0 ;
 
2021
    wxWindow *result;
 
2022
    PyObject * obj0 = 0 ;
 
2023
    char *kwnames[] = {
 
2024
        (char *) "self", NULL 
 
2025
    };
 
2026
    
 
2027
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GLContext_GetWindow",kwnames,&obj0)) goto fail;
 
2028
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
2029
    if (SWIG_arg_fail(1)) SWIG_fail;
 
2030
    {
 
2031
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
2032
        result = (wxWindow *)(arg1)->GetWindow();
 
2033
        
 
2034
        wxPyEndAllowThreads(__tstate);
 
2035
        if (PyErr_Occurred()) SWIG_fail;
 
2036
    }
 
2037
    {
 
2038
        resultobj = wxPyMake_wxObject(result, 0); 
 
2039
    }
 
2040
    return resultobj;
 
2041
    fail:
 
2042
    return NULL;
 
2043
}
 
2044
 
 
2045
 
 
2046
static PyObject * GLContext_swigregister(PyObject *, PyObject *args) {
 
2047
    PyObject *obj;
 
2048
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
 
2049
    SWIG_TypeClientData(SWIGTYPE_p_wxGLContext, obj);
 
2050
    Py_INCREF(obj);
 
2051
    return Py_BuildValue((char *)"");
 
2052
}
 
2053
static PyObject *_wrap_new_GLCanvas(PyObject *, PyObject *args, PyObject *kwargs) {
 
2054
    PyObject *resultobj = NULL;
 
2055
    wxWindow *arg1 = (wxWindow *) 0 ;
 
2056
    int arg2 = (int) -1 ;
 
2057
    wxPoint const &arg3_defvalue = wxDefaultPosition ;
 
2058
    wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
 
2059
    wxSize const &arg4_defvalue = wxDefaultSize ;
 
2060
    wxSize *arg4 = (wxSize *) &arg4_defvalue ;
 
2061
    long arg5 = (long) 0 ;
 
2062
    wxString const &arg6_defvalue = wxPyGLCanvasNameStr ;
 
2063
    wxString *arg6 = (wxString *) &arg6_defvalue ;
 
2064
    int *arg7 = (int *) NULL ;
 
2065
    wxPalette const &arg8_defvalue = wxNullPalette ;
 
2066
    wxPalette *arg8 = (wxPalette *) &arg8_defvalue ;
 
2067
    wxGLCanvas *result;
 
2068
    wxPoint temp3 ;
 
2069
    wxSize temp4 ;
 
2070
    bool temp6 = false ;
 
2071
    int *temp7 ;
 
2072
    PyObject * obj0 = 0 ;
 
2073
    PyObject * obj1 = 0 ;
 
2074
    PyObject * obj2 = 0 ;
 
2075
    PyObject * obj3 = 0 ;
 
2076
    PyObject * obj4 = 0 ;
 
2077
    PyObject * obj5 = 0 ;
 
2078
    PyObject * obj6 = 0 ;
 
2079
    PyObject * obj7 = 0 ;
 
2080
    char *kwnames[] = {
 
2081
        (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name",(char *) "attribList",(char *) "palette", NULL 
 
2082
    };
 
2083
    
 
2084
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_GLCanvas",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
 
2085
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
 
2086
    if (SWIG_arg_fail(1)) SWIG_fail;
 
2087
    if (obj1) {
 
2088
        {
 
2089
            arg2 = static_cast<int >(SWIG_As_int(obj1)); 
 
2090
            if (SWIG_arg_fail(2)) SWIG_fail;
 
2091
        }
 
2092
    }
 
2093
    if (obj2) {
 
2094
        {
 
2095
            arg3 = &temp3;
 
2096
            if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
 
2097
        }
 
2098
    }
 
2099
    if (obj3) {
 
2100
        {
 
2101
            arg4 = &temp4;
 
2102
            if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
 
2103
        }
 
2104
    }
 
2105
    if (obj4) {
 
2106
        {
 
2107
            arg5 = static_cast<long >(SWIG_As_long(obj4)); 
 
2108
            if (SWIG_arg_fail(5)) SWIG_fail;
 
2109
        }
 
2110
    }
 
2111
    if (obj5) {
 
2112
        {
 
2113
            arg6 = wxString_in_helper(obj5);
 
2114
            if (arg6 == NULL) SWIG_fail;
 
2115
            temp6 = true;
 
2116
        }
 
2117
    }
 
2118
    if (obj6) {
 
2119
        {
 
2120
            int i;
 
2121
            if (PySequence_Check(obj6)) {
 
2122
                int size = PyObject_Length(obj6);
 
2123
                temp7 = new int[size+1]; // (int*)malloc((size + 1) * sizeof(int));
 
2124
                for (i = 0; i < size; i++) {
 
2125
                    temp7[i] = PyInt_AsLong(PySequence_GetItem(obj6, i));
 
2126
                }
 
2127
                temp7[size] = 0;
 
2128
                arg7 = temp7;
 
2129
            }
 
2130
        }
 
2131
    }
 
2132
    if (obj7) {
 
2133
        {
 
2134
            SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
 
2135
            if (SWIG_arg_fail(8)) SWIG_fail;
 
2136
            if (arg8 == NULL) {
 
2137
                SWIG_null_ref("wxPalette");
 
2138
            }
 
2139
            if (SWIG_arg_fail(8)) SWIG_fail;
 
2140
        }
 
2141
    }
 
2142
    {
 
2143
        if (!wxPyCheckForApp()) SWIG_fail;
 
2144
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
2145
        result = (wxGLCanvas *)new wxGLCanvas(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6,arg7,(wxPalette const &)*arg8);
 
2146
        
 
2147
        wxPyEndAllowThreads(__tstate);
 
2148
        if (PyErr_Occurred()) SWIG_fail;
 
2149
    }
 
2150
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGLCanvas, 1);
 
2151
    {
 
2152
        if (temp6)
 
2153
        delete arg6;
 
2154
    }
 
2155
    {
 
2156
        delete [] arg7;
 
2157
    }
 
2158
    return resultobj;
 
2159
    fail:
 
2160
    {
 
2161
        if (temp6)
 
2162
        delete arg6;
 
2163
    }
 
2164
    {
 
2165
        delete [] arg7;
 
2166
    }
 
2167
    return NULL;
 
2168
}
 
2169
 
 
2170
 
 
2171
static PyObject *_wrap_new_GLCanvasWithContext(PyObject *, PyObject *args, PyObject *kwargs) {
 
2172
    PyObject *resultobj = NULL;
 
2173
    wxWindow *arg1 = (wxWindow *) 0 ;
 
2174
    wxGLContext *arg2 = (wxGLContext *) NULL ;
 
2175
    int arg3 = (int) -1 ;
 
2176
    wxPoint const &arg4_defvalue = wxDefaultPosition ;
 
2177
    wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
 
2178
    wxSize const &arg5_defvalue = wxDefaultSize ;
 
2179
    wxSize *arg5 = (wxSize *) &arg5_defvalue ;
 
2180
    long arg6 = (long) 0 ;
 
2181
    wxString const &arg7_defvalue = wxPyGLCanvasNameStr ;
 
2182
    wxString *arg7 = (wxString *) &arg7_defvalue ;
 
2183
    int *arg8 = (int *) NULL ;
 
2184
    wxPalette const &arg9_defvalue = wxNullPalette ;
 
2185
    wxPalette *arg9 = (wxPalette *) &arg9_defvalue ;
 
2186
    wxGLCanvas *result;
 
2187
    wxPoint temp4 ;
 
2188
    wxSize temp5 ;
 
2189
    bool temp7 = false ;
 
2190
    int *temp8 ;
 
2191
    PyObject * obj0 = 0 ;
 
2192
    PyObject * obj1 = 0 ;
 
2193
    PyObject * obj2 = 0 ;
 
2194
    PyObject * obj3 = 0 ;
 
2195
    PyObject * obj4 = 0 ;
 
2196
    PyObject * obj5 = 0 ;
 
2197
    PyObject * obj6 = 0 ;
 
2198
    PyObject * obj7 = 0 ;
 
2199
    PyObject * obj8 = 0 ;
 
2200
    char *kwnames[] = {
 
2201
        (char *) "parent",(char *) "shared",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name",(char *) "attribList",(char *) "palette", NULL 
 
2202
    };
 
2203
    
 
2204
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_GLCanvasWithContext",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
 
2205
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
 
2206
    if (SWIG_arg_fail(1)) SWIG_fail;
 
2207
    if (obj1) {
 
2208
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGLContext, SWIG_POINTER_EXCEPTION | 0);
 
2209
        if (SWIG_arg_fail(2)) SWIG_fail;
 
2210
    }
 
2211
    if (obj2) {
 
2212
        {
 
2213
            arg3 = static_cast<int >(SWIG_As_int(obj2)); 
 
2214
            if (SWIG_arg_fail(3)) SWIG_fail;
 
2215
        }
 
2216
    }
 
2217
    if (obj3) {
 
2218
        {
 
2219
            arg4 = &temp4;
 
2220
            if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
 
2221
        }
 
2222
    }
 
2223
    if (obj4) {
 
2224
        {
 
2225
            arg5 = &temp5;
 
2226
            if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
 
2227
        }
 
2228
    }
 
2229
    if (obj5) {
 
2230
        {
 
2231
            arg6 = static_cast<long >(SWIG_As_long(obj5)); 
 
2232
            if (SWIG_arg_fail(6)) SWIG_fail;
 
2233
        }
 
2234
    }
 
2235
    if (obj6) {
 
2236
        {
 
2237
            arg7 = wxString_in_helper(obj6);
 
2238
            if (arg7 == NULL) SWIG_fail;
 
2239
            temp7 = true;
 
2240
        }
 
2241
    }
 
2242
    if (obj7) {
 
2243
        {
 
2244
            int i;
 
2245
            if (PySequence_Check(obj7)) {
 
2246
                int size = PyObject_Length(obj7);
 
2247
                temp8 = new int[size+1]; // (int*)malloc((size + 1) * sizeof(int));
 
2248
                for (i = 0; i < size; i++) {
 
2249
                    temp8[i] = PyInt_AsLong(PySequence_GetItem(obj7, i));
 
2250
                }
 
2251
                temp8[size] = 0;
 
2252
                arg8 = temp8;
 
2253
            }
 
2254
        }
 
2255
    }
 
2256
    if (obj8) {
 
2257
        {
 
2258
            SWIG_Python_ConvertPtr(obj8, (void **)&arg9, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
 
2259
            if (SWIG_arg_fail(9)) SWIG_fail;
 
2260
            if (arg9 == NULL) {
 
2261
                SWIG_null_ref("wxPalette");
 
2262
            }
 
2263
            if (SWIG_arg_fail(9)) SWIG_fail;
 
2264
        }
 
2265
    }
 
2266
    {
 
2267
        if (!wxPyCheckForApp()) SWIG_fail;
 
2268
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
2269
        result = (wxGLCanvas *)new wxGLCanvas(arg1,(wxGLContext const *)arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7,arg8,(wxPalette const &)*arg9);
 
2270
        
 
2271
        wxPyEndAllowThreads(__tstate);
 
2272
        if (PyErr_Occurred()) SWIG_fail;
 
2273
    }
 
2274
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGLCanvas, 1);
 
2275
    {
 
2276
        if (temp7)
 
2277
        delete arg7;
 
2278
    }
 
2279
    {
 
2280
        delete [] arg8;
 
2281
    }
 
2282
    return resultobj;
 
2283
    fail:
 
2284
    {
 
2285
        if (temp7)
 
2286
        delete arg7;
 
2287
    }
 
2288
    {
 
2289
        delete [] arg8;
 
2290
    }
 
2291
    return NULL;
 
2292
}
 
2293
 
 
2294
 
 
2295
static PyObject *_wrap_GLCanvas_SetCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
 
2296
    PyObject *resultobj = NULL;
 
2297
    wxGLCanvas *arg1 = (wxGLCanvas *) 0 ;
 
2298
    PyObject * obj0 = 0 ;
 
2299
    char *kwnames[] = {
 
2300
        (char *) "self", NULL 
 
2301
    };
 
2302
    
 
2303
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GLCanvas_SetCurrent",kwnames,&obj0)) goto fail;
 
2304
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLCanvas, SWIG_POINTER_EXCEPTION | 0);
 
2305
    if (SWIG_arg_fail(1)) SWIG_fail;
 
2306
    {
 
2307
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
2308
        (arg1)->SetCurrent();
 
2309
        
 
2310
        wxPyEndAllowThreads(__tstate);
 
2311
        if (PyErr_Occurred()) SWIG_fail;
 
2312
    }
 
2313
    Py_INCREF(Py_None); resultobj = Py_None;
 
2314
    return resultobj;
 
2315
    fail:
 
2316
    return NULL;
 
2317
}
 
2318
 
 
2319
 
 
2320
static PyObject *_wrap_GLCanvas_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
 
2321
    PyObject *resultobj = NULL;
 
2322
    wxGLCanvas *arg1 = (wxGLCanvas *) 0 ;
 
2323
    wxString *arg2 = 0 ;
 
2324
    bool temp2 = false ;
 
2325
    PyObject * obj0 = 0 ;
 
2326
    PyObject * obj1 = 0 ;
 
2327
    char *kwnames[] = {
 
2328
        (char *) "self",(char *) "colour", NULL 
 
2329
    };
 
2330
    
 
2331
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GLCanvas_SetColour",kwnames,&obj0,&obj1)) goto fail;
 
2332
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLCanvas, SWIG_POINTER_EXCEPTION | 0);
 
2333
    if (SWIG_arg_fail(1)) SWIG_fail;
 
2334
    {
 
2335
        arg2 = wxString_in_helper(obj1);
 
2336
        if (arg2 == NULL) SWIG_fail;
 
2337
        temp2 = true;
 
2338
    }
 
2339
    {
 
2340
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
2341
        (arg1)->SetColour((wxString const &)*arg2);
 
2342
        
 
2343
        wxPyEndAllowThreads(__tstate);
 
2344
        if (PyErr_Occurred()) SWIG_fail;
 
2345
    }
 
2346
    Py_INCREF(Py_None); resultobj = Py_None;
 
2347
    {
 
2348
        if (temp2)
 
2349
        delete arg2;
 
2350
    }
 
2351
    return resultobj;
 
2352
    fail:
 
2353
    {
 
2354
        if (temp2)
 
2355
        delete arg2;
 
2356
    }
 
2357
    return NULL;
 
2358
}
 
2359
 
 
2360
 
 
2361
static PyObject *_wrap_GLCanvas_SwapBuffers(PyObject *, PyObject *args, PyObject *kwargs) {
 
2362
    PyObject *resultobj = NULL;
 
2363
    wxGLCanvas *arg1 = (wxGLCanvas *) 0 ;
 
2364
    PyObject * obj0 = 0 ;
 
2365
    char *kwnames[] = {
 
2366
        (char *) "self", NULL 
 
2367
    };
 
2368
    
 
2369
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GLCanvas_SwapBuffers",kwnames,&obj0)) goto fail;
 
2370
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLCanvas, SWIG_POINTER_EXCEPTION | 0);
 
2371
    if (SWIG_arg_fail(1)) SWIG_fail;
 
2372
    {
 
2373
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
2374
        (arg1)->SwapBuffers();
 
2375
        
 
2376
        wxPyEndAllowThreads(__tstate);
 
2377
        if (PyErr_Occurred()) SWIG_fail;
 
2378
    }
 
2379
    Py_INCREF(Py_None); resultobj = Py_None;
 
2380
    return resultobj;
 
2381
    fail:
 
2382
    return NULL;
 
2383
}
 
2384
 
 
2385
 
 
2386
static PyObject *_wrap_GLCanvas_GetContext(PyObject *, PyObject *args, PyObject *kwargs) {
 
2387
    PyObject *resultobj = NULL;
 
2388
    wxGLCanvas *arg1 = (wxGLCanvas *) 0 ;
 
2389
    wxGLContext *result;
 
2390
    PyObject * obj0 = 0 ;
 
2391
    char *kwnames[] = {
 
2392
        (char *) "self", NULL 
 
2393
    };
 
2394
    
 
2395
    if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GLCanvas_GetContext",kwnames,&obj0)) goto fail;
 
2396
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGLCanvas, SWIG_POINTER_EXCEPTION | 0);
 
2397
    if (SWIG_arg_fail(1)) SWIG_fail;
 
2398
    {
 
2399
        PyThreadState* __tstate = wxPyBeginAllowThreads();
 
2400
        result = (wxGLContext *)(arg1)->GetContext();
 
2401
        
 
2402
        wxPyEndAllowThreads(__tstate);
 
2403
        if (PyErr_Occurred()) SWIG_fail;
 
2404
    }
 
2405
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGLContext, 0);
 
2406
    return resultobj;
 
2407
    fail:
 
2408
    return NULL;
 
2409
}
 
2410
 
 
2411
 
 
2412
static PyObject * GLCanvas_swigregister(PyObject *, PyObject *args) {
 
2413
    PyObject *obj;
 
2414
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
 
2415
    SWIG_TypeClientData(SWIGTYPE_p_wxGLCanvas, obj);
 
2416
    Py_INCREF(obj);
 
2417
    return Py_BuildValue((char *)"");
 
2418
}
 
2419
static PyMethodDef SwigMethods[] = {
 
2420
         { (char *)"new_GLContext", (PyCFunction) _wrap_new_GLContext, METH_VARARGS | METH_KEYWORDS, NULL},
 
2421
         { (char *)"delete_GLContext", (PyCFunction) _wrap_delete_GLContext, METH_VARARGS | METH_KEYWORDS, NULL},
 
2422
         { (char *)"GLContext_SetCurrent", (PyCFunction) _wrap_GLContext_SetCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
 
2423
         { (char *)"GLContext_SetColour", (PyCFunction) _wrap_GLContext_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
2424
         { (char *)"GLContext_SwapBuffers", (PyCFunction) _wrap_GLContext_SwapBuffers, METH_VARARGS | METH_KEYWORDS, NULL},
 
2425
         { (char *)"GLContext_SetupPixelFormat", (PyCFunction) _wrap_GLContext_SetupPixelFormat, METH_VARARGS | METH_KEYWORDS, NULL},
 
2426
         { (char *)"GLContext_SetupPalette", (PyCFunction) _wrap_GLContext_SetupPalette, METH_VARARGS | METH_KEYWORDS, NULL},
 
2427
         { (char *)"GLContext_CreateDefaultPalette", (PyCFunction) _wrap_GLContext_CreateDefaultPalette, METH_VARARGS | METH_KEYWORDS, NULL},
 
2428
         { (char *)"GLContext_GetPalette", (PyCFunction) _wrap_GLContext_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
 
2429
         { (char *)"GLContext_GetWindow", (PyCFunction) _wrap_GLContext_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
 
2430
         { (char *)"GLContext_swigregister", GLContext_swigregister, METH_VARARGS, NULL},
 
2431
         { (char *)"new_GLCanvas", (PyCFunction) _wrap_new_GLCanvas, METH_VARARGS | METH_KEYWORDS, NULL},
 
2432
         { (char *)"new_GLCanvasWithContext", (PyCFunction) _wrap_new_GLCanvasWithContext, METH_VARARGS | METH_KEYWORDS, NULL},
 
2433
         { (char *)"GLCanvas_SetCurrent", (PyCFunction) _wrap_GLCanvas_SetCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
 
2434
         { (char *)"GLCanvas_SetColour", (PyCFunction) _wrap_GLCanvas_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
 
2435
         { (char *)"GLCanvas_SwapBuffers", (PyCFunction) _wrap_GLCanvas_SwapBuffers, METH_VARARGS | METH_KEYWORDS, NULL},
 
2436
         { (char *)"GLCanvas_GetContext", (PyCFunction) _wrap_GLCanvas_GetContext, METH_VARARGS | METH_KEYWORDS, NULL},
 
2437
         { (char *)"GLCanvas_swigregister", GLCanvas_swigregister, METH_VARARGS, NULL},
 
2438
         { NULL, NULL, 0, NULL }
 
2439
};
 
2440
 
 
2441
 
 
2442
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
2443
 
 
2444
static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
 
2445
    return (void *)((wxObject *)  ((wxLayoutConstraints *) x));
 
2446
}
 
2447
static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
 
2448
    return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
 
2449
}
 
2450
static void *_p_wxSizerItemTo_p_wxObject(void *x) {
 
2451
    return (void *)((wxObject *)  ((wxSizerItem *) x));
 
2452
}
 
2453
static void *_p_wxScrollEventTo_p_wxObject(void *x) {
 
2454
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
 
2455
}
 
2456
static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
 
2457
    return (void *)((wxObject *)  ((wxIndividualLayoutConstraint *) x));
 
2458
}
 
2459
static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
 
2460
    return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
 
2461
}
 
2462
static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
 
2463
    return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
 
2464
}
 
2465
static void *_p_wxSizerTo_p_wxObject(void *x) {
 
2466
    return (void *)((wxObject *)  ((wxSizer *) x));
 
2467
}
 
2468
static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
 
2469
    return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
 
2470
}
 
2471
static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
 
2472
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
 
2473
}
 
2474
static void *_p_wxEventTo_p_wxObject(void *x) {
 
2475
    return (void *)((wxObject *)  ((wxEvent *) x));
 
2476
}
 
2477
static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
 
2478
    return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
 
2479
}
 
2480
static void *_p_wxGridSizerTo_p_wxObject(void *x) {
 
2481
    return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
 
2482
}
 
2483
static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
 
2484
    return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
 
2485
}
 
2486
static void *_p_wxPaintEventTo_p_wxObject(void *x) {
 
2487
    return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
 
2488
}
 
2489
static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
 
2490
    return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
 
2491
}
 
2492
static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
 
2493
    return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
 
2494
}
 
2495
static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
 
2496
    return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
 
2497
}
 
2498
static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
 
2499
    return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
 
2500
}
 
2501
static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
 
2502
    return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
 
2503
}
 
2504
static void *_p_wxControlTo_p_wxObject(void *x) {
 
2505
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
 
2506
}
 
2507
static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
 
2508
    return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
 
2509
}
 
2510
static void *_p_wxFSFileTo_p_wxObject(void *x) {
 
2511
    return (void *)((wxObject *)  ((wxFSFile *) x));
 
2512
}
 
2513
static void *_p_wxPySizerTo_p_wxObject(void *x) {
 
2514
    return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
 
2515
}
 
2516
static void *_p_wxPyEventTo_p_wxObject(void *x) {
 
2517
    return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
 
2518
}
 
2519
static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
 
2520
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
 
2521
}
 
2522
static void *_p_wxGLContextTo_p_wxObject(void *x) {
 
2523
    return (void *)((wxObject *)  ((wxGLContext *) x));
 
2524
}
 
2525
static void *_p_wxShowEventTo_p_wxObject(void *x) {
 
2526
    return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
 
2527
}
 
2528
static void *_p_wxMenuItemTo_p_wxObject(void *x) {
 
2529
    return (void *)((wxObject *)  ((wxMenuItem *) x));
 
2530
}
 
2531
static void *_p_wxDateEventTo_p_wxObject(void *x) {
 
2532
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
 
2533
}
 
2534
static void *_p_wxIdleEventTo_p_wxObject(void *x) {
 
2535
    return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
 
2536
}
 
2537
static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
 
2538
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
 
2539
}
 
2540
static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
 
2541
    return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
 
2542
}
 
2543
static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
 
2544
    return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
 
2545
}
 
2546
static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
 
2547
    return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
 
2548
}
 
2549
static void *_p_wxSizeEventTo_p_wxObject(void *x) {
 
2550
    return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
 
2551
}
 
2552
static void *_p_wxMoveEventTo_p_wxObject(void *x) {
 
2553
    return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
 
2554
}
 
2555
static void *_p_wxActivateEventTo_p_wxObject(void *x) {
 
2556
    return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
 
2557
}
 
2558
static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
 
2559
    return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
 
2560
}
 
2561
static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
 
2562
    return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
 
2563
}
 
2564
static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
 
2565
    return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
 
2566
}
 
2567
static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
 
2568
    return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
 
2569
}
 
2570
static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
 
2571
    return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
 
2572
}
 
2573
static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
 
2574
    return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
 
2575
}
 
2576
static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
 
2577
    return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
 
2578
}
 
2579
static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
 
2580
    return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
 
2581
}
 
2582
static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
 
2583
    return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
 
2584
}
 
2585
static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
 
2586
    return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
 
2587
}
 
2588
static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
 
2589
    return (void *)((wxObject *)  ((wxImageHandler *) x));
 
2590
}
 
2591
static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
 
2592
    return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
 
2593
}
 
2594
static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
 
2595
    return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
 
2596
}
 
2597
static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
 
2598
    return (void *)((wxObject *)  ((wxEvtHandler *) x));
 
2599
}
 
2600
static void *_p_wxGLCanvasTo_p_wxObject(void *x) {
 
2601
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxGLCanvas *) x));
 
2602
}
 
2603
static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
 
2604
    return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
 
2605
}
 
2606
static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
 
2607
    return (void *)((wxObject *)  ((wxAcceleratorTable *) x));
 
2608
}
 
2609
static void *_p_wxImageTo_p_wxObject(void *x) {
 
2610
    return (void *)((wxObject *)  ((wxImage *) x));
 
2611
}
 
2612
static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
 
2613
    return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
 
2614
}
 
2615
static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
 
2616
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
 
2617
}
 
2618
static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
 
2619
    return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
 
2620
}
 
2621
static void *_p_wxKeyEventTo_p_wxObject(void *x) {
 
2622
    return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
 
2623
}
 
2624
static void *_p_wxWindowTo_p_wxObject(void *x) {
 
2625
    return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
 
2626
}
 
2627
static void *_p_wxMenuTo_p_wxObject(void *x) {
 
2628
    return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
 
2629
}
 
2630
static void *_p_wxMenuBarTo_p_wxObject(void *x) {
 
2631
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
 
2632
}
 
2633
static void *_p_wxFileSystemTo_p_wxObject(void *x) {
 
2634
    return (void *)((wxObject *)  ((wxFileSystem *) x));
 
2635
}
 
2636
static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
 
2637
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
 
2638
}
 
2639
static void *_p_wxMenuEventTo_p_wxObject(void *x) {
 
2640
    return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
 
2641
}
 
2642
static void *_p_wxPyAppTo_p_wxObject(void *x) {
 
2643
    return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
 
2644
}
 
2645
static void *_p_wxCloseEventTo_p_wxObject(void *x) {
 
2646
    return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
 
2647
}
 
2648
static void *_p_wxMouseEventTo_p_wxObject(void *x) {
 
2649
    return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
 
2650
}
 
2651
static void *_p_wxEraseEventTo_p_wxObject(void *x) {
 
2652
    return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
 
2653
}
 
2654
static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
 
2655
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
 
2656
}
 
2657
static void *_p_wxCommandEventTo_p_wxObject(void *x) {
 
2658
    return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
 
2659
}
 
2660
static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
 
2661
    return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
 
2662
}
 
2663
static void *_p_wxFocusEventTo_p_wxObject(void *x) {
 
2664
    return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
 
2665
}
 
2666
static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
 
2667
    return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
 
2668
}
 
2669
static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
 
2670
    return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
 
2671
}
 
2672
static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
 
2673
    return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
 
2674
}
 
2675
static void *_p_wxValidatorTo_p_wxObject(void *x) {
 
2676
    return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
 
2677
}
 
2678
static void *_p_wxControlTo_p_wxWindow(void *x) {
 
2679
    return (void *)((wxWindow *)  ((wxControl *) x));
 
2680
}
 
2681
static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
 
2682
    return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
 
2683
}
 
2684
static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
 
2685
    return (void *)((wxWindow *)  ((wxMenuBar *) x));
 
2686
}
 
2687
static void *_p_wxGLCanvasTo_p_wxWindow(void *x) {
 
2688
    return (void *)((wxWindow *)  ((wxGLCanvas *) x));
 
2689
}
 
2690
static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
 
2691
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
 
2692
}
 
2693
static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
 
2694
    return (void *)((wxEvtHandler *)  ((wxWindow *) x));
 
2695
}
 
2696
static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
 
2697
    return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
 
2698
}
 
2699
static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
 
2700
    return (void *)((wxEvtHandler *)  ((wxPyApp *) x));
 
2701
}
 
2702
static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
 
2703
    return (void *)((wxEvtHandler *)  ((wxValidator *) x));
 
2704
}
 
2705
static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
 
2706
    return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
 
2707
}
 
2708
static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
 
2709
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
 
2710
}
 
2711
static void *_p_wxGLCanvasTo_p_wxEvtHandler(void *x) {
 
2712
    return (void *)((wxEvtHandler *) (wxWindow *) ((wxGLCanvas *) x));
 
2713
}
 
2714
static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
 
2715
    return (void *)((wxEvtHandler *)  ((wxMenu *) x));
 
2716
}
 
2717
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
 
2718
static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
 
2719
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
 
2720
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
 
2721
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
 
2722
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
 
2723
static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
 
2724
static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
 
2725
static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0};
 
2726
static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0};
 
2727
static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0};
 
2728
static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0};
 
2729
static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0};
 
2730
static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0};
 
2731
static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0};
 
2732
static swig_type_info _swigt__p_wxGLCanvas = {"_p_wxGLCanvas", "wxGLCanvas *", 0, 0, 0};
 
2733
static swig_type_info _swigt__p_wxGLContext = {"_p_wxGLContext", "wxGLContext *", 0, 0, 0};
 
2734
static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
 
2735
static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0};
 
2736
static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0};
 
2737
static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0};
 
2738
static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0};
 
2739
static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0};
 
2740
static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0};
 
2741
static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0};
 
2742
static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0};
 
2743
static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0};
 
2744
static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0};
 
2745
static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", 0, 0, 0, 0};
 
2746
static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0};
 
2747
static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0};
 
2748
static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0};
 
2749
static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0};
 
2750
static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0};
 
2751
static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0};
 
2752
static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0};
 
2753
static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0};
 
2754
static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0};
 
2755
static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0};
 
2756
static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0};
 
2757
static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0};
 
2758
static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0};
 
2759
static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0};
 
2760
static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0};
 
2761
static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0};
 
2762
static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0};
 
2763
static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0};
 
2764
static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0};
 
2765
static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0};
 
2766
static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0};
 
2767
static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0};
 
2768
static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0};
 
2769
static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0};
 
2770
static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0};
 
2771
static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0};
 
2772
static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0};
 
2773
static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0};
 
2774
static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0};
 
2775
static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0};
 
2776
static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0};
 
2777
static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0};
 
2778
static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0};
 
2779
static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0};
 
2780
static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0};
 
2781
static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0};
 
2782
static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0};
 
2783
static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0};
 
2784
static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0};
 
2785
static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0};
 
2786
static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0};
 
2787
static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0};
 
2788
static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0};
 
2789
static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0};
 
2790
static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0};
 
2791
static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0};
 
2792
static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0};
 
2793
static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0};
 
2794
static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0};
 
2795
static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0};
 
2796
static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0};
 
2797
static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0};
 
2798
static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0};
 
2799
static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0};
 
2800
static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0};
 
2801
static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0};
 
2802
static swig_type_info _swigt__p_wxPalette = {"_p_wxPalette", "wxPalette *", 0, 0, 0};
 
2803
static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
 
2804
static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
 
2805
static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
 
2806
static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
 
2807
static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
 
2808
 
 
2809
static swig_type_info *swig_type_initial[] = {
 
2810
  &_swigt__p_char,
 
2811
  &_swigt__p_form_ops_t,
 
2812
  &_swigt__p_int,
 
2813
  &_swigt__p_unsigned_char,
 
2814
  &_swigt__p_unsigned_int,
 
2815
  &_swigt__p_unsigned_long,
 
2816
  &_swigt__p_wxANIHandler,
 
2817
  &_swigt__p_wxAcceleratorTable,
 
2818
  &_swigt__p_wxActivateEvent,
 
2819
  &_swigt__p_wxBMPHandler,
 
2820
  &_swigt__p_wxBoxSizer,
 
2821
  &_swigt__p_wxCURHandler,
 
2822
  &_swigt__p_wxChildFocusEvent,
 
2823
  &_swigt__p_wxCloseEvent,
 
2824
  &_swigt__p_wxCommandEvent,
 
2825
  &_swigt__p_wxContextMenuEvent,
 
2826
  &_swigt__p_wxControl,
 
2827
  &_swigt__p_wxControlWithItems,
 
2828
  &_swigt__p_wxDateEvent,
 
2829
  &_swigt__p_wxDisplayChangedEvent,
 
2830
  &_swigt__p_wxDropFilesEvent,
 
2831
  &_swigt__p_wxDuplexMode,
 
2832
  &_swigt__p_wxEraseEvent,
 
2833
  &_swigt__p_wxEvent,
 
2834
  &_swigt__p_wxEvtHandler,
 
2835
  &_swigt__p_wxFSFile,
 
2836
  &_swigt__p_wxFileSystem,
 
2837
  &_swigt__p_wxFlexGridSizer,
 
2838
  &_swigt__p_wxFocusEvent,
 
2839
  &_swigt__p_wxGBSizerItem,
 
2840
  &_swigt__p_wxGIFHandler,
 
2841
  &_swigt__p_wxGLCanvas,
 
2842
  &_swigt__p_wxGLContext,
 
2843
  &_swigt__p_wxGridBagSizer,
 
2844
  &_swigt__p_wxGridSizer,
 
2845
  &_swigt__p_wxICOHandler,
 
2846
  &_swigt__p_wxIconizeEvent,
 
2847
  &_swigt__p_wxIdleEvent,
 
2848
  &_swigt__p_wxImage,
 
2849
  &_swigt__p_wxImageHandler,
 
2850
  &_swigt__p_wxIndividualLayoutConstraint,
 
2851
  &_swigt__p_wxInitDialogEvent,
 
2852
  &_swigt__p_wxJPEGHandler,
 
2853
  &_swigt__p_wxKeyEvent,
 
2854
  &_swigt__p_wxLayoutConstraints,
 
2855
  &_swigt__p_wxMaximizeEvent,
 
2856
  &_swigt__p_wxMenu,
 
2857
  &_swigt__p_wxMenuBar,
 
2858
  &_swigt__p_wxMenuEvent,
 
2859
  &_swigt__p_wxMenuItem,
 
2860
  &_swigt__p_wxMouseCaptureChangedEvent,
 
2861
  &_swigt__p_wxMouseEvent,
 
2862
  &_swigt__p_wxMoveEvent,
 
2863
  &_swigt__p_wxNavigationKeyEvent,
 
2864
  &_swigt__p_wxNcPaintEvent,
 
2865
  &_swigt__p_wxNotifyEvent,
 
2866
  &_swigt__p_wxObject,
 
2867
  &_swigt__p_wxPCXHandler,
 
2868
  &_swigt__p_wxPNGHandler,
 
2869
  &_swigt__p_wxPNMHandler,
 
2870
  &_swigt__p_wxPaintEvent,
 
2871
  &_swigt__p_wxPalette,
 
2872
  &_swigt__p_wxPaletteChangedEvent,
 
2873
  &_swigt__p_wxPaperSize,
 
2874
  &_swigt__p_wxPyApp,
 
2875
  &_swigt__p_wxPyCommandEvent,
 
2876
  &_swigt__p_wxPyEvent,
 
2877
  &_swigt__p_wxPyImageHandler,
 
2878
  &_swigt__p_wxPySizer,
 
2879
  &_swigt__p_wxPyValidator,
 
2880
  &_swigt__p_wxQueryNewPaletteEvent,
 
2881
  &_swigt__p_wxScrollEvent,
 
2882
  &_swigt__p_wxScrollWinEvent,
 
2883
  &_swigt__p_wxSetCursorEvent,
 
2884
  &_swigt__p_wxShowEvent,
 
2885
  &_swigt__p_wxSizeEvent,
 
2886
  &_swigt__p_wxSizer,
 
2887
  &_swigt__p_wxSizerItem,
 
2888
  &_swigt__p_wxStaticBoxSizer,
 
2889
  &_swigt__p_wxStdDialogButtonSizer,
 
2890
  &_swigt__p_wxSysColourChangedEvent,
 
2891
  &_swigt__p_wxTIFFHandler,
 
2892
  &_swigt__p_wxUpdateUIEvent,
 
2893
  &_swigt__p_wxValidator,
 
2894
  &_swigt__p_wxWindow,
 
2895
  &_swigt__p_wxWindowCreateEvent,
 
2896
  &_swigt__p_wxWindowDestroyEvent,
 
2897
  &_swigt__p_wxXPMHandler,
 
2898
  &_swigt__ptrdiff_t,
 
2899
  &_swigt__std__ptrdiff_t,
 
2900
  &_swigt__unsigned_int,
 
2901
};
 
2902
 
 
2903
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
 
2904
static swig_cast_info _swigc__p_form_ops_t[] = {  {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
 
2905
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
 
2906
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
 
2907
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
 
2908
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
 
2909
static swig_cast_info _swigc__p_wxDuplexMode[] = {  {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
 
2910
static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
 
2911
static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
 
2912
static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
 
2913
static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
 
2914
static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
 
2915
static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
 
2916
static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
 
2917
static swig_cast_info _swigc__p_wxEvtHandler[] = {  {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxEvtHandler, 0, 0, 0},  {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxGLCanvas, _p_wxGLCanvasTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0},  {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
 
2918
static swig_cast_info _swigc__p_wxGLCanvas[] = {  {&_swigt__p_wxGLCanvas, 0, 0, 0},{0, 0, 0, 0}};
 
2919
static swig_cast_info _swigc__p_wxGLContext[] = {  {&_swigt__p_wxGLContext, 0, 0, 0},{0, 0, 0, 0}};
 
2920
static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
 
2921
static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
 
2922
static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
 
2923
static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2924
static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
 
2925
static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
 
2926
static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
 
2927
static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
 
2928
static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
 
2929
static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2930
static swig_cast_info _swigc__p_wxEvent[] = {{&_swigt__p_wxEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2931
static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
 
2932
static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
 
2933
static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2934
static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2935
static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2936
static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2937
static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2938
static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2939
static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2940
static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2941
static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
 
2942
static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
 
2943
static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2944
static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2945
static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2946
static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
 
2947
static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2948
static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2949
static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2950
static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2951
static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2952
static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2953
static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2954
static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2955
static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2956
static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2957
static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2958
static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2959
static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2960
static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2961
static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2962
static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2963
static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2964
static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2965
static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2966
static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2967
static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2968
static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
 
2969
static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
 
2970
static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
 
2971
static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
 
2972
static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2973
static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2974
static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2975
static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2976
static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
 
2977
static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2978
static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2979
static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2980
static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2981
static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2982
static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2983
static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2984
static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2985
static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2986
static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
 
2987
static swig_cast_info _swigc__p_wxObject[] = {  {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0},  {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0},  {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0},  {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0},  {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_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_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0},  {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0},  {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxGLContext, _p_wxGLContextTo_p_wxObject, 0, 0},  {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0},  {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxDateEvent, _p_wxDateEventTo_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_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_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_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0},  {&_swigt__p_wxGLCanvas, _p_wxGLCanvasTo_p_wxObject, 0, 0},  {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0},  {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0},  {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0},  {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxObject, 0, 0, 0},  {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0},  {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_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_wxPyApp, _p_wxPyAppTo_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_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0},  {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},  {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
 
2988
static swig_cast_info _swigc__p_wxPalette[] = {  {&_swigt__p_wxPalette, 0, 0, 0},{0, 0, 0, 0}};
 
2989
static swig_cast_info _swigc__p_wxPaperSize[] = {  {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
 
2990
static swig_cast_info _swigc__p_wxWindow[] = {  {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0},  {&_swigt__p_wxWindow, 0, 0, 0},  {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0},  {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},  {&_swigt__p_wxGLCanvas, _p_wxGLCanvasTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
 
2991
static swig_cast_info _swigc__ptrdiff_t[] = {  {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
 
2992
static swig_cast_info _swigc__std__ptrdiff_t[] = {  {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
 
2993
static swig_cast_info _swigc__unsigned_int[] = {  {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
 
2994
 
 
2995
static swig_cast_info *swig_cast_initial[] = {
 
2996
  _swigc__p_char,
 
2997
  _swigc__p_form_ops_t,
 
2998
  _swigc__p_int,
 
2999
  _swigc__p_unsigned_char,
 
3000
  _swigc__p_unsigned_int,
 
3001
  _swigc__p_unsigned_long,
 
3002
  _swigc__p_wxANIHandler,
 
3003
  _swigc__p_wxAcceleratorTable,
 
3004
  _swigc__p_wxActivateEvent,
 
3005
  _swigc__p_wxBMPHandler,
 
3006
  _swigc__p_wxBoxSizer,
 
3007
  _swigc__p_wxCURHandler,
 
3008
  _swigc__p_wxChildFocusEvent,
 
3009
  _swigc__p_wxCloseEvent,
 
3010
  _swigc__p_wxCommandEvent,
 
3011
  _swigc__p_wxContextMenuEvent,
 
3012
  _swigc__p_wxControl,
 
3013
  _swigc__p_wxControlWithItems,
 
3014
  _swigc__p_wxDateEvent,
 
3015
  _swigc__p_wxDisplayChangedEvent,
 
3016
  _swigc__p_wxDropFilesEvent,
 
3017
  _swigc__p_wxDuplexMode,
 
3018
  _swigc__p_wxEraseEvent,
 
3019
  _swigc__p_wxEvent,
 
3020
  _swigc__p_wxEvtHandler,
 
3021
  _swigc__p_wxFSFile,
 
3022
  _swigc__p_wxFileSystem,
 
3023
  _swigc__p_wxFlexGridSizer,
 
3024
  _swigc__p_wxFocusEvent,
 
3025
  _swigc__p_wxGBSizerItem,
 
3026
  _swigc__p_wxGIFHandler,
 
3027
  _swigc__p_wxGLCanvas,
 
3028
  _swigc__p_wxGLContext,
 
3029
  _swigc__p_wxGridBagSizer,
 
3030
  _swigc__p_wxGridSizer,
 
3031
  _swigc__p_wxICOHandler,
 
3032
  _swigc__p_wxIconizeEvent,
 
3033
  _swigc__p_wxIdleEvent,
 
3034
  _swigc__p_wxImage,
 
3035
  _swigc__p_wxImageHandler,
 
3036
  _swigc__p_wxIndividualLayoutConstraint,
 
3037
  _swigc__p_wxInitDialogEvent,
 
3038
  _swigc__p_wxJPEGHandler,
 
3039
  _swigc__p_wxKeyEvent,
 
3040
  _swigc__p_wxLayoutConstraints,
 
3041
  _swigc__p_wxMaximizeEvent,
 
3042
  _swigc__p_wxMenu,
 
3043
  _swigc__p_wxMenuBar,
 
3044
  _swigc__p_wxMenuEvent,
 
3045
  _swigc__p_wxMenuItem,
 
3046
  _swigc__p_wxMouseCaptureChangedEvent,
 
3047
  _swigc__p_wxMouseEvent,
 
3048
  _swigc__p_wxMoveEvent,
 
3049
  _swigc__p_wxNavigationKeyEvent,
 
3050
  _swigc__p_wxNcPaintEvent,
 
3051
  _swigc__p_wxNotifyEvent,
 
3052
  _swigc__p_wxObject,
 
3053
  _swigc__p_wxPCXHandler,
 
3054
  _swigc__p_wxPNGHandler,
 
3055
  _swigc__p_wxPNMHandler,
 
3056
  _swigc__p_wxPaintEvent,
 
3057
  _swigc__p_wxPalette,
 
3058
  _swigc__p_wxPaletteChangedEvent,
 
3059
  _swigc__p_wxPaperSize,
 
3060
  _swigc__p_wxPyApp,
 
3061
  _swigc__p_wxPyCommandEvent,
 
3062
  _swigc__p_wxPyEvent,
 
3063
  _swigc__p_wxPyImageHandler,
 
3064
  _swigc__p_wxPySizer,
 
3065
  _swigc__p_wxPyValidator,
 
3066
  _swigc__p_wxQueryNewPaletteEvent,
 
3067
  _swigc__p_wxScrollEvent,
 
3068
  _swigc__p_wxScrollWinEvent,
 
3069
  _swigc__p_wxSetCursorEvent,
 
3070
  _swigc__p_wxShowEvent,
 
3071
  _swigc__p_wxSizeEvent,
 
3072
  _swigc__p_wxSizer,
 
3073
  _swigc__p_wxSizerItem,
 
3074
  _swigc__p_wxStaticBoxSizer,
 
3075
  _swigc__p_wxStdDialogButtonSizer,
 
3076
  _swigc__p_wxSysColourChangedEvent,
 
3077
  _swigc__p_wxTIFFHandler,
 
3078
  _swigc__p_wxUpdateUIEvent,
 
3079
  _swigc__p_wxValidator,
 
3080
  _swigc__p_wxWindow,
 
3081
  _swigc__p_wxWindowCreateEvent,
 
3082
  _swigc__p_wxWindowDestroyEvent,
 
3083
  _swigc__p_wxXPMHandler,
 
3084
  _swigc__ptrdiff_t,
 
3085
  _swigc__std__ptrdiff_t,
 
3086
  _swigc__unsigned_int,
 
3087
};
 
3088
 
 
3089
 
 
3090
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
 
3091
 
 
3092
static swig_const_info swig_const_table[] = {
 
3093
{0, 0, 0, 0.0, 0, 0}};
 
3094
 
 
3095
#ifdef __cplusplus
 
3096
}
 
3097
#endif
 
3098
/*************************************************************************
 
3099
 * Type initialization:
 
3100
 * This problem is tough by the requirement that no dynamic 
 
3101
 * memory is used. Also, since swig_type_info structures store pointers to 
 
3102
 * swig_cast_info structures and swig_cast_info structures store pointers back
 
3103
 * to swig_type_info structures, we need some lookup code at initialization. 
 
3104
 * The idea is that swig generates all the structures that are needed. 
 
3105
 * The runtime then collects these partially filled structures. 
 
3106
 * The SWIG_InitializeModule function takes these initial arrays out of 
 
3107
 * swig_module, and does all the lookup, filling in the swig_module.types
 
3108
 * array with the correct data and linking the correct swig_cast_info
 
3109
 * structures together.
 
3110
 
 
3111
 * The generated swig_type_info structures are assigned staticly to an initial 
 
3112
 * array. We just loop though that array, and handle each type individually.
 
3113
 * First we lookup if this type has been already loaded, and if so, use the
 
3114
 * loaded structure instead of the generated one. Then we have to fill in the
 
3115
 * cast linked list. The cast data is initially stored in something like a
 
3116
 * two-dimensional array. Each row corresponds to a type (there are the same
 
3117
 * number of rows as there are in the swig_type_initial array). Each entry in
 
3118
 * a column is one of the swig_cast_info structures for that type.
 
3119
 * The cast_initial array is actually an array of arrays, because each row has
 
3120
 * a variable number of columns. So to actually build the cast linked list,
 
3121
 * we find the array of casts associated with the type, and loop through it 
 
3122
 * adding the casts to the list. The one last trick we need to do is making
 
3123
 * sure the type pointer in the swig_cast_info struct is correct.
 
3124
 
 
3125
 * First off, we lookup the cast->type name to see if it is already loaded. 
 
3126
 * There are three cases to handle:
 
3127
 *  1) If the cast->type has already been loaded AND the type we are adding
 
3128
 *     casting info to has not been loaded (it is in this module), THEN we
 
3129
 *     replace the cast->type pointer with the type pointer that has already
 
3130
 *     been loaded.
 
3131
 *  2) If BOTH types (the one we are adding casting info to, and the 
 
3132
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 
3133
 *     the previous module so we just ignore it.
 
3134
 *  3) Finally, if cast->type has not already been loaded, then we add that
 
3135
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 
3136
 *     be correct.
 
3137
**/
 
3138
 
 
3139
#ifdef __cplusplus
 
3140
extern "C" {
 
3141
#if 0
 
3142
} /* c-mode */
 
3143
#endif
 
3144
#endif
 
3145
 
 
3146
#if 0
 
3147
#define SWIGRUNTIME_DEBUG
 
3148
#endif
 
3149
 
 
3150
SWIGRUNTIME void
 
3151
SWIG_InitializeModule(void *clientdata) {
 
3152
    size_t i;
 
3153
    swig_module_info *module_head;
 
3154
    static int init_run = 0;
 
3155
    
 
3156
    clientdata = clientdata;
 
3157
    
 
3158
    if (init_run) return;
 
3159
    init_run = 1;
 
3160
    
 
3161
    /* Initialize the swig_module */
 
3162
    swig_module.type_initial = swig_type_initial;
 
3163
    swig_module.cast_initial = swig_cast_initial;
 
3164
    
 
3165
    /* Try and load any already created modules */
 
3166
    module_head = SWIG_GetModule(clientdata);
 
3167
    if (module_head) {
 
3168
        swig_module.next = module_head->next;
 
3169
        module_head->next = &swig_module;
 
3170
    } else {
 
3171
        /* This is the first module loaded */
 
3172
        swig_module.next = &swig_module;
 
3173
        SWIG_SetModule(clientdata, &swig_module);
 
3174
    }
 
3175
    
 
3176
    /* Now work on filling in swig_module.types */
 
3177
#ifdef SWIGRUNTIME_DEBUG
 
3178
    printf("SWIG_InitializeModule: size %d\n", swig_module.size);
 
3179
#endif
 
3180
    for (i = 0; i < swig_module.size; ++i) {
 
3181
        swig_type_info *type = 0;
 
3182
        swig_type_info *ret;
 
3183
        swig_cast_info *cast;
 
3184
        
 
3185
#ifdef SWIGRUNTIME_DEBUG
 
3186
        printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
 
3187
#endif
 
3188
        
 
3189
        /* if there is another module already loaded */
 
3190
        if (swig_module.next != &swig_module) {
 
3191
            type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
 
3192
        }
 
3193
        if (type) {
 
3194
            /* Overwrite clientdata field */
 
3195
#ifdef SWIGRUNTIME_DEBUG
 
3196
            printf("SWIG_InitializeModule: found type %s\n", type->name);
 
3197
#endif
 
3198
            if (swig_module.type_initial[i]->clientdata) {
 
3199
                type->clientdata = swig_module.type_initial[i]->clientdata;
 
3200
#ifdef SWIGRUNTIME_DEBUG
 
3201
                printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
 
3202
#endif
 
3203
            }
 
3204
        } else {
 
3205
            type = swig_module.type_initial[i];
 
3206
        }
 
3207
        
 
3208
        /* Insert casting types */
 
3209
        cast = swig_module.cast_initial[i];
 
3210
        while (cast->type) {
 
3211
            /* Don't need to add information already in the list */
 
3212
            ret = 0;
 
3213
#ifdef SWIGRUNTIME_DEBUG
 
3214
            printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
 
3215
#endif
 
3216
            if (swig_module.next != &swig_module) {
 
3217
                ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
 
3218
#ifdef SWIGRUNTIME_DEBUG
 
3219
                if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
 
3220
#endif
 
3221
            }
 
3222
            if (ret) {
 
3223
                if (type == swig_module.type_initial[i]) {
 
3224
#ifdef SWIGRUNTIME_DEBUG
 
3225
                    printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
 
3226
#endif
 
3227
                    cast->type = ret;
 
3228
                    ret = 0;
 
3229
                } else {
 
3230
                    /* Check for casting already in the list */
 
3231
                    swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
 
3232
#ifdef SWIGRUNTIME_DEBUG
 
3233
                    if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
 
3234
#endif
 
3235
                    if (!ocast) ret = 0;
 
3236
                }
 
3237
            }
 
3238
            
 
3239
            if (!ret) {
 
3240
#ifdef SWIGRUNTIME_DEBUG
 
3241
                printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
 
3242
#endif
 
3243
                if (type->cast) {
 
3244
                    type->cast->prev = cast;
 
3245
                    cast->next = type->cast;
 
3246
                }
 
3247
                type->cast = cast;
 
3248
            }
 
3249
            cast++;
 
3250
        }
 
3251
        /* Set entry in modules->types array equal to the type */
 
3252
        swig_module.types[i] = type;
 
3253
    }
 
3254
    swig_module.types[i] = 0;
 
3255
    
 
3256
#ifdef SWIGRUNTIME_DEBUG
 
3257
    printf("**** SWIG_InitializeModule: Cast List ******\n");
 
3258
    for (i = 0; i < swig_module.size; ++i) {
 
3259
        int j = 0;
 
3260
        swig_cast_info *cast = swig_module.cast_initial[i];
 
3261
        printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
 
3262
        while (cast->type) {
 
3263
            printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
 
3264
            cast++;
 
3265
            ++j;
 
3266
        }
 
3267
        printf("---- Total casts: %d\n",j);
 
3268
    }
 
3269
    printf("**** SWIG_InitializeModule: Cast List ******\n");
 
3270
#endif
 
3271
}
 
3272
 
 
3273
/* This function will propagate the clientdata field of type to
 
3274
* any new swig_type_info structures that have been added into the list
 
3275
* of equivalent types.  It is like calling
 
3276
* SWIG_TypeClientData(type, clientdata) a second time.
 
3277
*/
 
3278
SWIGRUNTIME void
 
3279
SWIG_PropagateClientData(void) {
 
3280
    size_t i;
 
3281
    swig_cast_info *equiv;
 
3282
    static int init_run = 0;
 
3283
    
 
3284
    if (init_run) return;
 
3285
    init_run = 1;
 
3286
    
 
3287
    for (i = 0; i < swig_module.size; i++) {
 
3288
        if (swig_module.types[i]->clientdata) {
 
3289
            equiv = swig_module.types[i]->cast;
 
3290
            while (equiv) {
 
3291
                if (!equiv->converter) {
 
3292
                    if (equiv->type && !equiv->type->clientdata)
 
3293
                    SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
 
3294
                }
 
3295
                equiv = equiv->next;
 
3296
            }
 
3297
        }
 
3298
    }
 
3299
}
 
3300
 
 
3301
#ifdef __cplusplus
 
3302
#if 0
 
3303
{
 
3304
    /* c-mode */
 
3305
#endif
 
3306
}
 
3307
#endif
 
3308
 
 
3309
 
 
3310
 
 
3311
#ifdef __cplusplus
 
3312
extern "C" {
 
3313
#endif
 
3314
    
 
3315
    /* Python-specific SWIG API */
 
3316
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
 
3317
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
 
3318
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
3319
    
 
3320
    /* -----------------------------------------------------------------------------
 
3321
     * global variable support code.
 
3322
     * ----------------------------------------------------------------------------- */
 
3323
    
 
3324
    typedef struct swig_globalvar {
 
3325
        char       *name;                  /* Name of global variable */
 
3326
        PyObject *(*get_attr)(void);       /* Return the current value */
 
3327
        int       (*set_attr)(PyObject *); /* Set the value */
 
3328
        struct swig_globalvar *next;
 
3329
    } swig_globalvar;
 
3330
    
 
3331
    typedef struct swig_varlinkobject {
 
3332
        PyObject_HEAD
 
3333
        swig_globalvar *vars;
 
3334
    } swig_varlinkobject;
 
3335
    
 
3336
    SWIGINTERN PyObject *
 
3337
    swig_varlink_repr(swig_varlinkobject *v) {
 
3338
        v = v;
 
3339
        return PyString_FromString("<Swig global variables>");
 
3340
    }
 
3341
    
 
3342
    SWIGINTERN int
 
3343
    swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
 
3344
        swig_globalvar  *var;
 
3345
        flags = flags;
 
3346
        fprintf(fp,"Swig global variables { ");
 
3347
        for (var = v->vars; var; var=var->next) {
 
3348
            fprintf(fp,"%s", var->name);
 
3349
            if (var->next) fprintf(fp,", ");
 
3350
        }
 
3351
        fprintf(fp," }\n");
 
3352
        return 0;
 
3353
    }
 
3354
    
 
3355
    SWIGINTERN PyObject *
 
3356
    swig_varlink_getattr(swig_varlinkobject *v, char *n) {
 
3357
        swig_globalvar *var = v->vars;
 
3358
        while (var) {
 
3359
            if (strcmp(var->name,n) == 0) {
 
3360
                return (*var->get_attr)();
 
3361
            }
 
3362
            var = var->next;
 
3363
        }
 
3364
        PyErr_SetString(PyExc_NameError,"Unknown C global variable");
 
3365
        return NULL;
 
3366
    }
 
3367
    
 
3368
    SWIGINTERN int
 
3369
    swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
 
3370
        swig_globalvar *var = v->vars;
 
3371
        while (var) {
 
3372
            if (strcmp(var->name,n) == 0) {
 
3373
                return (*var->set_attr)(p);
 
3374
            }
 
3375
            var = var->next;
 
3376
        }
 
3377
        PyErr_SetString(PyExc_NameError,"Unknown C global variable");
 
3378
        return 1;
 
3379
    }
 
3380
    
 
3381
    SWIGINTERN PyTypeObject*
 
3382
    swig_varlink_type(void) {
 
3383
        static char varlink__doc__[] = "Swig var link object";
 
3384
        static PyTypeObject varlink_type
 
3385
#if !defined(__cplusplus)
 
3386
        ;
 
3387
        static int type_init = 0;  
 
3388
        if (!type_init) {
 
3389
            PyTypeObject tmp
 
3390
#endif
 
3391
            = {
 
3392
                PyObject_HEAD_INIT(&PyType_Type)
 
3393
                0,                                  /* Number of items in variable part (ob_size) */
 
3394
                (char *)"swigvarlink",              /* Type name (tp_name) */
 
3395
                sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
 
3396
                0,                                  /* Itemsize (tp_itemsize) */
 
3397
                0,                                  /* Deallocator (tp_dealloc) */ 
 
3398
                (printfunc) swig_varlink_print,     /* Print (tp_print) */
 
3399
                (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
 
3400
                (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
 
3401
                0,                                  /* tp_compare */
 
3402
                (reprfunc) swig_varlink_repr,       /* tp_repr */
 
3403
                0,                                  /* tp_as_number */
 
3404
                0,                                  /* tp_as_sequence */
 
3405
                0,                                  /* tp_as_mapping */
 
3406
                0,                                  /* tp_hash */
 
3407
                0,                                  /* tp_call */
 
3408
                0,                                  /* tp_str */
 
3409
                0,                                  /* tp_getattro */
 
3410
                0,                                  /* tp_setattro */
 
3411
                0,                                  /* tp_as_buffer */
 
3412
                0,                                  /* tp_flags */
 
3413
                varlink__doc__,                     /* tp_doc */
 
3414
#if PY_VERSION_HEX >= 0x02000000
 
3415
                0,                                  /* tp_traverse */
 
3416
                0,                                  /* tp_clear */
 
3417
#endif
 
3418
#if PY_VERSION_HEX >= 0x02010000
 
3419
                0,                                  /* tp_richcompare */
 
3420
                0,                                  /* tp_weaklistoffset */
 
3421
#endif
 
3422
#if PY_VERSION_HEX >= 0x02020000
 
3423
                0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
 
3424
#endif
 
3425
#if PY_VERSION_HEX >= 0x02030000
 
3426
                0,                                  /* tp_del */
 
3427
#endif
 
3428
#ifdef COUNT_ALLOCS
 
3429
                0,0,0,0                             /* tp_alloc -> tp_next */
 
3430
#endif
 
3431
            };
 
3432
#if !defined(__cplusplus)
 
3433
            varlink_type = tmp;
 
3434
            type_init = 1;
 
3435
        }
 
3436
#endif
 
3437
        return &varlink_type;
 
3438
    }
 
3439
    
 
3440
    /* Create a variable linking object for use later */
 
3441
    SWIGINTERN PyObject *
 
3442
    SWIG_Python_newvarlink(void) {
 
3443
        swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
 
3444
        if (result) {
 
3445
            result->vars = 0;
 
3446
        }
 
3447
        return ((PyObject*) result);
 
3448
    }
 
3449
    
 
3450
    SWIGINTERN void 
 
3451
    SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
 
3452
        swig_varlinkobject *v = (swig_varlinkobject *) p;
 
3453
        swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
 
3454
        if (gv) {
 
3455
            size_t size = strlen(name)+1;
 
3456
            gv->name = (char *)malloc(size);
 
3457
            if (gv->name) {
 
3458
                strncpy(gv->name,name,size);
 
3459
                gv->get_attr = get_attr;
 
3460
                gv->set_attr = set_attr;
 
3461
                gv->next = v->vars;
 
3462
            }
 
3463
        }
 
3464
        v->vars = gv;
 
3465
    }
 
3466
    
 
3467
    /* -----------------------------------------------------------------------------
 
3468
     * constants/methods manipulation
 
3469
     * ----------------------------------------------------------------------------- */
 
3470
    
 
3471
    /* Install Constants */
 
3472
    SWIGINTERN void
 
3473
    SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
 
3474
        PyObject *obj = 0;
 
3475
        size_t i;
 
3476
        for (i = 0; constants[i].type; ++i) {
 
3477
            switch(constants[i].type) {
 
3478
                case SWIG_PY_INT:
 
3479
                obj = PyInt_FromLong(constants[i].lvalue);
 
3480
                break;
 
3481
                case SWIG_PY_FLOAT:
 
3482
                obj = PyFloat_FromDouble(constants[i].dvalue);
 
3483
                break;
 
3484
                case SWIG_PY_STRING:
 
3485
                if (constants[i].pvalue) {
 
3486
                    obj = PyString_FromString((char *) constants[i].pvalue);
 
3487
                } else {
 
3488
                    Py_INCREF(Py_None);
 
3489
                    obj = Py_None;
 
3490
                }
 
3491
                break;
 
3492
                case SWIG_PY_POINTER:
 
3493
                obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
 
3494
                break;
 
3495
                case SWIG_PY_BINARY:
 
3496
                obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
 
3497
                break;
 
3498
                default:
 
3499
                obj = 0;
 
3500
                break;
 
3501
            }
 
3502
            if (obj) {
 
3503
                PyDict_SetItemString(d,constants[i].name,obj);
 
3504
                Py_DECREF(obj);
 
3505
            }
 
3506
        }
 
3507
    }
 
3508
    
 
3509
    /* -----------------------------------------------------------------------------*/
 
3510
    /* Fix SwigMethods to carry the callback ptrs when needed */
 
3511
    /* -----------------------------------------------------------------------------*/
 
3512
    
 
3513
    SWIGINTERN void
 
3514
    SWIG_Python_FixMethods(PyMethodDef *methods,
 
3515
    swig_const_info *const_table,
 
3516
    swig_type_info **types,
 
3517
    swig_type_info **types_initial) {
 
3518
        size_t i;
 
3519
        for (i = 0; methods[i].ml_name; ++i) {
 
3520
            char *c = methods[i].ml_doc;
 
3521
            if (c && (c = strstr(c, "swig_ptr: "))) {
 
3522
                int j;
 
3523
                swig_const_info *ci = 0;
 
3524
                char *name = c + 10;
 
3525
                for (j = 0; const_table[j].type; ++j) {
 
3526
                    if (strncmp(const_table[j].name, name, 
 
3527
                    strlen(const_table[j].name)) == 0) {
 
3528
                        ci = &(const_table[j]);
 
3529
                        break;
 
3530
                    }
 
3531
                }
 
3532
                if (ci) {
 
3533
                    size_t shift = (ci->ptype) - types;
 
3534
                    swig_type_info *ty = types_initial[shift];
 
3535
                    size_t ldoc = (c - methods[i].ml_doc);
 
3536
                    size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
 
3537
                    char *ndoc = (char*)malloc(ldoc + lptr + 10);
 
3538
                    if (ndoc) {
 
3539
                        char *buff = ndoc;
 
3540
                        void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
 
3541
                        if (ptr) {
 
3542
                            strncpy(buff, methods[i].ml_doc, ldoc);
 
3543
                            buff += ldoc;
 
3544
                            strncpy(buff, "swig_ptr: ", 10);
 
3545
                            buff += 10;
 
3546
                            SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
 
3547
                            methods[i].ml_doc = ndoc;
 
3548
                        }
 
3549
                    }
 
3550
                }
 
3551
            }
 
3552
        }
 
3553
    }
 
3554
    
 
3555
    /* -----------------------------------------------------------------------------*
 
3556
     *  Initialize type list
 
3557
     * -----------------------------------------------------------------------------*/
 
3558
    
 
3559
#ifdef __cplusplus
 
3560
}
 
3561
#endif
 
3562
 
 
3563
/* -----------------------------------------------------------------------------*
 
3564
 *  Partial Init method
 
3565
 * -----------------------------------------------------------------------------*/
 
3566
 
 
3567
#ifdef __cplusplus
 
3568
extern "C"
 
3569
#endif
 
3570
SWIGEXPORT void SWIG_init(void) {
 
3571
    static PyObject *SWIG_globals = 0; 
 
3572
    PyObject *m, *d;
 
3573
    if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
 
3574
    
 
3575
    /* Fix SwigMethods to carry the callback ptrs when needed */
 
3576
    SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
 
3577
    
 
3578
    m = Py_InitModule((char *) SWIG_name, SwigMethods);
 
3579
    d = PyModule_GetDict(m);
 
3580
    
 
3581
    SWIG_InitializeModule(0);
 
3582
    SWIG_InstallConstants(d,swig_const_table);
 
3583
    
 
3584
    PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
 
3585
    SWIG_addvarlink(SWIG_globals,(char*)"GLCanvasNameStr",_wrap_GLCanvasNameStr_get, _wrap_GLCanvasNameStr_set);
 
3586
    {
 
3587
        PyDict_SetItemString(d,"WX_GL_RGBA", SWIG_From_int(static_cast<int >(WX_GL_RGBA))); 
 
3588
    }
 
3589
    {
 
3590
        PyDict_SetItemString(d,"WX_GL_BUFFER_SIZE", SWIG_From_int(static_cast<int >(WX_GL_BUFFER_SIZE))); 
 
3591
    }
 
3592
    {
 
3593
        PyDict_SetItemString(d,"WX_GL_LEVEL", SWIG_From_int(static_cast<int >(WX_GL_LEVEL))); 
 
3594
    }
 
3595
    {
 
3596
        PyDict_SetItemString(d,"WX_GL_DOUBLEBUFFER", SWIG_From_int(static_cast<int >(WX_GL_DOUBLEBUFFER))); 
 
3597
    }
 
3598
    {
 
3599
        PyDict_SetItemString(d,"WX_GL_STEREO", SWIG_From_int(static_cast<int >(WX_GL_STEREO))); 
 
3600
    }
 
3601
    {
 
3602
        PyDict_SetItemString(d,"WX_GL_AUX_BUFFERS", SWIG_From_int(static_cast<int >(WX_GL_AUX_BUFFERS))); 
 
3603
    }
 
3604
    {
 
3605
        PyDict_SetItemString(d,"WX_GL_MIN_RED", SWIG_From_int(static_cast<int >(WX_GL_MIN_RED))); 
 
3606
    }
 
3607
    {
 
3608
        PyDict_SetItemString(d,"WX_GL_MIN_GREEN", SWIG_From_int(static_cast<int >(WX_GL_MIN_GREEN))); 
 
3609
    }
 
3610
    {
 
3611
        PyDict_SetItemString(d,"WX_GL_MIN_BLUE", SWIG_From_int(static_cast<int >(WX_GL_MIN_BLUE))); 
 
3612
    }
 
3613
    {
 
3614
        PyDict_SetItemString(d,"WX_GL_MIN_ALPHA", SWIG_From_int(static_cast<int >(WX_GL_MIN_ALPHA))); 
 
3615
    }
 
3616
    {
 
3617
        PyDict_SetItemString(d,"WX_GL_DEPTH_SIZE", SWIG_From_int(static_cast<int >(WX_GL_DEPTH_SIZE))); 
 
3618
    }
 
3619
    {
 
3620
        PyDict_SetItemString(d,"WX_GL_STENCIL_SIZE", SWIG_From_int(static_cast<int >(WX_GL_STENCIL_SIZE))); 
 
3621
    }
 
3622
    {
 
3623
        PyDict_SetItemString(d,"WX_GL_MIN_ACCUM_RED", SWIG_From_int(static_cast<int >(WX_GL_MIN_ACCUM_RED))); 
 
3624
    }
 
3625
    {
 
3626
        PyDict_SetItemString(d,"WX_GL_MIN_ACCUM_GREEN", SWIG_From_int(static_cast<int >(WX_GL_MIN_ACCUM_GREEN))); 
 
3627
    }
 
3628
    {
 
3629
        PyDict_SetItemString(d,"WX_GL_MIN_ACCUM_BLUE", SWIG_From_int(static_cast<int >(WX_GL_MIN_ACCUM_BLUE))); 
 
3630
    }
 
3631
    {
 
3632
        PyDict_SetItemString(d,"WX_GL_MIN_ACCUM_ALPHA", SWIG_From_int(static_cast<int >(WX_GL_MIN_ACCUM_ALPHA))); 
 
3633
    }
 
3634
    
 
3635
    
 
3636
    
 
3637
}
 
3638