]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:


49a6f07d5c73df9d0cabed5768c91c3fca8bbe81
[wxWidgets.git] / wxPython / src / msw / grid_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 #define SWIG_VERSION 0x010327
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /***********************************************************************
31 *
32 * This section contains generic SWIG labels for method/variable
33 * declarations/attributes, and other compiler dependent labels.
34 *
35 ************************************************************************/
36
37 /* template workaround for compilers that cannot correctly implement the C++ standard */
38 #ifndef SWIGTEMPLATEDISAMBIGUATOR
39 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
40 # define SWIGTEMPLATEDISAMBIGUATOR template
41 # else
42 # define SWIGTEMPLATEDISAMBIGUATOR
43 # endif
44 #endif
45
46 /* inline attribute */
47 #ifndef SWIGINLINE
48 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
49 # define SWIGINLINE inline
50 # else
51 # define SWIGINLINE
52 # endif
53 #endif
54
55 /* attribute recognised by some compilers to avoid 'unused' warnings */
56 #ifndef SWIGUNUSED
57 # if defined(__GNUC__) || defined(__ICC)
58 # define SWIGUNUSED __attribute__ ((unused))
59 # else
60 # define SWIGUNUSED
61 # endif
62 #endif
63
64 /* internal SWIG method */
65 #ifndef SWIGINTERN
66 # define SWIGINTERN static SWIGUNUSED
67 #endif
68
69 /* internal inline SWIG method */
70 #ifndef SWIGINTERNINLINE
71 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
72 #endif
73
74 /* exporting methods for Windows DLLs */
75 #ifndef SWIGEXPORT
76 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
77 # if defined(STATIC_LINKED)
78 # define SWIGEXPORT
79 # else
80 # define SWIGEXPORT __declspec(dllexport)
81 # endif
82 # else
83 # define SWIGEXPORT
84 # endif
85 #endif
86
87 /* calling conventions for Windows */
88 #ifndef SWIGSTDCALL
89 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
90 # define SWIGSTDCALL __stdcall
91 # else
92 # define SWIGSTDCALL
93 # endif
94 #endif
95
96
97
98 #include <Python.h>
99
100 /***********************************************************************
101 * swigrun.swg
102 *
103 * This file contains generic CAPI SWIG runtime support for pointer
104 * type checking.
105 *
106 ************************************************************************/
107
108 /* This should only be incremented when either the layout of swig_type_info changes,
109 or for whatever reason, the runtime changes incompatibly */
110 #define SWIG_RUNTIME_VERSION "2"
111
112 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
113 #ifdef SWIG_TYPE_TABLE
114 # define SWIG_QUOTE_STRING(x) #x
115 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
116 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
117 #else
118 # define SWIG_TYPE_TABLE_NAME
119 #endif
120
121 /*
122 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
123 creating a static or dynamic library from the swig runtime code.
124 In 99.9% of the cases, swig just needs to declare them as 'static'.
125
126 But only do this if is strictly necessary, ie, if you have problems
127 with your compiler or so.
128 */
129
130 #ifndef SWIGRUNTIME
131 # define SWIGRUNTIME SWIGINTERN
132 #endif
133
134 #ifndef SWIGRUNTIMEINLINE
135 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
136 #endif
137
138 #include <string.h>
139
140 #ifdef __cplusplus
141 extern "C" {
142 #endif
143
144 typedef void *(*swig_converter_func)(void *);
145 typedef struct swig_type_info *(*swig_dycast_func)(void **);
146
147 /* Structure to store inforomation on one type */
148 typedef struct swig_type_info {
149 const char *name; /* mangled name of this type */
150 const char *str; /* human readable name of this type */
151 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
152 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
153 void *clientdata; /* language specific type data */
154 } swig_type_info;
155
156 /* Structure to store a type and conversion function used for casting */
157 typedef struct swig_cast_info {
158 swig_type_info *type; /* pointer to type that is equivalent to this type */
159 swig_converter_func converter; /* function to cast the void pointers */
160 struct swig_cast_info *next; /* pointer to next cast in linked list */
161 struct swig_cast_info *prev; /* pointer to the previous cast */
162 } swig_cast_info;
163
164 /* Structure used to store module information
165 * Each module generates one structure like this, and the runtime collects
166 * all of these structures and stores them in a circularly linked list.*/
167 typedef struct swig_module_info {
168 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
169 size_t size; /* Number of types in this module */
170 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
171 swig_type_info **type_initial; /* Array of initially generated type structures */
172 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
173 void *clientdata; /* Language specific module data */
174 } swig_module_info;
175
176
177 /*
178 Compare two type names skipping the space characters, therefore
179 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
180
181 Return 0 when the two name types are equivalent, as in
182 strncmp, but skipping ' '.
183 */
184 SWIGRUNTIME int
185 SWIG_TypeNameComp(const char *f1, const char *l1,
186 const char *f2, const char *l2) {
187 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
188 while ((*f1 == ' ') && (f1 != l1)) ++f1;
189 while ((*f2 == ' ') && (f2 != l2)) ++f2;
190 if (*f1 != *f2) return (int)(*f1 - *f2);
191 }
192 return (l1 - f1) - (l2 - f2);
193 }
194
195 /*
196 Check type equivalence in a name list like <name1>|<name2>|...
197 Return 0 if not equal, 1 if equal
198 */
199 SWIGRUNTIME int
200 SWIG_TypeEquiv(const char *nb, const char *tb) {
201 int equiv = 0;
202 const char* te = tb + strlen(tb);
203 const char* ne = nb;
204 while (!equiv && *ne) {
205 for (nb = ne; *ne; ++ne) {
206 if (*ne == '|') break;
207 }
208 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
209 if (*ne) ++ne;
210 }
211 return equiv;
212 }
213
214 /*
215 Check type equivalence in a name list like <name1>|<name2>|...
216 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
217 */
218 SWIGRUNTIME int
219 SWIG_TypeCompare(const char *nb, const char *tb) {
220 int equiv = 0;
221 const char* te = tb + strlen(tb);
222 const char* ne = nb;
223 while (!equiv && *ne) {
224 for (nb = ne; *ne; ++ne) {
225 if (*ne == '|') break;
226 }
227 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
228 if (*ne) ++ne;
229 }
230 return equiv;
231 }
232
233
234 /* think of this as a c++ template<> or a scheme macro */
235 #define SWIG_TypeCheck_Template(comparison, ty) \
236 if (ty) { \
237 swig_cast_info *iter = ty->cast; \
238 while (iter) { \
239 if (comparison) { \
240 if (iter == ty->cast) return iter; \
241 /* Move iter to the top of the linked list */ \
242 iter->prev->next = iter->next; \
243 if (iter->next) \
244 iter->next->prev = iter->prev; \
245 iter->next = ty->cast; \
246 iter->prev = 0; \
247 if (ty->cast) ty->cast->prev = iter; \
248 ty->cast = iter; \
249 return iter; \
250 } \
251 iter = iter->next; \
252 } \
253 } \
254 return 0
255
256 /*
257 Check the typename
258 */
259 SWIGRUNTIME swig_cast_info *
260 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
261 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
262 }
263
264 /* Same as previous function, except strcmp is replaced with a pointer comparison */
265 SWIGRUNTIME swig_cast_info *
266 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
267 SWIG_TypeCheck_Template(iter->type == from, into);
268 }
269
270 /*
271 Cast a pointer up an inheritance hierarchy
272 */
273 SWIGRUNTIMEINLINE void *
274 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
275 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
276 }
277
278 /*
279 Dynamic pointer casting. Down an inheritance hierarchy
280 */
281 SWIGRUNTIME swig_type_info *
282 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
283 swig_type_info *lastty = ty;
284 if (!ty || !ty->dcast) return ty;
285 while (ty && (ty->dcast)) {
286 ty = (*ty->dcast)(ptr);
287 if (ty) lastty = ty;
288 }
289 return lastty;
290 }
291
292 /*
293 Return the name associated with this type
294 */
295 SWIGRUNTIMEINLINE const char *
296 SWIG_TypeName(const swig_type_info *ty) {
297 return ty->name;
298 }
299
300 /*
301 Return the pretty name associated with this type,
302 that is an unmangled type name in a form presentable to the user.
303 */
304 SWIGRUNTIME const char *
305 SWIG_TypePrettyName(const swig_type_info *type) {
306 /* The "str" field contains the equivalent pretty names of the
307 type, separated by vertical-bar characters. We choose
308 to print the last name, as it is often (?) the most
309 specific. */
310 if (type->str != NULL) {
311 const char *last_name = type->str;
312 const char *s;
313 for (s = type->str; *s; s++)
314 if (*s == '|') last_name = s+1;
315 return last_name;
316 }
317 else
318 return type->name;
319 }
320
321 /*
322 Set the clientdata field for a type
323 */
324 SWIGRUNTIME void
325 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
326 swig_cast_info *cast = ti->cast;
327 /* if (ti->clientdata == clientdata) return; */
328 ti->clientdata = clientdata;
329
330 while (cast) {
331 if (!cast->converter) {
332 swig_type_info *tc = cast->type;
333 if (!tc->clientdata) {
334 SWIG_TypeClientData(tc, clientdata);
335 }
336 }
337 cast = cast->next;
338 }
339 }
340
341 /*
342 Search for a swig_type_info structure only by mangled name
343 Search is a O(log #types)
344
345 We start searching at module start, and finish searching when start == end.
346 Note: if start == end at the beginning of the function, we go all the way around
347 the circular list.
348 */
349 SWIGRUNTIME swig_type_info *
350 SWIG_MangledTypeQueryModule(swig_module_info *start,
351 swig_module_info *end,
352 const char *name) {
353 swig_module_info *iter = start;
354 do {
355 if (iter->size) {
356 register size_t l = 0;
357 register size_t r = iter->size - 1;
358 do {
359 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
360 register size_t i = (l + r) >> 1;
361 const char *iname = iter->types[i]->name;
362 if (iname) {
363 register int compare = strcmp(name, iname);
364 if (compare == 0) {
365 return iter->types[i];
366 } else if (compare < 0) {
367 if (i) {
368 r = i - 1;
369 } else {
370 break;
371 }
372 } else if (compare > 0) {
373 l = i + 1;
374 }
375 } else {
376 break; /* should never happen */
377 }
378 } while (l <= r);
379 }
380 iter = iter->next;
381 } while (iter != end);
382 return 0;
383 }
384
385 /*
386 Search for a swig_type_info structure for either a mangled name or a human readable name.
387 It first searches the mangled names of the types, which is a O(log #types)
388 If a type is not found it then searches the human readable names, which is O(#types).
389
390 We start searching at module start, and finish searching when start == end.
391 Note: if start == end at the beginning of the function, we go all the way around
392 the circular list.
393 */
394 SWIGRUNTIME swig_type_info *
395 SWIG_TypeQueryModule(swig_module_info *start,
396 swig_module_info *end,
397 const char *name) {
398 /* STEP 1: Search the name field using binary search */
399 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
400 if (ret) {
401 return ret;
402 } else {
403 /* STEP 2: If the type hasn't been found, do a complete search
404 of the str field (the human readable name) */
405 swig_module_info *iter = start;
406 do {
407 register size_t i = 0;
408 for (; i < iter->size; ++i) {
409 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
410 return iter->types[i];
411 }
412 iter = iter->next;
413 } while (iter != end);
414 }
415
416 /* neither found a match */
417 return 0;
418 }
419
420
421 /*
422 Pack binary data into a string
423 */
424 SWIGRUNTIME char *
425 SWIG_PackData(char *c, void *ptr, size_t sz) {
426 static const char hex[17] = "0123456789abcdef";
427 register const unsigned char *u = (unsigned char *) ptr;
428 register const unsigned char *eu = u + sz;
429 for (; u != eu; ++u) {
430 register unsigned char uu = *u;
431 *(c++) = hex[(uu & 0xf0) >> 4];
432 *(c++) = hex[uu & 0xf];
433 }
434 return c;
435 }
436
437 /*
438 Unpack binary data from a string
439 */
440 SWIGRUNTIME const char *
441 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
442 register unsigned char *u = (unsigned char *) ptr;
443 register const unsigned char *eu = u + sz;
444 for (; u != eu; ++u) {
445 register char d = *(c++);
446 register unsigned char uu = 0;
447 if ((d >= '0') && (d <= '9'))
448 uu = ((d - '0') << 4);
449 else if ((d >= 'a') && (d <= 'f'))
450 uu = ((d - ('a'-10)) << 4);
451 else
452 return (char *) 0;
453 d = *(c++);
454 if ((d >= '0') && (d <= '9'))
455 uu |= (d - '0');
456 else if ((d >= 'a') && (d <= 'f'))
457 uu |= (d - ('a'-10));
458 else
459 return (char *) 0;
460 *u = uu;
461 }
462 return c;
463 }
464
465 /*
466 Pack 'void *' into a string buffer.
467 */
468 SWIGRUNTIME char *
469 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
470 char *r = buff;
471 if ((2*sizeof(void *) + 2) > bsz) return 0;
472 *(r++) = '_';
473 r = SWIG_PackData(r,&ptr,sizeof(void *));
474 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
475 strcpy(r,name);
476 return buff;
477 }
478
479 SWIGRUNTIME const char *
480 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
481 if (*c != '_') {
482 if (strcmp(c,"NULL") == 0) {
483 *ptr = (void *) 0;
484 return name;
485 } else {
486 return 0;
487 }
488 }
489 return SWIG_UnpackData(++c,ptr,sizeof(void *));
490 }
491
492 SWIGRUNTIME char *
493 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
494 char *r = buff;
495 size_t lname = (name ? strlen(name) : 0);
496 if ((2*sz + 2 + lname) > bsz) return 0;
497 *(r++) = '_';
498 r = SWIG_PackData(r,ptr,sz);
499 if (lname) {
500 strncpy(r,name,lname+1);
501 } else {
502 *r = 0;
503 }
504 return buff;
505 }
506
507 SWIGRUNTIME const char *
508 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
509 if (*c != '_') {
510 if (strcmp(c,"NULL") == 0) {
511 memset(ptr,0,sz);
512 return name;
513 } else {
514 return 0;
515 }
516 }
517 return SWIG_UnpackData(++c,ptr,sz);
518 }
519
520 #ifdef __cplusplus
521 }
522 #endif
523
524 /* -----------------------------------------------------------------------------
525 * SWIG API. Portion that goes into the runtime
526 * ----------------------------------------------------------------------------- */
527
528 #ifdef __cplusplus
529 extern "C" {
530 #endif
531
532 /* -----------------------------------------------------------------------------
533 * for internal method declarations
534 * ----------------------------------------------------------------------------- */
535
536 #ifndef SWIGINTERN
537 # define SWIGINTERN static SWIGUNUSED
538 #endif
539
540 #ifndef SWIGINTERNINLINE
541 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
542 #endif
543
544 /*
545 Exception handling in wrappers
546 */
547 #define SWIG_fail goto fail
548 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
549 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
550 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
551 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
552 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
553
554 /*
555 Contract support
556 */
557 #define SWIG_contract_assert(expr, msg) \
558 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
559
560 /* -----------------------------------------------------------------------------
561 * Constant declarations
562 * ----------------------------------------------------------------------------- */
563
564 /* Constant Types */
565 #define SWIG_PY_INT 1
566 #define SWIG_PY_FLOAT 2
567 #define SWIG_PY_STRING 3
568 #define SWIG_PY_POINTER 4
569 #define SWIG_PY_BINARY 5
570
571 /* Constant information structure */
572 typedef struct swig_const_info {
573 int type;
574 char *name;
575 long lvalue;
576 double dvalue;
577 void *pvalue;
578 swig_type_info **ptype;
579 } swig_const_info;
580
581
582 /* -----------------------------------------------------------------------------
583 * Alloc. memory flags
584 * ----------------------------------------------------------------------------- */
585 #define SWIG_OLDOBJ 1
586 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
587 #define SWIG_PYSTR SWIG_NEWOBJ + 1
588
589 #ifdef __cplusplus
590 }
591 #endif
592
593
594 /***********************************************************************
595 * pyrun.swg
596 *
597 * This file contains the runtime support for Python modules
598 * and includes code for managing global variables and pointer
599 * type checking.
600 *
601 * Author : David Beazley (beazley@cs.uchicago.edu)
602 ************************************************************************/
603
604 /* Common SWIG API */
605 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
606 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
607 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
608
609
610 /* Python-specific SWIG API */
611 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
612 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
613
614 /* Runtime API */
615 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
616 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
617
618 /* -----------------------------------------------------------------------------
619 * Pointer declarations
620 * ----------------------------------------------------------------------------- */
621 /*
622 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
623 C/C++ pointers in the python side. Very useful for debugging, but
624 not always safe.
625 */
626 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
627 # define SWIG_COBJECT_TYPES
628 #endif
629
630 /* Flags for pointer conversion */
631 #define SWIG_POINTER_EXCEPTION 0x1
632 #define SWIG_POINTER_DISOWN 0x2
633
634
635 /* Add PyOS_snprintf for old Pythons */
636 #if PY_VERSION_HEX < 0x02020000
637 #define PyOS_snprintf snprintf
638 #endif
639
640 #ifdef __cplusplus
641 extern "C" {
642 #endif
643
644 /* -----------------------------------------------------------------------------
645 * Create a new pointer string
646 * ----------------------------------------------------------------------------- */
647 #ifndef SWIG_BUFFER_SIZE
648 #define SWIG_BUFFER_SIZE 1024
649 #endif
650
651 /* A crude PyString_FromFormat implementation for old Pythons */
652 #if PY_VERSION_HEX < 0x02020000
653 static PyObject *
654 PyString_FromFormat(const char *fmt, ...) {
655 va_list ap;
656 char buf[SWIG_BUFFER_SIZE * 2];
657 int res;
658 va_start(ap, fmt);
659 res = vsnprintf(buf, sizeof(buf), fmt, ap);
660 va_end(ap);
661 return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
662 }
663 #endif
664
665 #if PY_VERSION_HEX < 0x01060000
666 #define PyObject_Del(op) PyMem_DEL((op))
667 #endif
668
669 #if defined(SWIG_COBJECT_TYPES)
670 #if !defined(SWIG_COBJECT_PYTHON)
671 /* -----------------------------------------------------------------------------
672 * Implements a simple Swig Object type, and use it instead of PyCObject
673 * ----------------------------------------------------------------------------- */
674
675 typedef struct {
676 PyObject_HEAD
677 void *ptr;
678 const char *desc;
679 } PySwigObject;
680
681 /* Declarations for objects of type PySwigObject */
682
683 SWIGRUNTIME int
684 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
685 {
686 char result[SWIG_BUFFER_SIZE];
687 flags = flags;
688 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
689 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
690 return 0;
691 } else {
692 return 1;
693 }
694 }
695
696 SWIGRUNTIME PyObject *
697 PySwigObject_repr(PySwigObject *v)
698 {
699 char result[SWIG_BUFFER_SIZE];
700 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
701 PyString_FromFormat("<Swig Object at %s>", result) : 0;
702 }
703
704 SWIGRUNTIME PyObject *
705 PySwigObject_str(PySwigObject *v)
706 {
707 char result[SWIG_BUFFER_SIZE];
708 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
709 PyString_FromString(result) : 0;
710 }
711
712 SWIGRUNTIME PyObject *
713 PySwigObject_long(PySwigObject *v)
714 {
715 return PyLong_FromVoidPtr(v->ptr);
716 }
717
718 SWIGRUNTIME PyObject *
719 PySwigObject_format(const char* fmt, PySwigObject *v)
720 {
721 PyObject *res = NULL;
722 PyObject *args = PyTuple_New(1);
723 if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
724 PyObject *ofmt = PyString_FromString(fmt);
725 if (ofmt) {
726 res = PyString_Format(ofmt,args);
727 Py_DECREF(ofmt);
728 }
729 Py_DECREF(args);
730 }
731 return res;
732 }
733
734 SWIGRUNTIME PyObject *
735 PySwigObject_oct(PySwigObject *v)
736 {
737 return PySwigObject_format("%o",v);
738 }
739
740 SWIGRUNTIME PyObject *
741 PySwigObject_hex(PySwigObject *v)
742 {
743 return PySwigObject_format("%x",v);
744 }
745
746 SWIGRUNTIME int
747 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
748 {
749 int c = strcmp(v->desc, w->desc);
750 if (c) {
751 return (c > 0) ? 1 : -1;
752 } else {
753 void *i = v->ptr;
754 void *j = w->ptr;
755 return (i < j) ? -1 : ((i > j) ? 1 : 0);
756 }
757 }
758
759 SWIGRUNTIME void
760 PySwigObject_dealloc(PySwigObject *self)
761 {
762 PyObject_Del(self);
763 }
764
765 SWIGRUNTIME PyTypeObject*
766 PySwigObject_type(void) {
767 static char pyswigobject_type__doc__[] =
768 "Swig object carries a C/C++ instance pointer";
769
770 static PyNumberMethods PySwigObject_as_number = {
771 (binaryfunc)0, /*nb_add*/
772 (binaryfunc)0, /*nb_subtract*/
773 (binaryfunc)0, /*nb_multiply*/
774 (binaryfunc)0, /*nb_divide*/
775 (binaryfunc)0, /*nb_remainder*/
776 (binaryfunc)0, /*nb_divmod*/
777 (ternaryfunc)0,/*nb_power*/
778 (unaryfunc)0, /*nb_negative*/
779 (unaryfunc)0, /*nb_positive*/
780 (unaryfunc)0, /*nb_absolute*/
781 (inquiry)0, /*nb_nonzero*/
782 0, /*nb_invert*/
783 0, /*nb_lshift*/
784 0, /*nb_rshift*/
785 0, /*nb_and*/
786 0, /*nb_xor*/
787 0, /*nb_or*/
788 (coercion)0, /*nb_coerce*/
789 (unaryfunc)PySwigObject_long, /*nb_int*/
790 (unaryfunc)PySwigObject_long, /*nb_long*/
791 (unaryfunc)0, /*nb_float*/
792 (unaryfunc)PySwigObject_oct, /*nb_oct*/
793 (unaryfunc)PySwigObject_hex, /*nb_hex*/
794 #if PY_VERSION_HEX >= 0x02020000
795 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
796 #elif PY_VERSION_HEX >= 0x02000000
797 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
798 #endif
799 };
800
801 static PyTypeObject pyswigobject_type
802 #if !defined(__cplusplus)
803 ;
804 static int type_init = 0;
805 if (!type_init) {
806 PyTypeObject tmp
807 #endif
808 = {
809 PyObject_HEAD_INIT(&PyType_Type)
810 0, /*ob_size*/
811 (char *)"PySwigObject", /*tp_name*/
812 sizeof(PySwigObject), /*tp_basicsize*/
813 0, /*tp_itemsize*/
814 /* methods */
815 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
816 (printfunc)PySwigObject_print, /*tp_print*/
817 (getattrfunc)0, /*tp_getattr*/
818 (setattrfunc)0, /*tp_setattr*/
819 (cmpfunc)PySwigObject_compare, /*tp_compare*/
820 (reprfunc)PySwigObject_repr, /*tp_repr*/
821 &PySwigObject_as_number, /*tp_as_number*/
822 0, /*tp_as_sequence*/
823 0, /*tp_as_mapping*/
824 (hashfunc)0, /*tp_hash*/
825 (ternaryfunc)0, /*tp_call*/
826 (reprfunc)PySwigObject_str, /*tp_str*/
827 /* Space for future expansion */
828 0,0,0,0,
829 pyswigobject_type__doc__, /* Documentation string */
830 #if PY_VERSION_HEX >= 0x02000000
831 0, /* tp_traverse */
832 0, /* tp_clear */
833 #endif
834 #if PY_VERSION_HEX >= 0x02010000
835 0, /* tp_richcompare */
836 0, /* tp_weaklistoffset */
837 #endif
838 #if PY_VERSION_HEX >= 0x02020000
839 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
840 #endif
841 #if PY_VERSION_HEX >= 0x02030000
842 0, /* tp_del */
843 #endif
844 #ifdef COUNT_ALLOCS
845 0,0,0,0 /* tp_alloc -> tp_next */
846 #endif
847 };
848 #if !defined(__cplusplus)
849 pyswigobject_type = tmp;
850 type_init = 1;
851 }
852 #endif
853 return &pyswigobject_type;
854 }
855
856 SWIGRUNTIME PyObject *
857 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
858 {
859 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
860 if (self) {
861 self->ptr = ptr;
862 self->desc = desc;
863 }
864 return (PyObject *)self;
865 }
866
867 SWIGRUNTIMEINLINE void *
868 PySwigObject_AsVoidPtr(PyObject *self)
869 {
870 return ((PySwigObject *)self)->ptr;
871 }
872
873 SWIGRUNTIMEINLINE const char *
874 PySwigObject_GetDesc(PyObject *self)
875 {
876 return ((PySwigObject *)self)->desc;
877 }
878
879 SWIGRUNTIMEINLINE int
880 PySwigObject_Check(PyObject *op) {
881 return ((op)->ob_type == PySwigObject_type())
882 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
883 }
884
885 /* -----------------------------------------------------------------------------
886 * Implements a simple Swig Packed type, and use it instead of string
887 * ----------------------------------------------------------------------------- */
888
889 typedef struct {
890 PyObject_HEAD
891 void *pack;
892 const char *desc;
893 size_t size;
894 } PySwigPacked;
895
896 SWIGRUNTIME int
897 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
898 {
899 char result[SWIG_BUFFER_SIZE];
900 flags = flags;
901 fputs("<Swig Packed ", fp);
902 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
903 fputs("at ", fp);
904 fputs(result, fp);
905 }
906 fputs(v->desc,fp);
907 fputs(">", fp);
908 return 0;
909 }
910
911 SWIGRUNTIME PyObject *
912 PySwigPacked_repr(PySwigPacked *v)
913 {
914 char result[SWIG_BUFFER_SIZE];
915 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
916 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
917 } else {
918 return PyString_FromFormat("<Swig Packed %s>", v->desc);
919 }
920 }
921
922 SWIGRUNTIME PyObject *
923 PySwigPacked_str(PySwigPacked *v)
924 {
925 char result[SWIG_BUFFER_SIZE];
926 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
927 return PyString_FromFormat("%s%s", result, v->desc);
928 } else {
929 return PyString_FromString(v->desc);
930 }
931 }
932
933 SWIGRUNTIME int
934 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
935 {
936 int c = strcmp(v->desc, w->desc);
937 if (c) {
938 return (c > 0) ? 1 : -1;
939 } else {
940 size_t i = v->size;
941 size_t j = w->size;
942 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
943 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
944 }
945 }
946
947 SWIGRUNTIME void
948 PySwigPacked_dealloc(PySwigPacked *self)
949 {
950 free(self->pack);
951 PyObject_Del(self);
952 }
953
954 SWIGRUNTIME PyTypeObject*
955 PySwigPacked_type(void) {
956 static char pyswigpacked_type__doc__[] =
957 "Swig object carries a C/C++ instance pointer";
958 static PyTypeObject pyswigpacked_type
959 #if !defined(__cplusplus)
960 ;
961 static int type_init = 0;
962 if (!type_init) {
963 PyTypeObject tmp
964 #endif
965 = {
966 PyObject_HEAD_INIT(&PyType_Type)
967 0, /*ob_size*/
968 (char *)"PySwigPacked", /*tp_name*/
969 sizeof(PySwigPacked), /*tp_basicsize*/
970 0, /*tp_itemsize*/
971 /* methods */
972 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
973 (printfunc)PySwigPacked_print, /*tp_print*/
974 (getattrfunc)0, /*tp_getattr*/
975 (setattrfunc)0, /*tp_setattr*/
976 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
977 (reprfunc)PySwigPacked_repr, /*tp_repr*/
978 0, /*tp_as_number*/
979 0, /*tp_as_sequence*/
980 0, /*tp_as_mapping*/
981 (hashfunc)0, /*tp_hash*/
982 (ternaryfunc)0, /*tp_call*/
983 (reprfunc)PySwigPacked_str, /*tp_str*/
984 /* Space for future expansion */
985 0,0,0,0,
986 pyswigpacked_type__doc__, /* Documentation string */
987 #if PY_VERSION_HEX >= 0x02000000
988 0, /* tp_traverse */
989 0, /* tp_clear */
990 #endif
991 #if PY_VERSION_HEX >= 0x02010000
992 0, /* tp_richcompare */
993 0, /* tp_weaklistoffset */
994 #endif
995 #if PY_VERSION_HEX >= 0x02020000
996 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
997 #endif
998 #if PY_VERSION_HEX >= 0x02030000
999 0, /* tp_del */
1000 #endif
1001 #ifdef COUNT_ALLOCS
1002 0,0,0,0 /* tp_alloc -> tp_next */
1003 #endif
1004 };
1005 #if !defined(__cplusplus)
1006 pyswigpacked_type = tmp;
1007 type_init = 1;
1008 }
1009 #endif
1010 return &pyswigpacked_type;
1011 }
1012
1013 SWIGRUNTIME PyObject *
1014 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
1015 {
1016 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1017 if (self == NULL) {
1018 return NULL;
1019 } else {
1020 void *pack = malloc(size);
1021 if (pack) {
1022 memcpy(pack, ptr, size);
1023 self->pack = pack;
1024 self->desc = desc;
1025 self->size = size;
1026 return (PyObject *) self;
1027 }
1028 return NULL;
1029 }
1030 }
1031
1032 SWIGRUNTIMEINLINE const char *
1033 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1034 {
1035 PySwigPacked *self = (PySwigPacked *)obj;
1036 if (self->size != size) return 0;
1037 memcpy(ptr, self->pack, size);
1038 return self->desc;
1039 }
1040
1041 SWIGRUNTIMEINLINE const char *
1042 PySwigPacked_GetDesc(PyObject *self)
1043 {
1044 return ((PySwigPacked *)self)->desc;
1045 }
1046
1047 SWIGRUNTIMEINLINE int
1048 PySwigPacked_Check(PyObject *op) {
1049 return ((op)->ob_type == PySwigPacked_type())
1050 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1051 }
1052
1053 #else
1054 /* -----------------------------------------------------------------------------
1055 * Use the old Python PyCObject instead of PySwigObject
1056 * ----------------------------------------------------------------------------- */
1057
1058 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1059 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1060 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1061 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1062
1063 #endif
1064
1065 #endif
1066
1067 /* -----------------------------------------------------------------------------
1068 * errors manipulation
1069 * ----------------------------------------------------------------------------- */
1070
1071 SWIGRUNTIME void
1072 SWIG_Python_TypeError(const char *type, PyObject *obj)
1073 {
1074 if (type) {
1075 #if defined(SWIG_COBJECT_TYPES)
1076 if (obj && PySwigObject_Check(obj)) {
1077 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1078 if (otype) {
1079 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1080 type, otype);
1081 return;
1082 }
1083 } else
1084 #endif
1085 {
1086 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1087 if (otype) {
1088 PyObject *str = PyObject_Str(obj);
1089 const char *cstr = str ? PyString_AsString(str) : 0;
1090 if (cstr) {
1091 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1092 type, otype, cstr);
1093 } else {
1094 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1095 type, otype);
1096 }
1097 Py_XDECREF(str);
1098 return;
1099 }
1100 }
1101 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1102 } else {
1103 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1104 }
1105 }
1106
1107 SWIGRUNTIMEINLINE void
1108 SWIG_Python_NullRef(const char *type)
1109 {
1110 if (type) {
1111 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1112 } else {
1113 PyErr_Format(PyExc_TypeError, "null reference was received");
1114 }
1115 }
1116
1117 SWIGRUNTIME int
1118 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1119 {
1120 if (PyErr_Occurred()) {
1121 PyObject *type = 0;
1122 PyObject *value = 0;
1123 PyObject *traceback = 0;
1124 PyErr_Fetch(&type, &value, &traceback);
1125 if (value) {
1126 PyObject *old_str = PyObject_Str(value);
1127 Py_XINCREF(type);
1128 PyErr_Clear();
1129 if (infront) {
1130 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1131 } else {
1132 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1133 }
1134 Py_DECREF(old_str);
1135 }
1136 return 1;
1137 } else {
1138 return 0;
1139 }
1140 }
1141
1142 SWIGRUNTIME int
1143 SWIG_Python_ArgFail(int argnum)
1144 {
1145 if (PyErr_Occurred()) {
1146 /* add information about failing argument */
1147 char mesg[256];
1148 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1149 return SWIG_Python_AddErrMesg(mesg, 1);
1150 } else {
1151 return 0;
1152 }
1153 }
1154
1155
1156 /* -----------------------------------------------------------------------------
1157 * pointers/data manipulation
1158 * ----------------------------------------------------------------------------- */
1159
1160 /* Convert a pointer value */
1161 SWIGRUNTIME int
1162 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1163 swig_cast_info *tc;
1164 const char *c = 0;
1165 static PyObject *SWIG_this = 0;
1166 int newref = 0;
1167 PyObject *pyobj = 0;
1168 void *vptr;
1169
1170 if (!obj) return 0;
1171 if (obj == Py_None) {
1172 *ptr = 0;
1173 return 0;
1174 }
1175
1176 #ifdef SWIG_COBJECT_TYPES
1177 if (!(PySwigObject_Check(obj))) {
1178 if (!SWIG_this)
1179 SWIG_this = PyString_FromString("this");
1180 pyobj = obj;
1181 obj = PyObject_GetAttr(obj,SWIG_this);
1182 newref = 1;
1183 if (!obj) goto type_error;
1184 if (!PySwigObject_Check(obj)) {
1185 Py_DECREF(obj);
1186 goto type_error;
1187 }
1188 }
1189 vptr = PySwigObject_AsVoidPtr(obj);
1190 c = (const char *) PySwigObject_GetDesc(obj);
1191 if (newref) { Py_DECREF(obj); }
1192 goto type_check;
1193 #else
1194 if (!(PyString_Check(obj))) {
1195 if (!SWIG_this)
1196 SWIG_this = PyString_FromString("this");
1197 pyobj = obj;
1198 obj = PyObject_GetAttr(obj,SWIG_this);
1199 newref = 1;
1200 if (!obj) goto type_error;
1201 if (!PyString_Check(obj)) {
1202 Py_DECREF(obj);
1203 goto type_error;
1204 }
1205 }
1206 c = PyString_AsString(obj);
1207 /* Pointer values must start with leading underscore */
1208 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1209 if (newref) { Py_DECREF(obj); }
1210 if (!c) goto type_error;
1211 #endif
1212
1213 type_check:
1214 if (ty) {
1215 tc = SWIG_TypeCheck(c,ty);
1216 if (!tc) goto type_error;
1217 *ptr = SWIG_TypeCast(tc,vptr);
1218 } else {
1219 *ptr = vptr;
1220 }
1221 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1222 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1223 }
1224 return 0;
1225
1226 type_error:
1227 PyErr_Clear();
1228 if (pyobj && !obj) {
1229 obj = pyobj;
1230 if (PyCFunction_Check(obj)) {
1231 /* here we get the method pointer for callbacks */
1232 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1233 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1234 if (c) {
1235 c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1236 if (!c) goto type_error;
1237 goto type_check;
1238 }
1239 }
1240 }
1241 if (flags & SWIG_POINTER_EXCEPTION) {
1242 if (ty) {
1243 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1244 } else {
1245 SWIG_Python_TypeError("C/C++ pointer", obj);
1246 }
1247 }
1248 return -1;
1249 }
1250
1251 /* Convert a pointer value, signal an exception on a type mismatch */
1252 SWIGRUNTIME void *
1253 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1254 void *result;
1255 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1256 PyErr_Clear();
1257 if (flags & SWIG_POINTER_EXCEPTION) {
1258 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1259 SWIG_Python_ArgFail(argnum);
1260 }
1261 }
1262 return result;
1263 }
1264
1265 /* Convert a packed value value */
1266 SWIGRUNTIME int
1267 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1268 swig_cast_info *tc;
1269 const char *c = 0;
1270
1271 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1272 c = PySwigPacked_UnpackData(obj, ptr, sz);
1273 #else
1274 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1275 c = PyString_AsString(obj);
1276 /* Pointer values must start with leading underscore */
1277 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1278 #endif
1279 if (!c) goto type_error;
1280 if (ty) {
1281 tc = SWIG_TypeCheck(c,ty);
1282 if (!tc) goto type_error;
1283 }
1284 return 0;
1285
1286 type_error:
1287 PyErr_Clear();
1288 if (flags & SWIG_POINTER_EXCEPTION) {
1289 if (ty) {
1290 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1291 } else {
1292 SWIG_Python_TypeError("C/C++ packed data", obj);
1293 }
1294 }
1295 return -1;
1296 }
1297
1298 /* Create a new array object */
1299 SWIGRUNTIME PyObject *
1300 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1301 PyObject *robj = 0;
1302 if (!type) {
1303 if (!PyErr_Occurred()) {
1304 PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1305 }
1306 return robj;
1307 }
1308 if (!ptr) {
1309 Py_INCREF(Py_None);
1310 return Py_None;
1311 }
1312 #ifdef SWIG_COBJECT_TYPES
1313 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1314 #else
1315 {
1316 char result[SWIG_BUFFER_SIZE];
1317 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1318 PyString_FromString(result) : 0;
1319 }
1320 #endif
1321 if (!robj || (robj == Py_None)) return robj;
1322 if (type->clientdata) {
1323 PyObject *inst;
1324 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1325 Py_DECREF(robj);
1326 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1327 Py_DECREF(args);
1328 if (inst) {
1329 if (own) {
1330 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1331 }
1332 robj = inst;
1333 }
1334 }
1335 return robj;
1336 }
1337
1338 SWIGRUNTIME PyObject *
1339 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1340 PyObject *robj = 0;
1341 if (!ptr) {
1342 Py_INCREF(Py_None);
1343 return Py_None;
1344 }
1345 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1346 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1347 #else
1348 {
1349 char result[SWIG_BUFFER_SIZE];
1350 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1351 PyString_FromString(result) : 0;
1352 }
1353 #endif
1354 return robj;
1355 }
1356
1357 /* -----------------------------------------------------------------------------*
1358 * Get type list
1359 * -----------------------------------------------------------------------------*/
1360
1361 #ifdef SWIG_LINK_RUNTIME
1362 void *SWIG_ReturnGlobalTypeList(void *);
1363 #endif
1364
1365 SWIGRUNTIME swig_module_info *
1366 SWIG_Python_GetModule(void) {
1367 static void *type_pointer = (void *)0;
1368 /* first check if module already created */
1369 if (!type_pointer) {
1370 #ifdef SWIG_LINK_RUNTIME
1371 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1372 #else
1373 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1374 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1375 if (PyErr_Occurred()) {
1376 PyErr_Clear();
1377 type_pointer = (void *)0;
1378 }
1379 #endif
1380 }
1381 return (swig_module_info *) type_pointer;
1382 }
1383
1384 #if PY_MAJOR_VERSION < 2
1385 /* PyModule_AddObject function was introduced in Python 2.0. The following function
1386 is copied out of Python/modsupport.c in python version 2.3.4 */
1387 SWIGINTERN int
1388 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
1389 {
1390 PyObject *dict;
1391 if (!PyModule_Check(m)) {
1392 PyErr_SetString(PyExc_TypeError,
1393 "PyModule_AddObject() needs module as first arg");
1394 return -1;
1395 }
1396 if (!o) {
1397 PyErr_SetString(PyExc_TypeError,
1398 "PyModule_AddObject() needs non-NULL value");
1399 return -1;
1400 }
1401
1402 dict = PyModule_GetDict(m);
1403 if (dict == NULL) {
1404 /* Internal error -- modules must have a dict! */
1405 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
1406 PyModule_GetName(m));
1407 return -1;
1408 }
1409 if (PyDict_SetItemString(dict, name, o))
1410 return -1;
1411 Py_DECREF(o);
1412 return 0;
1413 }
1414 #endif
1415
1416 SWIGRUNTIME void
1417 SWIG_Python_SetModule(swig_module_info *swig_module) {
1418 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1419
1420 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1421 swig_empty_runtime_method_table);
1422 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1423 if (pointer && module) {
1424 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1425 }
1426 }
1427
1428 #ifdef __cplusplus
1429 }
1430 #endif
1431
1432
1433 /* -------- TYPES TABLE (BEGIN) -------- */
1434
1435 #define SWIGTYPE_p_char swig_types[0]
1436 #define SWIGTYPE_p_form_ops_t swig_types[1]
1437 #define SWIGTYPE_p_int swig_types[2]
1438 #define SWIGTYPE_p_long swig_types[3]
1439 #define SWIGTYPE_p_unsigned_char swig_types[4]
1440 #define SWIGTYPE_p_unsigned_int swig_types[5]
1441 #define SWIGTYPE_p_unsigned_long swig_types[6]
1442 #define SWIGTYPE_p_wxANIHandler swig_types[7]
1443 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
1444 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
1445 #define SWIGTYPE_p_wxArrayString swig_types[10]
1446 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
1447 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
1448 #define SWIGTYPE_p_wxCURHandler swig_types[13]
1449 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
1450 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
1451 #define SWIGTYPE_p_wxCloseEvent swig_types[16]
1452 #define SWIGTYPE_p_wxColour swig_types[17]
1453 #define SWIGTYPE_p_wxColourData swig_types[18]
1454 #define SWIGTYPE_p_wxColourDialog swig_types[19]
1455 #define SWIGTYPE_p_wxCommandEvent swig_types[20]
1456 #define SWIGTYPE_p_wxContextMenuEvent swig_types[21]
1457 #define SWIGTYPE_p_wxControl swig_types[22]
1458 #define SWIGTYPE_p_wxControlWithItems swig_types[23]
1459 #define SWIGTYPE_p_wxDC swig_types[24]
1460 #define SWIGTYPE_p_wxDateEvent swig_types[25]
1461 #define SWIGTYPE_p_wxDialog swig_types[26]
1462 #define SWIGTYPE_p_wxDirDialog swig_types[27]
1463 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[28]
1464 #define SWIGTYPE_p_wxDropFilesEvent swig_types[29]
1465 #define SWIGTYPE_p_wxDuplexMode swig_types[30]
1466 #define SWIGTYPE_p_wxEraseEvent swig_types[31]
1467 #define SWIGTYPE_p_wxEvent swig_types[32]
1468 #define SWIGTYPE_p_wxEvtHandler swig_types[33]
1469 #define SWIGTYPE_p_wxFSFile swig_types[34]
1470 #define SWIGTYPE_p_wxFileDialog swig_types[35]
1471 #define SWIGTYPE_p_wxFileSystem swig_types[36]
1472 #define SWIGTYPE_p_wxFindDialogEvent swig_types[37]
1473 #define SWIGTYPE_p_wxFindReplaceData swig_types[38]
1474 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[39]
1475 #define SWIGTYPE_p_wxFlexGridSizer swig_types[40]
1476 #define SWIGTYPE_p_wxFocusEvent swig_types[41]
1477 #define SWIGTYPE_p_wxFont swig_types[42]
1478 #define SWIGTYPE_p_wxFontData swig_types[43]
1479 #define SWIGTYPE_p_wxFontDialog swig_types[44]
1480 #define SWIGTYPE_p_wxFrame swig_types[45]
1481 #define SWIGTYPE_p_wxGBSizerItem swig_types[46]
1482 #define SWIGTYPE_p_wxGIFHandler swig_types[47]
1483 #define SWIGTYPE_p_wxGrid swig_types[48]
1484 #define SWIGTYPE_p_wxGridBagSizer swig_types[49]
1485 #define SWIGTYPE_p_wxGridCellAttr swig_types[50]
1486 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[51]
1487 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[52]
1488 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[53]
1489 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[54]
1490 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[55]
1491 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[56]
1492 #define SWIGTYPE_p_wxGridCellCoords swig_types[57]
1493 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[58]
1494 #define SWIGTYPE_p_wxGridCellEditor swig_types[59]
1495 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[60]
1496 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[61]
1497 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[62]
1498 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[63]
1499 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[64]
1500 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[65]
1501 #define SWIGTYPE_p_wxGridCellRenderer swig_types[66]
1502 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[67]
1503 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[68]
1504 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[69]
1505 #define SWIGTYPE_p_wxGridEvent swig_types[70]
1506 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[71]
1507 #define SWIGTYPE_p_wxGridSizeEvent swig_types[72]
1508 #define SWIGTYPE_p_wxGridSizer swig_types[73]
1509 #define SWIGTYPE_p_wxGridStringTable swig_types[74]
1510 #define SWIGTYPE_p_wxGridTableBase swig_types[75]
1511 #define SWIGTYPE_p_wxGridTableMessage swig_types[76]
1512 #define SWIGTYPE_p_wxICOHandler swig_types[77]
1513 #define SWIGTYPE_p_wxIconizeEvent swig_types[78]
1514 #define SWIGTYPE_p_wxIdleEvent swig_types[79]
1515 #define SWIGTYPE_p_wxImage swig_types[80]
1516 #define SWIGTYPE_p_wxImageHandler swig_types[81]
1517 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[82]
1518 #define SWIGTYPE_p_wxInitDialogEvent swig_types[83]
1519 #define SWIGTYPE_p_wxJPEGHandler swig_types[84]
1520 #define SWIGTYPE_p_wxKeyEvent swig_types[85]
1521 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[86]
1522 #define SWIGTYPE_p_wxLayoutConstraints swig_types[87]
1523 #define SWIGTYPE_p_wxMDIChildFrame swig_types[88]
1524 #define SWIGTYPE_p_wxMDIClientWindow swig_types[89]
1525 #define SWIGTYPE_p_wxMDIParentFrame swig_types[90]
1526 #define SWIGTYPE_p_wxMaximizeEvent swig_types[91]
1527 #define SWIGTYPE_p_wxMenu swig_types[92]
1528 #define SWIGTYPE_p_wxMenuBar swig_types[93]
1529 #define SWIGTYPE_p_wxMenuEvent swig_types[94]
1530 #define SWIGTYPE_p_wxMenuItem swig_types[95]
1531 #define SWIGTYPE_p_wxMessageDialog swig_types[96]
1532 #define SWIGTYPE_p_wxMiniFrame swig_types[97]
1533 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[98]
1534 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
1535 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
1536 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[101]
1537 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
1538 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
1539 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
1540 #define SWIGTYPE_p_wxObject swig_types[105]
1541 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
1542 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
1543 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
1544 #define SWIGTYPE_p_wxPageSetupDialog swig_types[109]
1545 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[110]
1546 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
1547 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
1548 #define SWIGTYPE_p_wxPanel swig_types[113]
1549 #define SWIGTYPE_p_wxPaperSize swig_types[114]
1550 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[115]
1551 #define SWIGTYPE_p_wxPoint swig_types[116]
1552 #define SWIGTYPE_p_wxPopupWindow swig_types[117]
1553 #define SWIGTYPE_p_wxPreviewCanvas swig_types[118]
1554 #define SWIGTYPE_p_wxPreviewControlBar swig_types[119]
1555 #define SWIGTYPE_p_wxPreviewFrame swig_types[120]
1556 #define SWIGTYPE_p_wxPrintData swig_types[121]
1557 #define SWIGTYPE_p_wxPrintDialog swig_types[122]
1558 #define SWIGTYPE_p_wxPrintDialogData swig_types[123]
1559 #define SWIGTYPE_p_wxPrintPreview swig_types[124]
1560 #define SWIGTYPE_p_wxPrinter swig_types[125]
1561 #define SWIGTYPE_p_wxProgressDialog swig_types[126]
1562 #define SWIGTYPE_p_wxPyApp swig_types[127]
1563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[128]
1564 #define SWIGTYPE_p_wxPyEvent swig_types[129]
1565 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[130]
1566 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[131]
1567 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[132]
1568 #define SWIGTYPE_p_wxPyGridTableBase swig_types[133]
1569 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[134]
1570 #define SWIGTYPE_p_wxPyImageHandler swig_types[135]
1571 #define SWIGTYPE_p_wxPyPanel swig_types[136]
1572 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[137]
1573 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[138]
1574 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[139]
1575 #define SWIGTYPE_p_wxPyPrintPreview swig_types[140]
1576 #define SWIGTYPE_p_wxPyPrintout swig_types[141]
1577 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[142]
1578 #define SWIGTYPE_p_wxPySizer swig_types[143]
1579 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[144]
1580 #define SWIGTYPE_p_wxPyVListBox swig_types[145]
1581 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[146]
1582 #define SWIGTYPE_p_wxPyValidator swig_types[147]
1583 #define SWIGTYPE_p_wxPyWindow swig_types[148]
1584 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[149]
1585 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[150]
1586 #define SWIGTYPE_p_wxRect swig_types[151]
1587 #define SWIGTYPE_p_wxSashEvent swig_types[152]
1588 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[153]
1589 #define SWIGTYPE_p_wxSashWindow swig_types[154]
1590 #define SWIGTYPE_p_wxScrollEvent swig_types[155]
1591 #define SWIGTYPE_p_wxScrollWinEvent swig_types[156]
1592 #define SWIGTYPE_p_wxScrolledWindow swig_types[157]
1593 #define SWIGTYPE_p_wxSetCursorEvent swig_types[158]
1594 #define SWIGTYPE_p_wxShowEvent swig_types[159]
1595 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[160]
1596 #define SWIGTYPE_p_wxSize swig_types[161]
1597 #define SWIGTYPE_p_wxSizeEvent swig_types[162]
1598 #define SWIGTYPE_p_wxSizer swig_types[163]
1599 #define SWIGTYPE_p_wxSizerItem swig_types[164]
1600 #define SWIGTYPE_p_wxSplashScreen swig_types[165]
1601 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[166]
1602 #define SWIGTYPE_p_wxSplitterEvent swig_types[167]
1603 #define SWIGTYPE_p_wxSplitterWindow swig_types[168]
1604 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[169]
1605 #define SWIGTYPE_p_wxStatusBar swig_types[170]
1606 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[171]
1607 #define SWIGTYPE_p_wxString swig_types[172]
1608 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[173]
1609 #define SWIGTYPE_p_wxTIFFHandler swig_types[174]
1610 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[175]
1611 #define SWIGTYPE_p_wxTextEntryDialog swig_types[176]
1612 #define SWIGTYPE_p_wxTipWindow swig_types[177]
1613 #define SWIGTYPE_p_wxTopLevelWindow swig_types[178]
1614 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[179]
1615 #define SWIGTYPE_p_wxValidator swig_types[180]
1616 #define SWIGTYPE_p_wxVisualAttributes swig_types[181]
1617 #define SWIGTYPE_p_wxWindow swig_types[182]
1618 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[183]
1619 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[184]
1620 #define SWIGTYPE_p_wxXPMHandler swig_types[185]
1621 #define SWIGTYPE_ptrdiff_t swig_types[186]
1622 #define SWIGTYPE_std__ptrdiff_t swig_types[187]
1623 #define SWIGTYPE_unsigned_int swig_types[188]
1624 static swig_type_info *swig_types[190];
1625 static swig_module_info swig_module = {swig_types, 189, 0, 0, 0, 0};
1626 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1627 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1628
1629 /* -------- TYPES TABLE (END) -------- */
1630
1631
1632 /*-----------------------------------------------
1633 @(target):= _grid.so
1634 ------------------------------------------------*/
1635 #define SWIG_init init_grid
1636
1637 #define SWIG_name "_grid"
1638
1639 #include "wx/wxPython/wxPython.h"
1640 #include "wx/wxPython/pyclasses.h"
1641 #include "wx/wxPython/printfw.h"
1642
1643 #include <wx/grid.h>
1644 #include <wx/generic/gridctrl.h>
1645
1646
1647 static const wxString wxPyEmptyString(wxEmptyString);
1648 static const wxString wxPyPanelNameStr(wxPanelNameStr);
1649 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
1650
1651
1652 #define wxPyMake_TEMPLATE(TYPE) \
1653 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
1654 PyObject* target = NULL; \
1655 if (source) { \
1656 /* Check if there is already a pointer to a Python object in the \
1657 OOR data that we can use. */ \
1658 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
1659 if (data) { \
1660 target = data->m_obj; \
1661 if (target) \
1662 Py_INCREF(target); \
1663 } \
1664 /* Otherwise make a new wrapper for it the old fashioned way and \
1665 give it the OOR treatment */ \
1666 if (! target) { \
1667 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
1668 if (target) \
1669 source->SetClientObject(new wxPyOORClientData(target)); \
1670 } \
1671 } else { /* source was NULL so return None. */ \
1672 Py_INCREF(Py_None); target = Py_None; \
1673 } \
1674 return target; \
1675 } \
1676
1677
1678 wxPyMake_TEMPLATE(wxGridCellRenderer)
1679 wxPyMake_TEMPLATE(wxGridCellEditor)
1680 wxPyMake_TEMPLATE(wxGridCellAttr)
1681 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
1682 wxPyMake_TEMPLATE(wxGridTableBase)
1683
1684
1685
1686 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
1687 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
1688 wxGridCellAttr* rval = NULL; \
1689 bool found; \
1690 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1691 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1692 PyObject* ro; \
1693 wxGridCellAttr* ptr; \
1694 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
1695 if (ro) { \
1696 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
1697 rval = ptr; \
1698 Py_DECREF(ro); \
1699 } \
1700 } \
1701 wxPyEndBlockThreads(blocked); \
1702 if (! found) \
1703 rval = PCLASS::CBNAME(a, b, c); \
1704 return rval; \
1705 } \
1706 wxGridCellAttr *base_##CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
1707 return PCLASS::CBNAME(a, b, c); \
1708 }
1709
1710
1711
1712 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
1713 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
1714 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1715 bool found; \
1716 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1717 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
1718 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
1719 Py_DECREF(obj); \
1720 } \
1721 wxPyEndBlockThreads(blocked); \
1722 if (! found) \
1723 PCLASS::CBNAME(attr, a, b); \
1724 } \
1725 void base_##CBNAME(wxGridCellAttr *attr, int a, int b) { \
1726 PCLASS::CBNAME(attr, a, b); \
1727 }
1728
1729
1730
1731 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
1732 void CBNAME(wxGridCellAttr *attr, int val) { \
1733 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1734 bool found; \
1735 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1736 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
1737 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
1738 Py_DECREF(obj); \
1739 } \
1740 wxPyEndBlockThreads(blocked); \
1741 if (! found) \
1742 PCLASS::CBNAME(attr, val); \
1743 } \
1744 void base_##CBNAME(wxGridCellAttr *attr, int val) { \
1745 PCLASS::CBNAME(attr, val); \
1746 }
1747
1748
1749
1750 #define PYCALLBACK_INT__pure(CBNAME) \
1751 int CBNAME() { \
1752 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1753 int rval = 0; \
1754 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1755 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1756 wxPyEndBlockThreads(blocked); \
1757 return rval; \
1758 }
1759
1760
1761
1762 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
1763 bool CBNAME(int a, int b) { \
1764 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1765 bool rval = 0; \
1766 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1767 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
1768 wxPyEndBlockThreads(blocked); \
1769 return rval; \
1770 }
1771
1772
1773 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
1774 wxString CBNAME(int a, int b) { \
1775 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1776 wxString rval; \
1777 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1778 PyObject* ro; \
1779 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1780 if (ro) { \
1781 rval = Py2wxString(ro); \
1782 Py_DECREF(ro); \
1783 } \
1784 } \
1785 wxPyEndBlockThreads(blocked); \
1786 return rval; \
1787 }
1788
1789
1790 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
1791 void CBNAME(int a, int b, const wxString& c) { \
1792 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1793 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1794 PyObject* s = wx2PyString(c); \
1795 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1796 Py_DECREF(s); \
1797 } \
1798 wxPyEndBlockThreads(blocked); \
1799 }
1800
1801
1802 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
1803 wxString CBNAME(int a, int b) { \
1804 bool found; \
1805 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1806 wxString rval; \
1807 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1808 PyObject* ro; \
1809 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1810 if (ro) { \
1811 rval = Py2wxString(ro); \
1812 Py_DECREF(ro); \
1813 } \
1814 } \
1815 wxPyEndBlockThreads(blocked); \
1816 if (! found) \
1817 rval = PCLASS::CBNAME(a, b); \
1818 return rval; \
1819 } \
1820 wxString base_##CBNAME(int a, int b) { \
1821 return PCLASS::CBNAME(a, b); \
1822 }
1823
1824
1825 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
1826 bool CBNAME(int a, int b, const wxString& c) { \
1827 bool rval = 0; \
1828 bool found; \
1829 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1830 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1831 PyObject* s = wx2PyString(c); \
1832 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1833 Py_DECREF(s); \
1834 } \
1835 wxPyEndBlockThreads(blocked); \
1836 if (! found) \
1837 rval = PCLASS::CBNAME(a,b,c); \
1838 return rval; \
1839 } \
1840 bool base_##CBNAME(int a, int b, const wxString& c) { \
1841 return PCLASS::CBNAME(a,b,c); \
1842 }
1843
1844
1845
1846
1847 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
1848 long CBNAME(int a, int b) { \
1849 long rval; \
1850 bool found; \
1851 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1852 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1853 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1854 wxPyEndBlockThreads(blocked); \
1855 if (! found) \
1856 rval = PCLASS::CBNAME(a,b); \
1857 return rval; \
1858 } \
1859 long base_##CBNAME(int a, int b) { \
1860 return PCLASS::CBNAME(a,b); \
1861 }
1862
1863
1864
1865 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
1866 bool CBNAME(int a, int b) { \
1867 bool rval = 0; \
1868 bool found; \
1869 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1870 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1871 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1872 wxPyEndBlockThreads(blocked); \
1873 if (! found) \
1874 rval = PCLASS::CBNAME(a,b); \
1875 return rval; \
1876 } \
1877 bool base_##CBNAME(int a, int b) { \
1878 return PCLASS::CBNAME(a,b); \
1879 }
1880
1881
1882
1883 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
1884 double CBNAME(int a, int b) { \
1885 bool found; \
1886 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1887 double rval; \
1888 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1889 PyObject* ro; \
1890 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
1891 if (ro) { \
1892 PyObject* str = PyObject_Str(ro); \
1893 rval = PyFloat_AsDouble(str); \
1894 Py_DECREF(ro); Py_DECREF(str); \
1895 } \
1896 } \
1897 wxPyEndBlockThreads(blocked); \
1898 if (! found) \
1899 rval = PCLASS::CBNAME(a, b); \
1900 return rval; \
1901 } \
1902 double base_##CBNAME(int a, int b) { \
1903 return PCLASS::CBNAME(a, b); \
1904 }
1905
1906
1907
1908 #define PYCALLBACK__(PCLASS, CBNAME) \
1909 void CBNAME() { \
1910 bool found; \
1911 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1912 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1913 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1914 wxPyEndBlockThreads(blocked); \
1915 if (! found) \
1916 PCLASS::CBNAME(); \
1917 } \
1918 void base_##CBNAME() { \
1919 PCLASS::CBNAME(); \
1920 }
1921
1922
1923
1924
1925 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
1926 bool CBNAME(size_t a, size_t b) { \
1927 bool rval = 0; \
1928 bool found; \
1929 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1930 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1931 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
1932 wxPyEndBlockThreads(blocked); \
1933 if (! found) \
1934 rval = PCLASS::CBNAME(a,b); \
1935 return rval; \
1936 } \
1937 bool base_##CBNAME(size_t a, size_t b) { \
1938 return PCLASS::CBNAME(a,b); \
1939 }
1940
1941
1942
1943 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
1944 bool CBNAME(size_t a) { \
1945 bool rval = 0; \
1946 bool found; \
1947 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1948 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1949 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
1950 wxPyEndBlockThreads(blocked); \
1951 if (! found) \
1952 rval = PCLASS::CBNAME(a); \
1953 return rval; \
1954 } \
1955 bool base_##CBNAME(size_t a) { \
1956 return PCLASS::CBNAME(a); \
1957 }
1958
1959
1960 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
1961 wxString CBNAME(int a) { \
1962 bool found; \
1963 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1964 wxString rval; \
1965 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1966 PyObject* ro; \
1967 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
1968 if (ro) { \
1969 rval = Py2wxString(ro); \
1970 Py_DECREF(ro); \
1971 } \
1972 } \
1973 wxPyEndBlockThreads(blocked); \
1974 if (! found) \
1975 rval = PCLASS::CBNAME(a); \
1976 return rval; \
1977 } \
1978 wxString base_##CBNAME(int a) { \
1979 return PCLASS::CBNAME(a); \
1980 }
1981
1982
1983 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
1984 void CBNAME(int a, const wxString& c) { \
1985 bool found; \
1986 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1987 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1988 PyObject* s = wx2PyString(c); \
1989 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
1990 Py_DECREF(s); \
1991 } \
1992 wxPyEndBlockThreads(blocked); \
1993 if (! found) \
1994 PCLASS::CBNAME(a,c); \
1995 } \
1996 void base_##CBNAME(int a, const wxString& c) { \
1997 PCLASS::CBNAME(a,c); \
1998 }
1999
2000
2001
2002
2003 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
2004 bool CBNAME() { \
2005 bool rval = 0; \
2006 bool found; \
2007 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2008 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2009 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2010 wxPyEndBlockThreads(blocked); \
2011 if (! found) \
2012 rval = PCLASS::CBNAME(); \
2013 return rval; \
2014 } \
2015 bool base_##CBNAME() { \
2016 return PCLASS::CBNAME(); \
2017 }
2018
2019
2020
2021 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
2022 void CBNAME(size_t a, int b) { \
2023 bool found; \
2024 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2025 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2026 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2027 wxPyEndBlockThreads(blocked); \
2028 if (! found) \
2029 PCLASS::CBNAME(a,b); \
2030 } \
2031 void base_##CBNAME(size_t a, int b) { \
2032 PCLASS::CBNAME(a,b); \
2033 }
2034
2035
2036
2037
2038 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
2039 void CBNAME(int a, int b, long c) { \
2040 bool found; \
2041 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2042 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2043 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
2044 wxPyEndBlockThreads(blocked); \
2045 if (! found) \
2046 PCLASS::CBNAME(a,b,c); \
2047 } \
2048 void base_##CBNAME(int a, int b, long c) { \
2049 PCLASS::CBNAME(a,b,c); \
2050 }
2051
2052
2053
2054
2055 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
2056 void CBNAME(int a, int b, double c) { \
2057 bool found; \
2058 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2059 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2060 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
2061 wxPyEndBlockThreads(blocked); \
2062 if (! found) \
2063 PCLASS::CBNAME(a,b,c); \
2064 } \
2065 void base_##CBNAME(int a, int b, double c) { \
2066 PCLASS::CBNAME(a,b,c); \
2067 }
2068
2069
2070
2071 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
2072 void CBNAME(int a, int b, bool c) { \
2073 bool found; \
2074 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2075 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2076 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
2077 wxPyEndBlockThreads(blocked); \
2078 if (! found) \
2079 PCLASS::CBNAME(a,b,c); \
2080 } \
2081 void base_##CBNAME(int a, int b, bool c) { \
2082 PCLASS::CBNAME(a,b,c); \
2083 }
2084
2085
2086
2087
2088
2089
2090 SWIGINTERN PyObject *
2091 SWIG_FromCharPtr(const char* cptr)
2092 {
2093 if (cptr) {
2094 size_t size = strlen(cptr);
2095 if (size > INT_MAX) {
2096 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2097 SWIG_TypeQuery("char *"), 0);
2098 } else {
2099 if (size != 0) {
2100 return PyString_FromStringAndSize(cptr, size);
2101 } else {
2102 return PyString_FromString(cptr);
2103 }
2104 }
2105 }
2106 Py_INCREF(Py_None);
2107 return Py_None;
2108 }
2109
2110
2111 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
2112 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
2113 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
2114 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
2115 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
2116 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
2117 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
2118 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
2119 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
2120 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
2121
2122
2123 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2124 #define SWIG_From_int PyInt_FromLong
2125 /*@@*/
2126
2127 static void wxGridCellRenderer__setOORInfo(wxGridCellRenderer *self,PyObject *_self){
2128 if (!self->GetClientObject())
2129 self->SetClientObject(new wxPyOORClientData(_self));
2130 }
2131
2132 #include <limits.h>
2133
2134
2135 SWIGINTERN int
2136 SWIG_CheckLongInRange(long value, long min_value, long max_value,
2137 const char *errmsg)
2138 {
2139 if (value < min_value) {
2140 if (errmsg) {
2141 PyErr_Format(PyExc_OverflowError,
2142 "value %ld is less than '%s' minimum %ld",
2143 value, errmsg, min_value);
2144 }
2145 return 0;
2146 } else if (value > max_value) {
2147 if (errmsg) {
2148 PyErr_Format(PyExc_OverflowError,
2149 "value %ld is greater than '%s' maximum %ld",
2150 value, errmsg, max_value);
2151 }
2152 return 0;
2153 }
2154 return 1;
2155 }
2156
2157
2158 SWIGINTERN int
2159 SWIG_AsVal_long(PyObject* obj, long* val)
2160 {
2161 if (PyNumber_Check(obj)) {
2162 if (val) *val = PyInt_AsLong(obj);
2163 return 1;
2164 }
2165 else {
2166 SWIG_Python_TypeError("number", obj);
2167 }
2168 return 0;
2169 }
2170
2171
2172 #if INT_MAX != LONG_MAX
2173 SWIGINTERN int
2174 SWIG_AsVal_int(PyObject *obj, int *val)
2175 {
2176 const char* errmsg = val ? "int" : (char*)0;
2177 long v;
2178 if (SWIG_AsVal_long(obj, &v)) {
2179 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
2180 if (val) *val = static_cast<int >(v);
2181 return 1;
2182 } else {
2183 return 0;
2184 }
2185 } else {
2186 PyErr_Clear();
2187 }
2188 if (val) {
2189 SWIG_type_error(errmsg, obj);
2190 }
2191 return 0;
2192 }
2193 #else
2194 SWIGINTERNINLINE int
2195 SWIG_AsVal_int(PyObject *obj, int *val)
2196 {
2197 return SWIG_AsVal_long(obj,(long*)val);
2198 }
2199 #endif
2200
2201
2202 SWIGINTERNINLINE int
2203 SWIG_As_int(PyObject* obj)
2204 {
2205 int v;
2206 if (!SWIG_AsVal_int(obj, &v)) {
2207 /*
2208 this is needed to make valgrind/purify happier.
2209 */
2210 memset((void*)&v, 0, sizeof(int));
2211 }
2212 return v;
2213 }
2214
2215
2216 SWIGINTERN int
2217 SWIG_AsVal_bool(PyObject *obj, bool *val)
2218 {
2219 if (obj == Py_True) {
2220 if (val) *val = true;
2221 return 1;
2222 }
2223 if (obj == Py_False) {
2224 if (val) *val = false;
2225 return 1;
2226 }
2227 int res = 0;
2228 if (SWIG_AsVal_int(obj, &res)) {
2229 if (val) *val = res ? true : false;
2230 return 1;
2231 } else {
2232 PyErr_Clear();
2233 }
2234 if (val) {
2235 SWIG_type_error("bool", obj);
2236 }
2237 return 0;
2238 }
2239
2240
2241 SWIGINTERNINLINE bool
2242 SWIG_As_bool(PyObject* obj)
2243 {
2244 bool v;
2245 if (!SWIG_AsVal_bool(obj, &v)) {
2246 /*
2247 this is needed to make valgrind/purify happier.
2248 */
2249 memset((void*)&v, 0, sizeof(bool));
2250 }
2251 return v;
2252 }
2253
2254
2255 SWIGINTERNINLINE int
2256 SWIG_Check_int(PyObject* obj)
2257 {
2258 return SWIG_AsVal_int(obj, (int*)0);
2259 }
2260
2261
2262 SWIGINTERNINLINE int
2263 SWIG_Check_bool(PyObject* obj)
2264 {
2265 return SWIG_AsVal_bool(obj, (bool*)0);
2266 }
2267
2268
2269 class wxPyGridCellRenderer : public wxGridCellRenderer
2270 {
2271 public:
2272 wxPyGridCellRenderer() : wxGridCellRenderer() {};
2273
2274 // Implement Python callback aware virtual methods
2275 void Draw(wxGrid& grid, wxGridCellAttr& attr,
2276 wxDC& dc, const wxRect& rect,
2277 int row, int col, bool isSelected) {
2278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2279 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
2280 PyObject* go = wxPyMake_wxObject(&grid,false);
2281 PyObject* dco = wxPyMake_wxObject(&dc,false);
2282 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
2283 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
2284
2285 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
2286 row, col, isSelected));
2287 Py_DECREF(go);
2288 Py_DECREF(ao);
2289 Py_DECREF(dco);
2290 Py_DECREF(ro);
2291 }
2292 wxPyEndBlockThreads(blocked);
2293 }
2294
2295 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
2296 int row, int col) {
2297 wxSize rval;
2298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2299 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
2300 PyObject* ro;
2301 wxSize* ptr;
2302 PyObject* go = wxPyMake_wxObject(&grid,false);
2303 PyObject* dco = wxPyMake_wxObject(&dc,false);
2304 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
2305
2306 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
2307 go, ao, dco,
2308 row, col));
2309 Py_DECREF(go);
2310 Py_DECREF(ao);
2311 Py_DECREF(dco);
2312
2313 if (ro) {
2314 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
2315 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
2316 rval = *ptr;
2317 }
2318 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
2319 PyObject* o1 = PySequence_GetItem(ro, 0);
2320 PyObject* o2 = PySequence_GetItem(ro, 1);
2321 if (PyNumber_Check(o1) && PyNumber_Check(o2))
2322 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
2323 else
2324 PyErr_SetString(PyExc_TypeError, errmsg);
2325 Py_DECREF(o1);
2326 Py_DECREF(o2);
2327 }
2328 else {
2329 PyErr_SetString(PyExc_TypeError, errmsg);
2330 }
2331 Py_DECREF(ro);
2332 }
2333 }
2334 wxPyEndBlockThreads(blocked);
2335 return rval;
2336 }
2337
2338
2339 wxGridCellRenderer *Clone() const {
2340 wxGridCellRenderer* rval = NULL;
2341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2342 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
2343 PyObject* ro;
2344 wxGridCellRenderer* ptr;
2345 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2346 if (ro) {
2347 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
2348 rval = ptr;
2349 Py_DECREF(ro);
2350 }
2351 }
2352 wxPyEndBlockThreads(blocked);
2353 return rval;
2354 }
2355
2356 DEC_PYCALLBACK__STRING(SetParameters);
2357
2358 PYPRIVATE;
2359 };
2360
2361 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
2362
2363
2364 static void wxGridCellEditor__setOORInfo(wxGridCellEditor *self,PyObject *_self){
2365 if (!self->GetClientObject())
2366 self->SetClientObject(new wxPyOORClientData(_self));
2367 }
2368
2369 class wxPyGridCellEditor : public wxGridCellEditor
2370 {
2371 public:
2372 wxPyGridCellEditor() : wxGridCellEditor() {}
2373
2374 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
2375 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2376 if (wxPyCBH_findCallback(m_myInst, "Create")) {
2377 PyObject* po = wxPyMake_wxObject(parent,false);
2378 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
2379
2380 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
2381 Py_DECREF(po);
2382 Py_DECREF(eo);
2383 }
2384 wxPyEndBlockThreads(blocked);
2385 }
2386
2387
2388 void BeginEdit(int row, int col, wxGrid* grid) {
2389 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2390 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
2391 PyObject* go = wxPyMake_wxObject(grid,false);
2392 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
2393 Py_DECREF(go);
2394 }
2395 wxPyEndBlockThreads(blocked);
2396 }
2397
2398
2399 bool EndEdit(int row, int col, wxGrid* grid) {
2400 bool rv = false;
2401 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2402 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
2403 PyObject* go = wxPyMake_wxObject(grid,false);
2404 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
2405 Py_DECREF(go);
2406 }
2407 wxPyEndBlockThreads(blocked);
2408 return rv;
2409 }
2410
2411
2412 wxGridCellEditor* Clone() const {
2413 wxGridCellEditor* rval = NULL;
2414 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2415 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
2416 PyObject* ro;
2417 wxGridCellEditor* ptr;
2418 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2419 if (ro) {
2420 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
2421 rval = ptr;
2422 Py_DECREF(ro);
2423 }
2424 }
2425 wxPyEndBlockThreads(blocked);
2426 return rval;
2427 }
2428
2429
2430 void Show(bool show, wxGridCellAttr *attr) {
2431 bool found;
2432 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2433 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
2434 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
2435 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
2436 Py_DECREF(ao);
2437 }
2438 wxPyEndBlockThreads(blocked);
2439 if (! found)
2440 wxGridCellEditor::Show(show, attr);
2441 }
2442 void base_Show(bool show, wxGridCellAttr *attr) {
2443 wxGridCellEditor::Show(show, attr);
2444 }
2445
2446
2447 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
2448 bool found;
2449 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2450 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
2451 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
2452 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
2453
2454 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
2455
2456 Py_DECREF(ro);
2457 Py_DECREF(ao);
2458 }
2459 wxPyEndBlockThreads(blocked);
2460 if (! found)
2461 wxGridCellEditor::PaintBackground(rectCell, attr);
2462 }
2463 void base_PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
2464 wxGridCellEditor::PaintBackground(rectCell, attr);
2465 }
2466
2467
2468 DEC_PYCALLBACK___pure(Reset);
2469 DEC_PYCALLBACK__constany(SetSize, wxRect);
2470 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
2471 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
2472 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
2473 DEC_PYCALLBACK__(StartingClick);
2474 DEC_PYCALLBACK__(Destroy);
2475 DEC_PYCALLBACK__STRING(SetParameters);
2476 DEC_PYCALLBACK_STRING__constpure(GetValue);
2477
2478 PYPRIVATE;
2479 };
2480
2481
2482 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
2483 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
2484 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
2485 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
2486 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
2487 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
2488 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
2489 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
2490 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
2491
2492
2493 static void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
2494 if (!self->GetClientObject())
2495 self->SetClientObject(new wxPyOORClientData(_self));
2496 }
2497
2498 static PyObject* t_output_helper(PyObject* result, PyObject* obj)
2499 {
2500 PyObject* o2;
2501 PyObject* o3;
2502 if (!result) {
2503 result = obj;
2504 } else if (result == Py_None) {
2505 Py_DECREF(result);
2506 result = obj;
2507 } else {
2508 if (!PyTuple_Check(result)) {
2509 o2 = result;
2510 result = PyTuple_New(1);
2511 PyTuple_SET_ITEM(result, 0, o2);
2512 }
2513 o3 = PyTuple_New(1);
2514 PyTuple_SetItem(o3, 0, obj);
2515 o2 = result;
2516 result = PySequence_Concat(o2, o3);
2517 Py_DECREF(o2);
2518 Py_DECREF(o3);
2519 }
2520 return result;
2521 }
2522
2523
2524 static void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
2525 if (!self->GetClientObject())
2526 self->SetClientObject(new wxPyOORClientData(_self));
2527 }
2528
2529 SWIGINTERN int
2530 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2531 {
2532 long v = 0;
2533 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2534 SWIG_Python_TypeError("unsigned number", obj);
2535 }
2536 else if (val)
2537 *val = (unsigned long)v;
2538 return 1;
2539 }
2540
2541
2542 SWIGINTERNINLINE unsigned long
2543 SWIG_As_unsigned_SS_long(PyObject* obj)
2544 {
2545 unsigned long v;
2546 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2547 /*
2548 this is needed to make valgrind/purify happier.
2549 */
2550 memset((void*)&v, 0, sizeof(unsigned long));
2551 }
2552 return v;
2553 }
2554
2555
2556 SWIGINTERNINLINE int
2557 SWIG_Check_unsigned_SS_long(PyObject* obj)
2558 {
2559 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2560 }
2561
2562
2563 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
2564 {
2565 public:
2566 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
2567
2568 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
2569 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
2570 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
2571 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
2572
2573 PYPRIVATE;
2574 };
2575
2576 static void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
2577 if (!self->GetClientObject())
2578 self->SetClientObject(new wxPyOORClientData(_self));
2579 }
2580
2581 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2582 #define SWIG_From_long PyInt_FromLong
2583 /*@@*/
2584
2585
2586 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2587 #define SWIG_From_double PyFloat_FromDouble
2588 /*@@*/
2589
2590
2591 SWIGINTERNINLINE long
2592 SWIG_As_long(PyObject* obj)
2593 {
2594 long v;
2595 if (!SWIG_AsVal_long(obj, &v)) {
2596 /*
2597 this is needed to make valgrind/purify happier.
2598 */
2599 memset((void*)&v, 0, sizeof(long));
2600 }
2601 return v;
2602 }
2603
2604
2605 SWIGINTERNINLINE int
2606 SWIG_Check_long(PyObject* obj)
2607 {
2608 return SWIG_AsVal_long(obj, (long*)0);
2609 }
2610
2611
2612 SWIGINTERN int
2613 SWIG_AsVal_double(PyObject *obj, double* val)
2614 {
2615 if (PyNumber_Check(obj)) {
2616 if (val) *val = PyFloat_AsDouble(obj);
2617 return 1;
2618 }
2619 else {
2620 SWIG_Python_TypeError("number", obj);
2621 }
2622 return 0;
2623 }
2624
2625
2626 SWIGINTERNINLINE double
2627 SWIG_As_double(PyObject* obj)
2628 {
2629 double v;
2630 if (!SWIG_AsVal_double(obj, &v)) {
2631 /*
2632 this is needed to make valgrind/purify happier.
2633 */
2634 memset((void*)&v, 0, sizeof(double));
2635 }
2636 return v;
2637 }
2638
2639
2640 SWIGINTERNINLINE int
2641 SWIG_Check_double(PyObject* obj)
2642 {
2643 return SWIG_AsVal_double(obj, (double*)0);
2644 }
2645
2646
2647 class wxPyGridTableBase : public wxGridTableBase
2648 {
2649 public:
2650 wxPyGridTableBase() : wxGridTableBase() {}
2651
2652 PYCALLBACK_INT__pure(GetNumberRows);
2653 PYCALLBACK_INT__pure(GetNumberCols);
2654 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
2655 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
2656 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
2657 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
2658 PYCALLBACK__(wxGridTableBase, Clear);
2659 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
2660 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
2661 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
2662 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
2663 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
2664 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
2665 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
2666 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
2667 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
2668 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
2669 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
2670 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
2671 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
2672 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
2673 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
2674
2675
2676 wxString GetValue(int row, int col) {
2677 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2678 wxString rval;
2679 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2680 PyObject* ro;
2681 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
2682 if (ro) {
2683 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
2684 PyObject* old = ro;
2685 ro = PyObject_Str(ro);
2686 Py_DECREF(old);
2687 }
2688 rval = Py2wxString(ro);
2689 Py_DECREF(ro);
2690 }
2691 }
2692 wxPyEndBlockThreads(blocked);
2693 return rval;
2694 }
2695
2696 void SetValue(int row, int col, const wxString& val) {
2697 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2698 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2699 PyObject* s = wx2PyString(val);
2700 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
2701 Py_DECREF(s);
2702 }
2703 wxPyEndBlockThreads(blocked);
2704 }
2705
2706
2707 // Map the Get/Set methods for the standard non-string types to
2708 // the GetValue and SetValue python methods.
2709 long GetValueAsLong( int row, int col ) {
2710 long rval = 0;
2711 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2712 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2713 PyObject* ro;
2714 PyObject* num;
2715 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
2716 if (ro && PyNumber_Check(ro)) {
2717 num = PyNumber_Int(ro);
2718 if (num) {
2719 rval = PyInt_AsLong(num);
2720 Py_DECREF(num);
2721 }
2722 Py_DECREF(ro);
2723 }
2724 }
2725 wxPyEndBlockThreads(blocked);
2726 return rval;
2727 }
2728
2729 double GetValueAsDouble( int row, int col ) {
2730 double rval = 0.0;
2731 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2732 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
2733 PyObject* ro;
2734 PyObject* num;
2735 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
2736 if (ro && PyNumber_Check(ro)) {
2737 num = PyNumber_Float(ro);
2738 if (num) {
2739 rval = PyFloat_AsDouble(num);
2740 Py_DECREF(num);
2741 }
2742 Py_DECREF(ro);
2743 }
2744 }
2745 wxPyEndBlockThreads(blocked);
2746 return rval;
2747 }
2748
2749 bool GetValueAsBool( int row, int col ) {
2750 return (bool)GetValueAsLong(row, col);
2751 }
2752
2753 void SetValueAsLong( int row, int col, long value ) {
2754 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2755 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2756 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
2757 }
2758 wxPyEndBlockThreads(blocked);
2759 }
2760
2761 void SetValueAsDouble( int row, int col, double value ) {
2762 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2763 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
2764 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
2765 }
2766 wxPyEndBlockThreads(blocked);
2767 }
2768
2769 void SetValueAsBool( int row, int col, bool value ) {
2770 SetValueAsLong( row, col, (long)value );
2771 }
2772
2773
2774 PYPRIVATE;
2775 };
2776
2777 static void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
2778
2779 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
2780
2781 if (source == Py_None) {
2782 **obj = wxGridCellCoords(-1,-1);
2783 return true;
2784 }
2785
2786 // If source is an object instance then it may already be the right type
2787 if (wxPySwigInstance_Check(source)) {
2788 wxGridCellCoords* ptr;
2789 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
2790 goto error;
2791 *obj = ptr;
2792 return true;
2793 }
2794 // otherwise a 2-tuple of integers is expected
2795 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
2796 PyObject* o1 = PySequence_GetItem(source, 0);
2797 PyObject* o2 = PySequence_GetItem(source, 1);
2798 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
2799 Py_DECREF(o1);
2800 Py_DECREF(o2);
2801 goto error;
2802 }
2803 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
2804 Py_DECREF(o1);
2805 Py_DECREF(o2);
2806 return true;
2807 }
2808
2809 error:
2810 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
2811 return false;
2812 }
2813
2814
2815 bool wxGridCellCoords_typecheck(PyObject* source) {
2816 void* ptr;
2817
2818 if (wxPySwigInstance_Check(source) &&
2819 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
2820 return true;
2821
2822 PyErr_Clear();
2823 if (PySequence_Check(source) && PySequence_Length(source) == 2)
2824 return true;
2825
2826 return false;
2827 }
2828
2829
2830 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
2831 {
2832 PyObject* list = PyList_New(0);
2833 size_t idx;
2834 for (idx = 0; idx < source.GetCount(); idx += 1) {
2835 wxGridCellCoords& coord = source.Item(idx);
2836 PyObject* tup = PyTuple_New(2);
2837 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
2838 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
2839 PyList_Append(list, tup);
2840 Py_DECREF(tup);
2841 }
2842 return list;
2843 }
2844
2845 static PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
2846 PyObject* tup = PyTuple_New(2);
2847 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
2848 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
2849 return tup;
2850 }
2851
2852 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
2853
2854
2855 static wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
2856 wxGridCellCoords rv;
2857 self->XYToCell(x, y, rv);
2858 return rv;
2859 }
2860 #ifdef __cplusplus
2861 extern "C" {
2862 #endif
2863 static int _wrap_GridNoCellCoords_set(PyObject *) {
2864 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellCoords is read-only.");
2865 return 1;
2866 }
2867
2868
2869 static PyObject *_wrap_GridNoCellCoords_get(void) {
2870 PyObject *pyobj = NULL;
2871
2872 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0);
2873 return pyobj;
2874 }
2875
2876
2877 static int _wrap_GridNoCellRect_set(PyObject *) {
2878 PyErr_SetString(PyExc_TypeError,"Variable GridNoCellRect is read-only.");
2879 return 1;
2880 }
2881
2882
2883 static PyObject *_wrap_GridNoCellRect_get(void) {
2884 PyObject *pyobj = NULL;
2885
2886 pyobj = SWIG_NewPointerObj((void *)(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0);
2887 return pyobj;
2888 }
2889
2890
2891 static PyObject *_wrap_GridCellRenderer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
2892 PyObject *resultobj = NULL;
2893 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2894 PyObject *arg2 = (PyObject *) 0 ;
2895 PyObject * obj0 = 0 ;
2896 PyObject * obj1 = 0 ;
2897 char *kwnames[] = {
2898 (char *) "self",(char *) "_self", NULL
2899 };
2900
2901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
2902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2903 if (SWIG_arg_fail(1)) SWIG_fail;
2904 arg2 = obj1;
2905 {
2906 PyThreadState* __tstate = wxPyBeginAllowThreads();
2907 wxGridCellRenderer__setOORInfo(arg1,arg2);
2908
2909 wxPyEndAllowThreads(__tstate);
2910 if (PyErr_Occurred()) SWIG_fail;
2911 }
2912 Py_INCREF(Py_None); resultobj = Py_None;
2913 return resultobj;
2914 fail:
2915 return NULL;
2916 }
2917
2918
2919 static PyObject *_wrap_GridCellRenderer_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
2920 PyObject *resultobj = NULL;
2921 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2922 wxString *arg2 = 0 ;
2923 bool temp2 = false ;
2924 PyObject * obj0 = 0 ;
2925 PyObject * obj1 = 0 ;
2926 char *kwnames[] = {
2927 (char *) "self",(char *) "params", NULL
2928 };
2929
2930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) goto fail;
2931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2932 if (SWIG_arg_fail(1)) SWIG_fail;
2933 {
2934 arg2 = wxString_in_helper(obj1);
2935 if (arg2 == NULL) SWIG_fail;
2936 temp2 = true;
2937 }
2938 {
2939 PyThreadState* __tstate = wxPyBeginAllowThreads();
2940 (arg1)->SetParameters((wxString const &)*arg2);
2941
2942 wxPyEndAllowThreads(__tstate);
2943 if (PyErr_Occurred()) SWIG_fail;
2944 }
2945 Py_INCREF(Py_None); resultobj = Py_None;
2946 {
2947 if (temp2)
2948 delete arg2;
2949 }
2950 return resultobj;
2951 fail:
2952 {
2953 if (temp2)
2954 delete arg2;
2955 }
2956 return NULL;
2957 }
2958
2959
2960 static PyObject *_wrap_GridCellRenderer_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
2961 PyObject *resultobj = NULL;
2962 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2963 PyObject * obj0 = 0 ;
2964 char *kwnames[] = {
2965 (char *) "self", NULL
2966 };
2967
2968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_IncRef",kwnames,&obj0)) goto fail;
2969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2970 if (SWIG_arg_fail(1)) SWIG_fail;
2971 {
2972 PyThreadState* __tstate = wxPyBeginAllowThreads();
2973 (arg1)->IncRef();
2974
2975 wxPyEndAllowThreads(__tstate);
2976 if (PyErr_Occurred()) SWIG_fail;
2977 }
2978 Py_INCREF(Py_None); resultobj = Py_None;
2979 return resultobj;
2980 fail:
2981 return NULL;
2982 }
2983
2984
2985 static PyObject *_wrap_GridCellRenderer_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
2986 PyObject *resultobj = NULL;
2987 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
2988 PyObject * obj0 = 0 ;
2989 char *kwnames[] = {
2990 (char *) "self", NULL
2991 };
2992
2993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_DecRef",kwnames,&obj0)) goto fail;
2994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
2995 if (SWIG_arg_fail(1)) SWIG_fail;
2996 {
2997 PyThreadState* __tstate = wxPyBeginAllowThreads();
2998 (arg1)->DecRef();
2999
3000 wxPyEndAllowThreads(__tstate);
3001 if (PyErr_Occurred()) SWIG_fail;
3002 }
3003 Py_INCREF(Py_None); resultobj = Py_None;
3004 return resultobj;
3005 fail:
3006 return NULL;
3007 }
3008
3009
3010 static PyObject *_wrap_GridCellRenderer_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
3011 PyObject *resultobj = NULL;
3012 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3013 wxGrid *arg2 = 0 ;
3014 wxGridCellAttr *arg3 = 0 ;
3015 wxDC *arg4 = 0 ;
3016 wxRect *arg5 = 0 ;
3017 int arg6 ;
3018 int arg7 ;
3019 bool arg8 ;
3020 wxRect temp5 ;
3021 PyObject * obj0 = 0 ;
3022 PyObject * obj1 = 0 ;
3023 PyObject * obj2 = 0 ;
3024 PyObject * obj3 = 0 ;
3025 PyObject * obj4 = 0 ;
3026 PyObject * obj5 = 0 ;
3027 PyObject * obj6 = 0 ;
3028 PyObject * obj7 = 0 ;
3029 char *kwnames[] = {
3030 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
3031 };
3032
3033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
3034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3035 if (SWIG_arg_fail(1)) SWIG_fail;
3036 {
3037 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3038 if (SWIG_arg_fail(2)) SWIG_fail;
3039 if (arg2 == NULL) {
3040 SWIG_null_ref("wxGrid");
3041 }
3042 if (SWIG_arg_fail(2)) SWIG_fail;
3043 }
3044 {
3045 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3046 if (SWIG_arg_fail(3)) SWIG_fail;
3047 if (arg3 == NULL) {
3048 SWIG_null_ref("wxGridCellAttr");
3049 }
3050 if (SWIG_arg_fail(3)) SWIG_fail;
3051 }
3052 {
3053 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
3054 if (SWIG_arg_fail(4)) SWIG_fail;
3055 if (arg4 == NULL) {
3056 SWIG_null_ref("wxDC");
3057 }
3058 if (SWIG_arg_fail(4)) SWIG_fail;
3059 }
3060 {
3061 arg5 = &temp5;
3062 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
3063 }
3064 {
3065 arg6 = static_cast<int >(SWIG_As_int(obj5));
3066 if (SWIG_arg_fail(6)) SWIG_fail;
3067 }
3068 {
3069 arg7 = static_cast<int >(SWIG_As_int(obj6));
3070 if (SWIG_arg_fail(7)) SWIG_fail;
3071 }
3072 {
3073 arg8 = static_cast<bool >(SWIG_As_bool(obj7));
3074 if (SWIG_arg_fail(8)) SWIG_fail;
3075 }
3076 {
3077 PyThreadState* __tstate = wxPyBeginAllowThreads();
3078 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
3079
3080 wxPyEndAllowThreads(__tstate);
3081 if (PyErr_Occurred()) SWIG_fail;
3082 }
3083 Py_INCREF(Py_None); resultobj = Py_None;
3084 return resultobj;
3085 fail:
3086 return NULL;
3087 }
3088
3089
3090 static PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
3091 PyObject *resultobj = NULL;
3092 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3093 wxGrid *arg2 = 0 ;
3094 wxGridCellAttr *arg3 = 0 ;
3095 wxDC *arg4 = 0 ;
3096 int arg5 ;
3097 int arg6 ;
3098 wxSize result;
3099 PyObject * obj0 = 0 ;
3100 PyObject * obj1 = 0 ;
3101 PyObject * obj2 = 0 ;
3102 PyObject * obj3 = 0 ;
3103 PyObject * obj4 = 0 ;
3104 PyObject * obj5 = 0 ;
3105 char *kwnames[] = {
3106 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
3107 };
3108
3109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3111 if (SWIG_arg_fail(1)) SWIG_fail;
3112 {
3113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
3114 if (SWIG_arg_fail(2)) SWIG_fail;
3115 if (arg2 == NULL) {
3116 SWIG_null_ref("wxGrid");
3117 }
3118 if (SWIG_arg_fail(2)) SWIG_fail;
3119 }
3120 {
3121 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3122 if (SWIG_arg_fail(3)) SWIG_fail;
3123 if (arg3 == NULL) {
3124 SWIG_null_ref("wxGridCellAttr");
3125 }
3126 if (SWIG_arg_fail(3)) SWIG_fail;
3127 }
3128 {
3129 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
3130 if (SWIG_arg_fail(4)) SWIG_fail;
3131 if (arg4 == NULL) {
3132 SWIG_null_ref("wxDC");
3133 }
3134 if (SWIG_arg_fail(4)) SWIG_fail;
3135 }
3136 {
3137 arg5 = static_cast<int >(SWIG_As_int(obj4));
3138 if (SWIG_arg_fail(5)) SWIG_fail;
3139 }
3140 {
3141 arg6 = static_cast<int >(SWIG_As_int(obj5));
3142 if (SWIG_arg_fail(6)) SWIG_fail;
3143 }
3144 {
3145 PyThreadState* __tstate = wxPyBeginAllowThreads();
3146 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
3147
3148 wxPyEndAllowThreads(__tstate);
3149 if (PyErr_Occurred()) SWIG_fail;
3150 }
3151 {
3152 wxSize * resultptr;
3153 resultptr = new wxSize(static_cast<wxSize & >(result));
3154 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3155 }
3156 return resultobj;
3157 fail:
3158 return NULL;
3159 }
3160
3161
3162 static PyObject *_wrap_GridCellRenderer_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
3163 PyObject *resultobj = NULL;
3164 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3165 wxGridCellRenderer *result;
3166 PyObject * obj0 = 0 ;
3167 char *kwnames[] = {
3168 (char *) "self", NULL
3169 };
3170
3171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellRenderer_Clone",kwnames,&obj0)) goto fail;
3172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3173 if (SWIG_arg_fail(1)) SWIG_fail;
3174 {
3175 PyThreadState* __tstate = wxPyBeginAllowThreads();
3176 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
3177
3178 wxPyEndAllowThreads(__tstate);
3179 if (PyErr_Occurred()) SWIG_fail;
3180 }
3181 {
3182 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
3183 }
3184 return resultobj;
3185 fail:
3186 return NULL;
3187 }
3188
3189
3190 static PyObject * GridCellRenderer_swigregister(PyObject *, PyObject *args) {
3191 PyObject *obj;
3192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3193 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellRenderer, obj);
3194 Py_INCREF(obj);
3195 return Py_BuildValue((char *)"");
3196 }
3197 static PyObject *_wrap_new_PyGridCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3198 PyObject *resultobj = NULL;
3199 wxPyGridCellRenderer *result;
3200 char *kwnames[] = {
3201 NULL
3202 };
3203
3204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellRenderer",kwnames)) goto fail;
3205 {
3206 PyThreadState* __tstate = wxPyBeginAllowThreads();
3207 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3208
3209 wxPyEndAllowThreads(__tstate);
3210 if (PyErr_Occurred()) SWIG_fail;
3211 }
3212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellRenderer, 1);
3213 return resultobj;
3214 fail:
3215 return NULL;
3216 }
3217
3218
3219 static PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
3220 PyObject *resultobj = NULL;
3221 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3222 PyObject *arg2 = (PyObject *) 0 ;
3223 PyObject *arg3 = (PyObject *) 0 ;
3224 PyObject * obj0 = 0 ;
3225 PyObject * obj1 = 0 ;
3226 PyObject * obj2 = 0 ;
3227 char *kwnames[] = {
3228 (char *) "self",(char *) "self",(char *) "_class", NULL
3229 };
3230
3231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
3232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3233 if (SWIG_arg_fail(1)) SWIG_fail;
3234 arg2 = obj1;
3235 arg3 = obj2;
3236 {
3237 PyThreadState* __tstate = wxPyBeginAllowThreads();
3238 (arg1)->_setCallbackInfo(arg2,arg3);
3239
3240 wxPyEndAllowThreads(__tstate);
3241 if (PyErr_Occurred()) SWIG_fail;
3242 }
3243 Py_INCREF(Py_None); resultobj = Py_None;
3244 return resultobj;
3245 fail:
3246 return NULL;
3247 }
3248
3249
3250 static PyObject *_wrap_PyGridCellRenderer_base_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3251 PyObject *resultobj = NULL;
3252 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3253 wxString *arg2 = 0 ;
3254 bool temp2 = false ;
3255 PyObject * obj0 = 0 ;
3256 PyObject * obj1 = 0 ;
3257 char *kwnames[] = {
3258 (char *) "self",(char *) "params", NULL
3259 };
3260
3261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_base_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
3263 if (SWIG_arg_fail(1)) SWIG_fail;
3264 {
3265 arg2 = wxString_in_helper(obj1);
3266 if (arg2 == NULL) SWIG_fail;
3267 temp2 = true;
3268 }
3269 {
3270 PyThreadState* __tstate = wxPyBeginAllowThreads();
3271 (arg1)->base_SetParameters((wxString const &)*arg2);
3272
3273 wxPyEndAllowThreads(__tstate);
3274 if (PyErr_Occurred()) SWIG_fail;
3275 }
3276 Py_INCREF(Py_None); resultobj = Py_None;
3277 {
3278 if (temp2)
3279 delete arg2;
3280 }
3281 return resultobj;
3282 fail:
3283 {
3284 if (temp2)
3285 delete arg2;
3286 }
3287 return NULL;
3288 }
3289
3290
3291 static PyObject * PyGridCellRenderer_swigregister(PyObject *, PyObject *args) {
3292 PyObject *obj;
3293 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3294 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellRenderer, obj);
3295 Py_INCREF(obj);
3296 return Py_BuildValue((char *)"");
3297 }
3298 static PyObject *_wrap_new_GridCellStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3299 PyObject *resultobj = NULL;
3300 wxGridCellStringRenderer *result;
3301 char *kwnames[] = {
3302 NULL
3303 };
3304
3305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellStringRenderer",kwnames)) goto fail;
3306 {
3307 PyThreadState* __tstate = wxPyBeginAllowThreads();
3308 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
3309
3310 wxPyEndAllowThreads(__tstate);
3311 if (PyErr_Occurred()) SWIG_fail;
3312 }
3313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellStringRenderer, 1);
3314 return resultobj;
3315 fail:
3316 return NULL;
3317 }
3318
3319
3320 static PyObject * GridCellStringRenderer_swigregister(PyObject *, PyObject *args) {
3321 PyObject *obj;
3322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3323 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellStringRenderer, obj);
3324 Py_INCREF(obj);
3325 return Py_BuildValue((char *)"");
3326 }
3327 static PyObject *_wrap_new_GridCellNumberRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3328 PyObject *resultobj = NULL;
3329 wxGridCellNumberRenderer *result;
3330 char *kwnames[] = {
3331 NULL
3332 };
3333
3334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellNumberRenderer",kwnames)) goto fail;
3335 {
3336 PyThreadState* __tstate = wxPyBeginAllowThreads();
3337 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
3338
3339 wxPyEndAllowThreads(__tstate);
3340 if (PyErr_Occurred()) SWIG_fail;
3341 }
3342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberRenderer, 1);
3343 return resultobj;
3344 fail:
3345 return NULL;
3346 }
3347
3348
3349 static PyObject * GridCellNumberRenderer_swigregister(PyObject *, PyObject *args) {
3350 PyObject *obj;
3351 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3352 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberRenderer, obj);
3353 Py_INCREF(obj);
3354 return Py_BuildValue((char *)"");
3355 }
3356 static PyObject *_wrap_new_GridCellFloatRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3357 PyObject *resultobj = NULL;
3358 int arg1 = (int) -1 ;
3359 int arg2 = (int) -1 ;
3360 wxGridCellFloatRenderer *result;
3361 PyObject * obj0 = 0 ;
3362 PyObject * obj1 = 0 ;
3363 char *kwnames[] = {
3364 (char *) "width",(char *) "precision", NULL
3365 };
3366
3367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) goto fail;
3368 if (obj0) {
3369 {
3370 arg1 = static_cast<int >(SWIG_As_int(obj0));
3371 if (SWIG_arg_fail(1)) SWIG_fail;
3372 }
3373 }
3374 if (obj1) {
3375 {
3376 arg2 = static_cast<int >(SWIG_As_int(obj1));
3377 if (SWIG_arg_fail(2)) SWIG_fail;
3378 }
3379 }
3380 {
3381 PyThreadState* __tstate = wxPyBeginAllowThreads();
3382 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
3383
3384 wxPyEndAllowThreads(__tstate);
3385 if (PyErr_Occurred()) SWIG_fail;
3386 }
3387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatRenderer, 1);
3388 return resultobj;
3389 fail:
3390 return NULL;
3391 }
3392
3393
3394 static PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3395 PyObject *resultobj = NULL;
3396 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3397 int result;
3398 PyObject * obj0 = 0 ;
3399 char *kwnames[] = {
3400 (char *) "self", NULL
3401 };
3402
3403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetWidth",kwnames,&obj0)) goto fail;
3404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3405 if (SWIG_arg_fail(1)) SWIG_fail;
3406 {
3407 PyThreadState* __tstate = wxPyBeginAllowThreads();
3408 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
3409
3410 wxPyEndAllowThreads(__tstate);
3411 if (PyErr_Occurred()) SWIG_fail;
3412 }
3413 {
3414 resultobj = SWIG_From_int(static_cast<int >(result));
3415 }
3416 return resultobj;
3417 fail:
3418 return NULL;
3419 }
3420
3421
3422 static PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3423 PyObject *resultobj = NULL;
3424 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3425 int arg2 ;
3426 PyObject * obj0 = 0 ;
3427 PyObject * obj1 = 0 ;
3428 char *kwnames[] = {
3429 (char *) "self",(char *) "width", NULL
3430 };
3431
3432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3434 if (SWIG_arg_fail(1)) SWIG_fail;
3435 {
3436 arg2 = static_cast<int >(SWIG_As_int(obj1));
3437 if (SWIG_arg_fail(2)) SWIG_fail;
3438 }
3439 {
3440 PyThreadState* __tstate = wxPyBeginAllowThreads();
3441 (arg1)->SetWidth(arg2);
3442
3443 wxPyEndAllowThreads(__tstate);
3444 if (PyErr_Occurred()) SWIG_fail;
3445 }
3446 Py_INCREF(Py_None); resultobj = Py_None;
3447 return resultobj;
3448 fail:
3449 return NULL;
3450 }
3451
3452
3453 static PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3454 PyObject *resultobj = NULL;
3455 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3456 int result;
3457 PyObject * obj0 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "self", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatRenderer_GetPrecision",kwnames,&obj0)) goto fail;
3463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3464 if (SWIG_arg_fail(1)) SWIG_fail;
3465 {
3466 PyThreadState* __tstate = wxPyBeginAllowThreads();
3467 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
3468
3469 wxPyEndAllowThreads(__tstate);
3470 if (PyErr_Occurred()) SWIG_fail;
3471 }
3472 {
3473 resultobj = SWIG_From_int(static_cast<int >(result));
3474 }
3475 return resultobj;
3476 fail:
3477 return NULL;
3478 }
3479
3480
3481 static PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *, PyObject *args, PyObject *kwargs) {
3482 PyObject *resultobj = NULL;
3483 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
3484 int arg2 ;
3485 PyObject * obj0 = 0 ;
3486 PyObject * obj1 = 0 ;
3487 char *kwnames[] = {
3488 (char *) "self",(char *) "precision", NULL
3489 };
3490
3491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) goto fail;
3492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_EXCEPTION | 0);
3493 if (SWIG_arg_fail(1)) SWIG_fail;
3494 {
3495 arg2 = static_cast<int >(SWIG_As_int(obj1));
3496 if (SWIG_arg_fail(2)) SWIG_fail;
3497 }
3498 {
3499 PyThreadState* __tstate = wxPyBeginAllowThreads();
3500 (arg1)->SetPrecision(arg2);
3501
3502 wxPyEndAllowThreads(__tstate);
3503 if (PyErr_Occurred()) SWIG_fail;
3504 }
3505 Py_INCREF(Py_None); resultobj = Py_None;
3506 return resultobj;
3507 fail:
3508 return NULL;
3509 }
3510
3511
3512 static PyObject * GridCellFloatRenderer_swigregister(PyObject *, PyObject *args) {
3513 PyObject *obj;
3514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3515 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatRenderer, obj);
3516 Py_INCREF(obj);
3517 return Py_BuildValue((char *)"");
3518 }
3519 static PyObject *_wrap_new_GridCellBoolRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3520 PyObject *resultobj = NULL;
3521 wxGridCellBoolRenderer *result;
3522 char *kwnames[] = {
3523 NULL
3524 };
3525
3526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolRenderer",kwnames)) goto fail;
3527 {
3528 PyThreadState* __tstate = wxPyBeginAllowThreads();
3529 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
3530
3531 wxPyEndAllowThreads(__tstate);
3532 if (PyErr_Occurred()) SWIG_fail;
3533 }
3534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolRenderer, 1);
3535 return resultobj;
3536 fail:
3537 return NULL;
3538 }
3539
3540
3541 static PyObject * GridCellBoolRenderer_swigregister(PyObject *, PyObject *args) {
3542 PyObject *obj;
3543 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3544 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolRenderer, obj);
3545 Py_INCREF(obj);
3546 return Py_BuildValue((char *)"");
3547 }
3548 static PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3549 PyObject *resultobj = NULL;
3550 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
3551 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
3552 wxGridCellDateTimeRenderer *result;
3553 PyObject * obj0 = 0 ;
3554 PyObject * obj1 = 0 ;
3555 char *kwnames[] = {
3556 (char *) "outformat",(char *) "informat", NULL
3557 };
3558
3559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) goto fail;
3560 if (obj0) {
3561 {
3562 wxString* sptr = wxString_in_helper(obj0);
3563 if (sptr == NULL) SWIG_fail;
3564 arg1 = *sptr;
3565 delete sptr;
3566 }
3567 }
3568 if (obj1) {
3569 {
3570 wxString* sptr = wxString_in_helper(obj1);
3571 if (sptr == NULL) SWIG_fail;
3572 arg2 = *sptr;
3573 delete sptr;
3574 }
3575 }
3576 {
3577 PyThreadState* __tstate = wxPyBeginAllowThreads();
3578 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
3579
3580 wxPyEndAllowThreads(__tstate);
3581 if (PyErr_Occurred()) SWIG_fail;
3582 }
3583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, 1);
3584 return resultobj;
3585 fail:
3586 return NULL;
3587 }
3588
3589
3590 static PyObject * GridCellDateTimeRenderer_swigregister(PyObject *, PyObject *args) {
3591 PyObject *obj;
3592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3593 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, obj);
3594 Py_INCREF(obj);
3595 return Py_BuildValue((char *)"");
3596 }
3597 static PyObject *_wrap_new_GridCellEnumRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3598 PyObject *resultobj = NULL;
3599 wxString const &arg1_defvalue = wxPyEmptyString ;
3600 wxString *arg1 = (wxString *) &arg1_defvalue ;
3601 wxGridCellEnumRenderer *result;
3602 bool temp1 = false ;
3603 PyObject * obj0 = 0 ;
3604 char *kwnames[] = {
3605 (char *) "choices", NULL
3606 };
3607
3608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) goto fail;
3609 if (obj0) {
3610 {
3611 arg1 = wxString_in_helper(obj0);
3612 if (arg1 == NULL) SWIG_fail;
3613 temp1 = true;
3614 }
3615 }
3616 {
3617 PyThreadState* __tstate = wxPyBeginAllowThreads();
3618 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
3619
3620 wxPyEndAllowThreads(__tstate);
3621 if (PyErr_Occurred()) SWIG_fail;
3622 }
3623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumRenderer, 1);
3624 {
3625 if (temp1)
3626 delete arg1;
3627 }
3628 return resultobj;
3629 fail:
3630 {
3631 if (temp1)
3632 delete arg1;
3633 }
3634 return NULL;
3635 }
3636
3637
3638 static PyObject * GridCellEnumRenderer_swigregister(PyObject *, PyObject *args) {
3639 PyObject *obj;
3640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3641 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumRenderer, obj);
3642 Py_INCREF(obj);
3643 return Py_BuildValue((char *)"");
3644 }
3645 static PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
3646 PyObject *resultobj = NULL;
3647 wxGridCellAutoWrapStringRenderer *result;
3648 char *kwnames[] = {
3649 NULL
3650 };
3651
3652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringRenderer",kwnames)) goto fail;
3653 {
3654 PyThreadState* __tstate = wxPyBeginAllowThreads();
3655 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
3656
3657 wxPyEndAllowThreads(__tstate);
3658 if (PyErr_Occurred()) SWIG_fail;
3659 }
3660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, 1);
3661 return resultobj;
3662 fail:
3663 return NULL;
3664 }
3665
3666
3667 static PyObject * GridCellAutoWrapStringRenderer_swigregister(PyObject *, PyObject *args) {
3668 PyObject *obj;
3669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3670 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, obj);
3671 Py_INCREF(obj);
3672 return Py_BuildValue((char *)"");
3673 }
3674 static PyObject *_wrap_GridCellEditor__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
3675 PyObject *resultobj = NULL;
3676 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3677 PyObject *arg2 = (PyObject *) 0 ;
3678 PyObject * obj0 = 0 ;
3679 PyObject * obj1 = 0 ;
3680 char *kwnames[] = {
3681 (char *) "self",(char *) "_self", NULL
3682 };
3683
3684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
3685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3686 if (SWIG_arg_fail(1)) SWIG_fail;
3687 arg2 = obj1;
3688 {
3689 PyThreadState* __tstate = wxPyBeginAllowThreads();
3690 wxGridCellEditor__setOORInfo(arg1,arg2);
3691
3692 wxPyEndAllowThreads(__tstate);
3693 if (PyErr_Occurred()) SWIG_fail;
3694 }
3695 Py_INCREF(Py_None); resultobj = Py_None;
3696 return resultobj;
3697 fail:
3698 return NULL;
3699 }
3700
3701
3702 static PyObject *_wrap_GridCellEditor_IsCreated(PyObject *, PyObject *args, PyObject *kwargs) {
3703 PyObject *resultobj = NULL;
3704 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3705 bool result;
3706 PyObject * obj0 = 0 ;
3707 char *kwnames[] = {
3708 (char *) "self", NULL
3709 };
3710
3711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IsCreated",kwnames,&obj0)) goto fail;
3712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3713 if (SWIG_arg_fail(1)) SWIG_fail;
3714 {
3715 PyThreadState* __tstate = wxPyBeginAllowThreads();
3716 result = (bool)(arg1)->IsCreated();
3717
3718 wxPyEndAllowThreads(__tstate);
3719 if (PyErr_Occurred()) SWIG_fail;
3720 }
3721 {
3722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3723 }
3724 return resultobj;
3725 fail:
3726 return NULL;
3727 }
3728
3729
3730 static PyObject *_wrap_GridCellEditor_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3731 PyObject *resultobj = NULL;
3732 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3733 wxControl *result;
3734 PyObject * obj0 = 0 ;
3735 char *kwnames[] = {
3736 (char *) "self", NULL
3737 };
3738
3739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetControl",kwnames,&obj0)) goto fail;
3740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3741 if (SWIG_arg_fail(1)) SWIG_fail;
3742 {
3743 PyThreadState* __tstate = wxPyBeginAllowThreads();
3744 result = (wxControl *)(arg1)->GetControl();
3745
3746 wxPyEndAllowThreads(__tstate);
3747 if (PyErr_Occurred()) SWIG_fail;
3748 }
3749 {
3750 resultobj = wxPyMake_wxObject(result, 0);
3751 }
3752 return resultobj;
3753 fail:
3754 return NULL;
3755 }
3756
3757
3758 static PyObject *_wrap_GridCellEditor_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
3759 PyObject *resultobj = NULL;
3760 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3761 wxControl *arg2 = (wxControl *) 0 ;
3762 PyObject * obj0 = 0 ;
3763 PyObject * obj1 = 0 ;
3764 char *kwnames[] = {
3765 (char *) "self",(char *) "control", NULL
3766 };
3767
3768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) goto fail;
3769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3770 if (SWIG_arg_fail(1)) SWIG_fail;
3771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
3772 if (SWIG_arg_fail(2)) SWIG_fail;
3773 {
3774 PyThreadState* __tstate = wxPyBeginAllowThreads();
3775 (arg1)->SetControl(arg2);
3776
3777 wxPyEndAllowThreads(__tstate);
3778 if (PyErr_Occurred()) SWIG_fail;
3779 }
3780 Py_INCREF(Py_None); resultobj = Py_None;
3781 return resultobj;
3782 fail:
3783 return NULL;
3784 }
3785
3786
3787 static PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3788 PyObject *resultobj = NULL;
3789 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3790 wxGridCellAttr *result;
3791 PyObject * obj0 = 0 ;
3792 char *kwnames[] = {
3793 (char *) "self", NULL
3794 };
3795
3796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_GetCellAttr",kwnames,&obj0)) goto fail;
3797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3798 if (SWIG_arg_fail(1)) SWIG_fail;
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 {
3807 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
3808 }
3809 return resultobj;
3810 fail:
3811 return NULL;
3812 }
3813
3814
3815 static PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj = NULL;
3817 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3818 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
3819 PyObject * obj0 = 0 ;
3820 PyObject * obj1 = 0 ;
3821 char *kwnames[] = {
3822 (char *) "self",(char *) "attr", NULL
3823 };
3824
3825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) goto fail;
3826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3827 if (SWIG_arg_fail(1)) SWIG_fail;
3828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
3829 if (SWIG_arg_fail(2)) SWIG_fail;
3830 {
3831 PyThreadState* __tstate = wxPyBeginAllowThreads();
3832 (arg1)->SetCellAttr(arg2);
3833
3834 wxPyEndAllowThreads(__tstate);
3835 if (PyErr_Occurred()) SWIG_fail;
3836 }
3837 Py_INCREF(Py_None); resultobj = Py_None;
3838 return resultobj;
3839 fail:
3840 return NULL;
3841 }
3842
3843
3844 static PyObject *_wrap_GridCellEditor_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
3845 PyObject *resultobj = NULL;
3846 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3847 wxString *arg2 = 0 ;
3848 bool temp2 = false ;
3849 PyObject * obj0 = 0 ;
3850 PyObject * obj1 = 0 ;
3851 char *kwnames[] = {
3852 (char *) "self",(char *) "params", NULL
3853 };
3854
3855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetParameters",kwnames,&obj0,&obj1)) goto fail;
3856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3857 if (SWIG_arg_fail(1)) SWIG_fail;
3858 {
3859 arg2 = wxString_in_helper(obj1);
3860 if (arg2 == NULL) SWIG_fail;
3861 temp2 = true;
3862 }
3863 {
3864 PyThreadState* __tstate = wxPyBeginAllowThreads();
3865 (arg1)->SetParameters((wxString const &)*arg2);
3866
3867 wxPyEndAllowThreads(__tstate);
3868 if (PyErr_Occurred()) SWIG_fail;
3869 }
3870 Py_INCREF(Py_None); resultobj = Py_None;
3871 {
3872 if (temp2)
3873 delete arg2;
3874 }
3875 return resultobj;
3876 fail:
3877 {
3878 if (temp2)
3879 delete arg2;
3880 }
3881 return NULL;
3882 }
3883
3884
3885 static PyObject *_wrap_GridCellEditor_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
3886 PyObject *resultobj = NULL;
3887 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3888 PyObject * obj0 = 0 ;
3889 char *kwnames[] = {
3890 (char *) "self", NULL
3891 };
3892
3893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_IncRef",kwnames,&obj0)) goto fail;
3894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3895 if (SWIG_arg_fail(1)) SWIG_fail;
3896 {
3897 PyThreadState* __tstate = wxPyBeginAllowThreads();
3898 (arg1)->IncRef();
3899
3900 wxPyEndAllowThreads(__tstate);
3901 if (PyErr_Occurred()) SWIG_fail;
3902 }
3903 Py_INCREF(Py_None); resultobj = Py_None;
3904 return resultobj;
3905 fail:
3906 return NULL;
3907 }
3908
3909
3910 static PyObject *_wrap_GridCellEditor_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
3911 PyObject *resultobj = NULL;
3912 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3913 PyObject * obj0 = 0 ;
3914 char *kwnames[] = {
3915 (char *) "self", NULL
3916 };
3917
3918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_DecRef",kwnames,&obj0)) goto fail;
3919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3920 if (SWIG_arg_fail(1)) SWIG_fail;
3921 {
3922 PyThreadState* __tstate = wxPyBeginAllowThreads();
3923 (arg1)->DecRef();
3924
3925 wxPyEndAllowThreads(__tstate);
3926 if (PyErr_Occurred()) SWIG_fail;
3927 }
3928 Py_INCREF(Py_None); resultobj = Py_None;
3929 return resultobj;
3930 fail:
3931 return NULL;
3932 }
3933
3934
3935 static PyObject *_wrap_GridCellEditor_Create(PyObject *, PyObject *args, PyObject *kwargs) {
3936 PyObject *resultobj = NULL;
3937 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3938 wxWindow *arg2 = (wxWindow *) 0 ;
3939 int arg3 ;
3940 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
3941 PyObject * obj0 = 0 ;
3942 PyObject * obj1 = 0 ;
3943 PyObject * obj2 = 0 ;
3944 PyObject * obj3 = 0 ;
3945 char *kwnames[] = {
3946 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
3947 };
3948
3949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3951 if (SWIG_arg_fail(1)) SWIG_fail;
3952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3953 if (SWIG_arg_fail(2)) SWIG_fail;
3954 {
3955 arg3 = static_cast<int >(SWIG_As_int(obj2));
3956 if (SWIG_arg_fail(3)) SWIG_fail;
3957 }
3958 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
3959 if (SWIG_arg_fail(4)) SWIG_fail;
3960 {
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 (arg1)->Create(arg2,arg3,arg4);
3963
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 Py_INCREF(Py_None); resultobj = Py_None;
3968 return resultobj;
3969 fail:
3970 return NULL;
3971 }
3972
3973
3974 static PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *, PyObject *args, PyObject *kwargs) {
3975 PyObject *resultobj = NULL;
3976 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
3977 int arg2 ;
3978 int arg3 ;
3979 wxGrid *arg4 = (wxGrid *) 0 ;
3980 PyObject * obj0 = 0 ;
3981 PyObject * obj1 = 0 ;
3982 PyObject * obj2 = 0 ;
3983 PyObject * obj3 = 0 ;
3984 char *kwnames[] = {
3985 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
3986 };
3987
3988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
3989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
3990 if (SWIG_arg_fail(1)) SWIG_fail;
3991 {
3992 arg2 = static_cast<int >(SWIG_As_int(obj1));
3993 if (SWIG_arg_fail(2)) SWIG_fail;
3994 }
3995 {
3996 arg3 = static_cast<int >(SWIG_As_int(obj2));
3997 if (SWIG_arg_fail(3)) SWIG_fail;
3998 }
3999 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
4000 if (SWIG_arg_fail(4)) SWIG_fail;
4001 {
4002 PyThreadState* __tstate = wxPyBeginAllowThreads();
4003 (arg1)->BeginEdit(arg2,arg3,arg4);
4004
4005 wxPyEndAllowThreads(__tstate);
4006 if (PyErr_Occurred()) SWIG_fail;
4007 }
4008 Py_INCREF(Py_None); resultobj = Py_None;
4009 return resultobj;
4010 fail:
4011 return NULL;
4012 }
4013
4014
4015 static PyObject *_wrap_GridCellEditor_EndEdit(PyObject *, PyObject *args, PyObject *kwargs) {
4016 PyObject *resultobj = NULL;
4017 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4018 int arg2 ;
4019 int arg3 ;
4020 wxGrid *arg4 = (wxGrid *) 0 ;
4021 bool result;
4022 PyObject * obj0 = 0 ;
4023 PyObject * obj1 = 0 ;
4024 PyObject * obj2 = 0 ;
4025 PyObject * obj3 = 0 ;
4026 char *kwnames[] = {
4027 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4028 };
4029
4030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4032 if (SWIG_arg_fail(1)) SWIG_fail;
4033 {
4034 arg2 = static_cast<int >(SWIG_As_int(obj1));
4035 if (SWIG_arg_fail(2)) SWIG_fail;
4036 }
4037 {
4038 arg3 = static_cast<int >(SWIG_As_int(obj2));
4039 if (SWIG_arg_fail(3)) SWIG_fail;
4040 }
4041 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
4042 if (SWIG_arg_fail(4)) SWIG_fail;
4043 {
4044 PyThreadState* __tstate = wxPyBeginAllowThreads();
4045 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
4046
4047 wxPyEndAllowThreads(__tstate);
4048 if (PyErr_Occurred()) SWIG_fail;
4049 }
4050 {
4051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4052 }
4053 return resultobj;
4054 fail:
4055 return NULL;
4056 }
4057
4058
4059 static PyObject *_wrap_GridCellEditor_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
4060 PyObject *resultobj = NULL;
4061 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4062 PyObject * obj0 = 0 ;
4063 char *kwnames[] = {
4064 (char *) "self", NULL
4065 };
4066
4067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Reset",kwnames,&obj0)) goto fail;
4068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4069 if (SWIG_arg_fail(1)) SWIG_fail;
4070 {
4071 PyThreadState* __tstate = wxPyBeginAllowThreads();
4072 (arg1)->Reset();
4073
4074 wxPyEndAllowThreads(__tstate);
4075 if (PyErr_Occurred()) SWIG_fail;
4076 }
4077 Py_INCREF(Py_None); resultobj = Py_None;
4078 return resultobj;
4079 fail:
4080 return NULL;
4081 }
4082
4083
4084 static PyObject *_wrap_GridCellEditor_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
4085 PyObject *resultobj = NULL;
4086 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4087 wxGridCellEditor *result;
4088 PyObject * obj0 = 0 ;
4089 char *kwnames[] = {
4090 (char *) "self", NULL
4091 };
4092
4093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Clone",kwnames,&obj0)) goto fail;
4094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4095 if (SWIG_arg_fail(1)) SWIG_fail;
4096 {
4097 PyThreadState* __tstate = wxPyBeginAllowThreads();
4098 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
4099
4100 wxPyEndAllowThreads(__tstate);
4101 if (PyErr_Occurred()) SWIG_fail;
4102 }
4103 {
4104 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
4105 }
4106 return resultobj;
4107 fail:
4108 return NULL;
4109 }
4110
4111
4112 static PyObject *_wrap_GridCellEditor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4113 PyObject *resultobj = NULL;
4114 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4115 wxRect *arg2 = 0 ;
4116 wxRect temp2 ;
4117 PyObject * obj0 = 0 ;
4118 PyObject * obj1 = 0 ;
4119 char *kwnames[] = {
4120 (char *) "self",(char *) "rect", NULL
4121 };
4122
4123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) goto fail;
4124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4125 if (SWIG_arg_fail(1)) SWIG_fail;
4126 {
4127 arg2 = &temp2;
4128 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4129 }
4130 {
4131 PyThreadState* __tstate = wxPyBeginAllowThreads();
4132 (arg1)->SetSize((wxRect const &)*arg2);
4133
4134 wxPyEndAllowThreads(__tstate);
4135 if (PyErr_Occurred()) SWIG_fail;
4136 }
4137 Py_INCREF(Py_None); resultobj = Py_None;
4138 return resultobj;
4139 fail:
4140 return NULL;
4141 }
4142
4143
4144 static PyObject *_wrap_GridCellEditor_Show(PyObject *, PyObject *args, PyObject *kwargs) {
4145 PyObject *resultobj = NULL;
4146 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4147 bool arg2 ;
4148 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4149 PyObject * obj0 = 0 ;
4150 PyObject * obj1 = 0 ;
4151 PyObject * obj2 = 0 ;
4152 char *kwnames[] = {
4153 (char *) "self",(char *) "show",(char *) "attr", NULL
4154 };
4155
4156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
4157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4158 if (SWIG_arg_fail(1)) SWIG_fail;
4159 {
4160 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
4161 if (SWIG_arg_fail(2)) SWIG_fail;
4162 }
4163 if (obj2) {
4164 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4165 if (SWIG_arg_fail(3)) SWIG_fail;
4166 }
4167 {
4168 PyThreadState* __tstate = wxPyBeginAllowThreads();
4169 (arg1)->Show(arg2,arg3);
4170
4171 wxPyEndAllowThreads(__tstate);
4172 if (PyErr_Occurred()) SWIG_fail;
4173 }
4174 Py_INCREF(Py_None); resultobj = Py_None;
4175 return resultobj;
4176 fail:
4177 return NULL;
4178 }
4179
4180
4181 static PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
4182 PyObject *resultobj = NULL;
4183 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4184 wxRect *arg2 = 0 ;
4185 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4186 wxRect temp2 ;
4187 PyObject * obj0 = 0 ;
4188 PyObject * obj1 = 0 ;
4189 PyObject * obj2 = 0 ;
4190 char *kwnames[] = {
4191 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4192 };
4193
4194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
4195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4196 if (SWIG_arg_fail(1)) SWIG_fail;
4197 {
4198 arg2 = &temp2;
4199 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4200 }
4201 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4202 if (SWIG_arg_fail(3)) SWIG_fail;
4203 {
4204 PyThreadState* __tstate = wxPyBeginAllowThreads();
4205 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
4206
4207 wxPyEndAllowThreads(__tstate);
4208 if (PyErr_Occurred()) SWIG_fail;
4209 }
4210 Py_INCREF(Py_None); resultobj = Py_None;
4211 return resultobj;
4212 fail:
4213 return NULL;
4214 }
4215
4216
4217 static PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
4218 PyObject *resultobj = NULL;
4219 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4220 wxKeyEvent *arg2 = 0 ;
4221 bool result;
4222 PyObject * obj0 = 0 ;
4223 PyObject * obj1 = 0 ;
4224 char *kwnames[] = {
4225 (char *) "self",(char *) "event", NULL
4226 };
4227
4228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4230 if (SWIG_arg_fail(1)) SWIG_fail;
4231 {
4232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4233 if (SWIG_arg_fail(2)) SWIG_fail;
4234 if (arg2 == NULL) {
4235 SWIG_null_ref("wxKeyEvent");
4236 }
4237 if (SWIG_arg_fail(2)) SWIG_fail;
4238 }
4239 {
4240 PyThreadState* __tstate = wxPyBeginAllowThreads();
4241 result = (bool)(arg1)->IsAcceptedKey(*arg2);
4242
4243 wxPyEndAllowThreads(__tstate);
4244 if (PyErr_Occurred()) SWIG_fail;
4245 }
4246 {
4247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4248 }
4249 return resultobj;
4250 fail:
4251 return NULL;
4252 }
4253
4254
4255 static PyObject *_wrap_GridCellEditor_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4256 PyObject *resultobj = NULL;
4257 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4258 wxKeyEvent *arg2 = 0 ;
4259 PyObject * obj0 = 0 ;
4260 PyObject * obj1 = 0 ;
4261 char *kwnames[] = {
4262 (char *) "self",(char *) "event", NULL
4263 };
4264
4265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4267 if (SWIG_arg_fail(1)) SWIG_fail;
4268 {
4269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4270 if (SWIG_arg_fail(2)) SWIG_fail;
4271 if (arg2 == NULL) {
4272 SWIG_null_ref("wxKeyEvent");
4273 }
4274 if (SWIG_arg_fail(2)) SWIG_fail;
4275 }
4276 {
4277 PyThreadState* __tstate = wxPyBeginAllowThreads();
4278 (arg1)->StartingKey(*arg2);
4279
4280 wxPyEndAllowThreads(__tstate);
4281 if (PyErr_Occurred()) SWIG_fail;
4282 }
4283 Py_INCREF(Py_None); resultobj = Py_None;
4284 return resultobj;
4285 fail:
4286 return NULL;
4287 }
4288
4289
4290 static PyObject *_wrap_GridCellEditor_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4291 PyObject *resultobj = NULL;
4292 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4293 PyObject * obj0 = 0 ;
4294 char *kwnames[] = {
4295 (char *) "self", NULL
4296 };
4297
4298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_StartingClick",kwnames,&obj0)) goto fail;
4299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4300 if (SWIG_arg_fail(1)) SWIG_fail;
4301 {
4302 PyThreadState* __tstate = wxPyBeginAllowThreads();
4303 (arg1)->StartingClick();
4304
4305 wxPyEndAllowThreads(__tstate);
4306 if (PyErr_Occurred()) SWIG_fail;
4307 }
4308 Py_INCREF(Py_None); resultobj = Py_None;
4309 return resultobj;
4310 fail:
4311 return NULL;
4312 }
4313
4314
4315 static PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4316 PyObject *resultobj = NULL;
4317 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4318 wxKeyEvent *arg2 = 0 ;
4319 PyObject * obj0 = 0 ;
4320 PyObject * obj1 = 0 ;
4321 char *kwnames[] = {
4322 (char *) "self",(char *) "event", NULL
4323 };
4324
4325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4327 if (SWIG_arg_fail(1)) SWIG_fail;
4328 {
4329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4330 if (SWIG_arg_fail(2)) SWIG_fail;
4331 if (arg2 == NULL) {
4332 SWIG_null_ref("wxKeyEvent");
4333 }
4334 if (SWIG_arg_fail(2)) SWIG_fail;
4335 }
4336 {
4337 PyThreadState* __tstate = wxPyBeginAllowThreads();
4338 (arg1)->HandleReturn(*arg2);
4339
4340 wxPyEndAllowThreads(__tstate);
4341 if (PyErr_Occurred()) SWIG_fail;
4342 }
4343 Py_INCREF(Py_None); resultobj = Py_None;
4344 return resultobj;
4345 fail:
4346 return NULL;
4347 }
4348
4349
4350 static PyObject *_wrap_GridCellEditor_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4351 PyObject *resultobj = NULL;
4352 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4353 PyObject * obj0 = 0 ;
4354 char *kwnames[] = {
4355 (char *) "self", NULL
4356 };
4357
4358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEditor_Destroy",kwnames,&obj0)) goto fail;
4359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4360 if (SWIG_arg_fail(1)) SWIG_fail;
4361 {
4362 PyThreadState* __tstate = wxPyBeginAllowThreads();
4363 (arg1)->Destroy();
4364
4365 wxPyEndAllowThreads(__tstate);
4366 if (PyErr_Occurred()) SWIG_fail;
4367 }
4368 Py_INCREF(Py_None); resultobj = Py_None;
4369 return resultobj;
4370 fail:
4371 return NULL;
4372 }
4373
4374
4375 static PyObject * GridCellEditor_swigregister(PyObject *, PyObject *args) {
4376 PyObject *obj;
4377 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4378 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEditor, obj);
4379 Py_INCREF(obj);
4380 return Py_BuildValue((char *)"");
4381 }
4382 static PyObject *_wrap_new_PyGridCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4383 PyObject *resultobj = NULL;
4384 wxPyGridCellEditor *result;
4385 char *kwnames[] = {
4386 NULL
4387 };
4388
4389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellEditor",kwnames)) goto fail;
4390 {
4391 PyThreadState* __tstate = wxPyBeginAllowThreads();
4392 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
4393
4394 wxPyEndAllowThreads(__tstate);
4395 if (PyErr_Occurred()) SWIG_fail;
4396 }
4397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellEditor, 1);
4398 return resultobj;
4399 fail:
4400 return NULL;
4401 }
4402
4403
4404 static PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
4405 PyObject *resultobj = NULL;
4406 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4407 PyObject *arg2 = (PyObject *) 0 ;
4408 PyObject *arg3 = (PyObject *) 0 ;
4409 PyObject * obj0 = 0 ;
4410 PyObject * obj1 = 0 ;
4411 PyObject * obj2 = 0 ;
4412 char *kwnames[] = {
4413 (char *) "self",(char *) "self",(char *) "_class", NULL
4414 };
4415
4416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
4417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4418 if (SWIG_arg_fail(1)) SWIG_fail;
4419 arg2 = obj1;
4420 arg3 = obj2;
4421 {
4422 PyThreadState* __tstate = wxPyBeginAllowThreads();
4423 (arg1)->_setCallbackInfo(arg2,arg3);
4424
4425 wxPyEndAllowThreads(__tstate);
4426 if (PyErr_Occurred()) SWIG_fail;
4427 }
4428 Py_INCREF(Py_None); resultobj = Py_None;
4429 return resultobj;
4430 fail:
4431 return NULL;
4432 }
4433
4434
4435 static PyObject *_wrap_PyGridCellEditor_base_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4436 PyObject *resultobj = NULL;
4437 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4438 wxRect *arg2 = 0 ;
4439 wxRect temp2 ;
4440 PyObject * obj0 = 0 ;
4441 PyObject * obj1 = 0 ;
4442 char *kwnames[] = {
4443 (char *) "self",(char *) "rect", NULL
4444 };
4445
4446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_SetSize",kwnames,&obj0,&obj1)) goto fail;
4447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4448 if (SWIG_arg_fail(1)) SWIG_fail;
4449 {
4450 arg2 = &temp2;
4451 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4452 }
4453 {
4454 PyThreadState* __tstate = wxPyBeginAllowThreads();
4455 (arg1)->base_SetSize((wxRect const &)*arg2);
4456
4457 wxPyEndAllowThreads(__tstate);
4458 if (PyErr_Occurred()) SWIG_fail;
4459 }
4460 Py_INCREF(Py_None); resultobj = Py_None;
4461 return resultobj;
4462 fail:
4463 return NULL;
4464 }
4465
4466
4467 static PyObject *_wrap_PyGridCellEditor_base_Show(PyObject *, PyObject *args, PyObject *kwargs) {
4468 PyObject *resultobj = NULL;
4469 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4470 bool arg2 ;
4471 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4472 PyObject * obj0 = 0 ;
4473 PyObject * obj1 = 0 ;
4474 PyObject * obj2 = 0 ;
4475 char *kwnames[] = {
4476 (char *) "self",(char *) "show",(char *) "attr", NULL
4477 };
4478
4479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyGridCellEditor_base_Show",kwnames,&obj0,&obj1,&obj2)) goto fail;
4480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4481 if (SWIG_arg_fail(1)) SWIG_fail;
4482 {
4483 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
4484 if (SWIG_arg_fail(2)) SWIG_fail;
4485 }
4486 if (obj2) {
4487 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4488 if (SWIG_arg_fail(3)) SWIG_fail;
4489 }
4490 {
4491 PyThreadState* __tstate = wxPyBeginAllowThreads();
4492 (arg1)->base_Show(arg2,arg3);
4493
4494 wxPyEndAllowThreads(__tstate);
4495 if (PyErr_Occurred()) SWIG_fail;
4496 }
4497 Py_INCREF(Py_None); resultobj = Py_None;
4498 return resultobj;
4499 fail:
4500 return NULL;
4501 }
4502
4503
4504 static PyObject *_wrap_PyGridCellEditor_base_PaintBackground(PyObject *, PyObject *args, PyObject *kwargs) {
4505 PyObject *resultobj = NULL;
4506 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4507 wxRect *arg2 = 0 ;
4508 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4509 wxRect temp2 ;
4510 PyObject * obj0 = 0 ;
4511 PyObject * obj1 = 0 ;
4512 PyObject * obj2 = 0 ;
4513 char *kwnames[] = {
4514 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4515 };
4516
4517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor_base_PaintBackground",kwnames,&obj0,&obj1,&obj2)) goto fail;
4518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4519 if (SWIG_arg_fail(1)) SWIG_fail;
4520 {
4521 arg2 = &temp2;
4522 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4523 }
4524 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
4525 if (SWIG_arg_fail(3)) SWIG_fail;
4526 {
4527 PyThreadState* __tstate = wxPyBeginAllowThreads();
4528 (arg1)->base_PaintBackground((wxRect const &)*arg2,arg3);
4529
4530 wxPyEndAllowThreads(__tstate);
4531 if (PyErr_Occurred()) SWIG_fail;
4532 }
4533 Py_INCREF(Py_None); resultobj = Py_None;
4534 return resultobj;
4535 fail:
4536 return NULL;
4537 }
4538
4539
4540 static PyObject *_wrap_PyGridCellEditor_base_IsAcceptedKey(PyObject *, PyObject *args, PyObject *kwargs) {
4541 PyObject *resultobj = NULL;
4542 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4543 wxKeyEvent *arg2 = 0 ;
4544 bool result;
4545 PyObject * obj0 = 0 ;
4546 PyObject * obj1 = 0 ;
4547 char *kwnames[] = {
4548 (char *) "self",(char *) "event", NULL
4549 };
4550
4551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_IsAcceptedKey",kwnames,&obj0,&obj1)) goto fail;
4552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4553 if (SWIG_arg_fail(1)) SWIG_fail;
4554 {
4555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4556 if (SWIG_arg_fail(2)) SWIG_fail;
4557 if (arg2 == NULL) {
4558 SWIG_null_ref("wxKeyEvent");
4559 }
4560 if (SWIG_arg_fail(2)) SWIG_fail;
4561 }
4562 {
4563 PyThreadState* __tstate = wxPyBeginAllowThreads();
4564 result = (bool)(arg1)->base_IsAcceptedKey(*arg2);
4565
4566 wxPyEndAllowThreads(__tstate);
4567 if (PyErr_Occurred()) SWIG_fail;
4568 }
4569 {
4570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4571 }
4572 return resultobj;
4573 fail:
4574 return NULL;
4575 }
4576
4577
4578 static PyObject *_wrap_PyGridCellEditor_base_StartingKey(PyObject *, PyObject *args, PyObject *kwargs) {
4579 PyObject *resultobj = NULL;
4580 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4581 wxKeyEvent *arg2 = 0 ;
4582 PyObject * obj0 = 0 ;
4583 PyObject * obj1 = 0 ;
4584 char *kwnames[] = {
4585 (char *) "self",(char *) "event", NULL
4586 };
4587
4588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_StartingKey",kwnames,&obj0,&obj1)) goto fail;
4589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4590 if (SWIG_arg_fail(1)) SWIG_fail;
4591 {
4592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4593 if (SWIG_arg_fail(2)) SWIG_fail;
4594 if (arg2 == NULL) {
4595 SWIG_null_ref("wxKeyEvent");
4596 }
4597 if (SWIG_arg_fail(2)) SWIG_fail;
4598 }
4599 {
4600 PyThreadState* __tstate = wxPyBeginAllowThreads();
4601 (arg1)->base_StartingKey(*arg2);
4602
4603 wxPyEndAllowThreads(__tstate);
4604 if (PyErr_Occurred()) SWIG_fail;
4605 }
4606 Py_INCREF(Py_None); resultobj = Py_None;
4607 return resultobj;
4608 fail:
4609 return NULL;
4610 }
4611
4612
4613 static PyObject *_wrap_PyGridCellEditor_base_StartingClick(PyObject *, PyObject *args, PyObject *kwargs) {
4614 PyObject *resultobj = NULL;
4615 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4616 PyObject * obj0 = 0 ;
4617 char *kwnames[] = {
4618 (char *) "self", NULL
4619 };
4620
4621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_base_StartingClick",kwnames,&obj0)) goto fail;
4622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4623 if (SWIG_arg_fail(1)) SWIG_fail;
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 (arg1)->base_StartingClick();
4627
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 Py_INCREF(Py_None); resultobj = Py_None;
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 static PyObject *_wrap_PyGridCellEditor_base_HandleReturn(PyObject *, PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj = NULL;
4640 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4641 wxKeyEvent *arg2 = 0 ;
4642 PyObject * obj0 = 0 ;
4643 PyObject * obj1 = 0 ;
4644 char *kwnames[] = {
4645 (char *) "self",(char *) "event", NULL
4646 };
4647
4648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_HandleReturn",kwnames,&obj0,&obj1)) goto fail;
4649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4650 if (SWIG_arg_fail(1)) SWIG_fail;
4651 {
4652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
4653 if (SWIG_arg_fail(2)) SWIG_fail;
4654 if (arg2 == NULL) {
4655 SWIG_null_ref("wxKeyEvent");
4656 }
4657 if (SWIG_arg_fail(2)) SWIG_fail;
4658 }
4659 {
4660 PyThreadState* __tstate = wxPyBeginAllowThreads();
4661 (arg1)->base_HandleReturn(*arg2);
4662
4663 wxPyEndAllowThreads(__tstate);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 Py_INCREF(Py_None); resultobj = Py_None;
4667 return resultobj;
4668 fail:
4669 return NULL;
4670 }
4671
4672
4673 static PyObject *_wrap_PyGridCellEditor_base_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
4674 PyObject *resultobj = NULL;
4675 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4676 PyObject * obj0 = 0 ;
4677 char *kwnames[] = {
4678 (char *) "self", NULL
4679 };
4680
4681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridCellEditor_base_Destroy",kwnames,&obj0)) goto fail;
4682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4683 if (SWIG_arg_fail(1)) SWIG_fail;
4684 {
4685 PyThreadState* __tstate = wxPyBeginAllowThreads();
4686 (arg1)->base_Destroy();
4687
4688 wxPyEndAllowThreads(__tstate);
4689 if (PyErr_Occurred()) SWIG_fail;
4690 }
4691 Py_INCREF(Py_None); resultobj = Py_None;
4692 return resultobj;
4693 fail:
4694 return NULL;
4695 }
4696
4697
4698 static PyObject *_wrap_PyGridCellEditor_base_SetParameters(PyObject *, PyObject *args, PyObject *kwargs) {
4699 PyObject *resultobj = NULL;
4700 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
4701 wxString *arg2 = 0 ;
4702 bool temp2 = false ;
4703 PyObject * obj0 = 0 ;
4704 PyObject * obj1 = 0 ;
4705 char *kwnames[] = {
4706 (char *) "self",(char *) "params", NULL
4707 };
4708
4709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_base_SetParameters",kwnames,&obj0,&obj1)) goto fail;
4710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
4711 if (SWIG_arg_fail(1)) SWIG_fail;
4712 {
4713 arg2 = wxString_in_helper(obj1);
4714 if (arg2 == NULL) SWIG_fail;
4715 temp2 = true;
4716 }
4717 {
4718 PyThreadState* __tstate = wxPyBeginAllowThreads();
4719 (arg1)->base_SetParameters((wxString const &)*arg2);
4720
4721 wxPyEndAllowThreads(__tstate);
4722 if (PyErr_Occurred()) SWIG_fail;
4723 }
4724 Py_INCREF(Py_None); resultobj = Py_None;
4725 {
4726 if (temp2)
4727 delete arg2;
4728 }
4729 return resultobj;
4730 fail:
4731 {
4732 if (temp2)
4733 delete arg2;
4734 }
4735 return NULL;
4736 }
4737
4738
4739 static PyObject * PyGridCellEditor_swigregister(PyObject *, PyObject *args) {
4740 PyObject *obj;
4741 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4742 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellEditor, obj);
4743 Py_INCREF(obj);
4744 return Py_BuildValue((char *)"");
4745 }
4746 static PyObject *_wrap_new_GridCellTextEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4747 PyObject *resultobj = NULL;
4748 wxGridCellTextEditor *result;
4749 char *kwnames[] = {
4750 NULL
4751 };
4752
4753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellTextEditor",kwnames)) goto fail;
4754 {
4755 PyThreadState* __tstate = wxPyBeginAllowThreads();
4756 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
4757
4758 wxPyEndAllowThreads(__tstate);
4759 if (PyErr_Occurred()) SWIG_fail;
4760 }
4761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellTextEditor, 1);
4762 return resultobj;
4763 fail:
4764 return NULL;
4765 }
4766
4767
4768 static PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4769 PyObject *resultobj = NULL;
4770 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
4771 wxString result;
4772 PyObject * obj0 = 0 ;
4773 char *kwnames[] = {
4774 (char *) "self", NULL
4775 };
4776
4777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellTextEditor_GetValue",kwnames,&obj0)) goto fail;
4778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_EXCEPTION | 0);
4779 if (SWIG_arg_fail(1)) SWIG_fail;
4780 {
4781 PyThreadState* __tstate = wxPyBeginAllowThreads();
4782 result = (arg1)->GetValue();
4783
4784 wxPyEndAllowThreads(__tstate);
4785 if (PyErr_Occurred()) SWIG_fail;
4786 }
4787 {
4788 #if wxUSE_UNICODE
4789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4790 #else
4791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4792 #endif
4793 }
4794 return resultobj;
4795 fail:
4796 return NULL;
4797 }
4798
4799
4800 static PyObject * GridCellTextEditor_swigregister(PyObject *, PyObject *args) {
4801 PyObject *obj;
4802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4803 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellTextEditor, obj);
4804 Py_INCREF(obj);
4805 return Py_BuildValue((char *)"");
4806 }
4807 static PyObject *_wrap_new_GridCellNumberEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4808 PyObject *resultobj = NULL;
4809 int arg1 = (int) -1 ;
4810 int arg2 = (int) -1 ;
4811 wxGridCellNumberEditor *result;
4812 PyObject * obj0 = 0 ;
4813 PyObject * obj1 = 0 ;
4814 char *kwnames[] = {
4815 (char *) "min",(char *) "max", NULL
4816 };
4817
4818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) goto fail;
4819 if (obj0) {
4820 {
4821 arg1 = static_cast<int >(SWIG_As_int(obj0));
4822 if (SWIG_arg_fail(1)) SWIG_fail;
4823 }
4824 }
4825 if (obj1) {
4826 {
4827 arg2 = static_cast<int >(SWIG_As_int(obj1));
4828 if (SWIG_arg_fail(2)) SWIG_fail;
4829 }
4830 }
4831 {
4832 PyThreadState* __tstate = wxPyBeginAllowThreads();
4833 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
4834
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellNumberEditor, 1);
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 static PyObject *_wrap_GridCellNumberEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4846 PyObject *resultobj = NULL;
4847 wxGridCellNumberEditor *arg1 = (wxGridCellNumberEditor *) 0 ;
4848 wxString result;
4849 PyObject * obj0 = 0 ;
4850 char *kwnames[] = {
4851 (char *) "self", NULL
4852 };
4853
4854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellNumberEditor_GetValue",kwnames,&obj0)) goto fail;
4855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_EXCEPTION | 0);
4856 if (SWIG_arg_fail(1)) SWIG_fail;
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 result = (arg1)->GetValue();
4860
4861 wxPyEndAllowThreads(__tstate);
4862 if (PyErr_Occurred()) SWIG_fail;
4863 }
4864 {
4865 #if wxUSE_UNICODE
4866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4867 #else
4868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4869 #endif
4870 }
4871 return resultobj;
4872 fail:
4873 return NULL;
4874 }
4875
4876
4877 static PyObject * GridCellNumberEditor_swigregister(PyObject *, PyObject *args) {
4878 PyObject *obj;
4879 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4880 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellNumberEditor, obj);
4881 Py_INCREF(obj);
4882 return Py_BuildValue((char *)"");
4883 }
4884 static PyObject *_wrap_new_GridCellFloatEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4885 PyObject *resultobj = NULL;
4886 int arg1 = (int) -1 ;
4887 int arg2 = (int) -1 ;
4888 wxGridCellFloatEditor *result;
4889 PyObject * obj0 = 0 ;
4890 PyObject * obj1 = 0 ;
4891 char *kwnames[] = {
4892 (char *) "width",(char *) "precision", NULL
4893 };
4894
4895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) goto fail;
4896 if (obj0) {
4897 {
4898 arg1 = static_cast<int >(SWIG_As_int(obj0));
4899 if (SWIG_arg_fail(1)) SWIG_fail;
4900 }
4901 }
4902 if (obj1) {
4903 {
4904 arg2 = static_cast<int >(SWIG_As_int(obj1));
4905 if (SWIG_arg_fail(2)) SWIG_fail;
4906 }
4907 }
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
4911
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellFloatEditor, 1);
4916 return resultobj;
4917 fail:
4918 return NULL;
4919 }
4920
4921
4922 static PyObject *_wrap_GridCellFloatEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj = NULL;
4924 wxGridCellFloatEditor *arg1 = (wxGridCellFloatEditor *) 0 ;
4925 wxString result;
4926 PyObject * obj0 = 0 ;
4927 char *kwnames[] = {
4928 (char *) "self", NULL
4929 };
4930
4931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellFloatEditor_GetValue",kwnames,&obj0)) goto fail;
4932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_EXCEPTION | 0);
4933 if (SWIG_arg_fail(1)) SWIG_fail;
4934 {
4935 PyThreadState* __tstate = wxPyBeginAllowThreads();
4936 result = (arg1)->GetValue();
4937
4938 wxPyEndAllowThreads(__tstate);
4939 if (PyErr_Occurred()) SWIG_fail;
4940 }
4941 {
4942 #if wxUSE_UNICODE
4943 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4944 #else
4945 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4946 #endif
4947 }
4948 return resultobj;
4949 fail:
4950 return NULL;
4951 }
4952
4953
4954 static PyObject * GridCellFloatEditor_swigregister(PyObject *, PyObject *args) {
4955 PyObject *obj;
4956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4957 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellFloatEditor, obj);
4958 Py_INCREF(obj);
4959 return Py_BuildValue((char *)"");
4960 }
4961 static PyObject *_wrap_new_GridCellBoolEditor(PyObject *, PyObject *args, PyObject *kwargs) {
4962 PyObject *resultobj = NULL;
4963 wxGridCellBoolEditor *result;
4964 char *kwnames[] = {
4965 NULL
4966 };
4967
4968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellBoolEditor",kwnames)) goto fail;
4969 {
4970 PyThreadState* __tstate = wxPyBeginAllowThreads();
4971 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
4972
4973 wxPyEndAllowThreads(__tstate);
4974 if (PyErr_Occurred()) SWIG_fail;
4975 }
4976 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellBoolEditor, 1);
4977 return resultobj;
4978 fail:
4979 return NULL;
4980 }
4981
4982
4983 static PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
4984 PyObject *resultobj = NULL;
4985 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
4986 wxString result;
4987 PyObject * obj0 = 0 ;
4988 char *kwnames[] = {
4989 (char *) "self", NULL
4990 };
4991
4992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_GetValue",kwnames,&obj0)) goto fail;
4993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_EXCEPTION | 0);
4994 if (SWIG_arg_fail(1)) SWIG_fail;
4995 {
4996 PyThreadState* __tstate = wxPyBeginAllowThreads();
4997 result = (arg1)->GetValue();
4998
4999 wxPyEndAllowThreads(__tstate);
5000 if (PyErr_Occurred()) SWIG_fail;
5001 }
5002 {
5003 #if wxUSE_UNICODE
5004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5005 #else
5006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5007 #endif
5008 }
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 static PyObject * GridCellBoolEditor_swigregister(PyObject *, PyObject *args) {
5016 PyObject *obj;
5017 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5018 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellBoolEditor, obj);
5019 Py_INCREF(obj);
5020 return Py_BuildValue((char *)"");
5021 }
5022 static PyObject *_wrap_new_GridCellChoiceEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5023 PyObject *resultobj = NULL;
5024 int arg1 = (int) 0 ;
5025 wxString *arg2 = (wxString *) NULL ;
5026 bool arg3 = (bool) false ;
5027 wxGridCellChoiceEditor *result;
5028 PyObject * obj0 = 0 ;
5029 PyObject * obj1 = 0 ;
5030 char *kwnames[] = {
5031 (char *) "choices",(char *) "allowOthers", NULL
5032 };
5033
5034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) goto fail;
5035 if (obj0) {
5036 {
5037 arg1 = PyList_Size(obj0);
5038 arg2 = wxString_LIST_helper(obj0);
5039 if (arg2 == NULL) SWIG_fail;
5040 }
5041 }
5042 if (obj1) {
5043 {
5044 arg3 = static_cast<bool >(SWIG_As_bool(obj1));
5045 if (SWIG_arg_fail(3)) SWIG_fail;
5046 }
5047 }
5048 {
5049 PyThreadState* __tstate = wxPyBeginAllowThreads();
5050 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5051
5052 wxPyEndAllowThreads(__tstate);
5053 if (PyErr_Occurred()) SWIG_fail;
5054 }
5055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellChoiceEditor, 1);
5056 {
5057 if (arg2) delete [] arg2;
5058 }
5059 return resultobj;
5060 fail:
5061 {
5062 if (arg2) delete [] arg2;
5063 }
5064 return NULL;
5065 }
5066
5067
5068 static PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5069 PyObject *resultobj = NULL;
5070 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5071 wxString result;
5072 PyObject * obj0 = 0 ;
5073 char *kwnames[] = {
5074 (char *) "self", NULL
5075 };
5076
5077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellChoiceEditor_GetValue",kwnames,&obj0)) goto fail;
5078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_EXCEPTION | 0);
5079 if (SWIG_arg_fail(1)) SWIG_fail;
5080 {
5081 PyThreadState* __tstate = wxPyBeginAllowThreads();
5082 result = (arg1)->GetValue();
5083
5084 wxPyEndAllowThreads(__tstate);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 {
5088 #if wxUSE_UNICODE
5089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5090 #else
5091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5092 #endif
5093 }
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 static PyObject * GridCellChoiceEditor_swigregister(PyObject *, PyObject *args) {
5101 PyObject *obj;
5102 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5103 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellChoiceEditor, obj);
5104 Py_INCREF(obj);
5105 return Py_BuildValue((char *)"");
5106 }
5107 static PyObject *_wrap_new_GridCellEnumEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5108 PyObject *resultobj = NULL;
5109 wxString const &arg1_defvalue = wxPyEmptyString ;
5110 wxString *arg1 = (wxString *) &arg1_defvalue ;
5111 wxGridCellEnumEditor *result;
5112 bool temp1 = false ;
5113 PyObject * obj0 = 0 ;
5114 char *kwnames[] = {
5115 (char *) "choices", NULL
5116 };
5117
5118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) goto fail;
5119 if (obj0) {
5120 {
5121 arg1 = wxString_in_helper(obj0);
5122 if (arg1 == NULL) SWIG_fail;
5123 temp1 = true;
5124 }
5125 }
5126 {
5127 PyThreadState* __tstate = wxPyBeginAllowThreads();
5128 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5129
5130 wxPyEndAllowThreads(__tstate);
5131 if (PyErr_Occurred()) SWIG_fail;
5132 }
5133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellEnumEditor, 1);
5134 {
5135 if (temp1)
5136 delete arg1;
5137 }
5138 return resultobj;
5139 fail:
5140 {
5141 if (temp1)
5142 delete arg1;
5143 }
5144 return NULL;
5145 }
5146
5147
5148 static PyObject *_wrap_GridCellEnumEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5149 PyObject *resultobj = NULL;
5150 wxGridCellEnumEditor *arg1 = (wxGridCellEnumEditor *) 0 ;
5151 wxString result;
5152 PyObject * obj0 = 0 ;
5153 char *kwnames[] = {
5154 (char *) "self", NULL
5155 };
5156
5157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellEnumEditor_GetValue",kwnames,&obj0)) goto fail;
5158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_EXCEPTION | 0);
5159 if (SWIG_arg_fail(1)) SWIG_fail;
5160 {
5161 PyThreadState* __tstate = wxPyBeginAllowThreads();
5162 result = (arg1)->GetValue();
5163
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 #if wxUSE_UNICODE
5169 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5170 #else
5171 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5172 #endif
5173 }
5174 return resultobj;
5175 fail:
5176 return NULL;
5177 }
5178
5179
5180 static PyObject * GridCellEnumEditor_swigregister(PyObject *, PyObject *args) {
5181 PyObject *obj;
5182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5183 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellEnumEditor, obj);
5184 Py_INCREF(obj);
5185 return Py_BuildValue((char *)"");
5186 }
5187 static PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5188 PyObject *resultobj = NULL;
5189 wxGridCellAutoWrapStringEditor *result;
5190 char *kwnames[] = {
5191 NULL
5192 };
5193
5194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAutoWrapStringEditor",kwnames)) goto fail;
5195 {
5196 PyThreadState* __tstate = wxPyBeginAllowThreads();
5197 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5198
5199 wxPyEndAllowThreads(__tstate);
5200 if (PyErr_Occurred()) SWIG_fail;
5201 }
5202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, 1);
5203 return resultobj;
5204 fail:
5205 return NULL;
5206 }
5207
5208
5209 static PyObject *_wrap_GridCellAutoWrapStringEditor_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
5210 PyObject *resultobj = NULL;
5211 wxGridCellAutoWrapStringEditor *arg1 = (wxGridCellAutoWrapStringEditor *) 0 ;
5212 wxString result;
5213 PyObject * obj0 = 0 ;
5214 char *kwnames[] = {
5215 (char *) "self", NULL
5216 };
5217
5218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAutoWrapStringEditor_GetValue",kwnames,&obj0)) goto fail;
5219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_EXCEPTION | 0);
5220 if (SWIG_arg_fail(1)) SWIG_fail;
5221 {
5222 PyThreadState* __tstate = wxPyBeginAllowThreads();
5223 result = (arg1)->GetValue();
5224
5225 wxPyEndAllowThreads(__tstate);
5226 if (PyErr_Occurred()) SWIG_fail;
5227 }
5228 {
5229 #if wxUSE_UNICODE
5230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5231 #else
5232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5233 #endif
5234 }
5235 return resultobj;
5236 fail:
5237 return NULL;
5238 }
5239
5240
5241 static PyObject * GridCellAutoWrapStringEditor_swigregister(PyObject *, PyObject *args) {
5242 PyObject *obj;
5243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5244 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, obj);
5245 Py_INCREF(obj);
5246 return Py_BuildValue((char *)"");
5247 }
5248 static PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
5249 PyObject *resultobj = NULL;
5250 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5251 PyObject *arg2 = (PyObject *) 0 ;
5252 PyObject * obj0 = 0 ;
5253 PyObject * obj1 = 0 ;
5254 char *kwnames[] = {
5255 (char *) "self",(char *) "_self", NULL
5256 };
5257
5258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
5259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5260 if (SWIG_arg_fail(1)) SWIG_fail;
5261 arg2 = obj1;
5262 {
5263 PyThreadState* __tstate = wxPyBeginAllowThreads();
5264 wxGridCellAttr__setOORInfo(arg1,arg2);
5265
5266 wxPyEndAllowThreads(__tstate);
5267 if (PyErr_Occurred()) SWIG_fail;
5268 }
5269 Py_INCREF(Py_None); resultobj = Py_None;
5270 return resultobj;
5271 fail:
5272 return NULL;
5273 }
5274
5275
5276 static PyObject *_wrap_new_GridCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
5277 PyObject *resultobj = NULL;
5278 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5279 wxGridCellAttr *result;
5280 PyObject * obj0 = 0 ;
5281 char *kwnames[] = {
5282 (char *) "attrDefault", NULL
5283 };
5284
5285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) goto fail;
5286 if (obj0) {
5287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5288 if (SWIG_arg_fail(1)) SWIG_fail;
5289 }
5290 {
5291 PyThreadState* __tstate = wxPyBeginAllowThreads();
5292 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5293
5294 wxPyEndAllowThreads(__tstate);
5295 if (PyErr_Occurred()) SWIG_fail;
5296 }
5297 {
5298 resultobj = wxPyMake_wxGridCellAttr(result, (bool)1);
5299 }
5300 return resultobj;
5301 fail:
5302 return NULL;
5303 }
5304
5305
5306 static PyObject *_wrap_GridCellAttr_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
5307 PyObject *resultobj = NULL;
5308 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5309 wxGridCellAttr *result;
5310 PyObject * obj0 = 0 ;
5311 char *kwnames[] = {
5312 (char *) "self", NULL
5313 };
5314
5315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_Clone",kwnames,&obj0)) goto fail;
5316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5317 if (SWIG_arg_fail(1)) SWIG_fail;
5318 {
5319 PyThreadState* __tstate = wxPyBeginAllowThreads();
5320 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5321
5322 wxPyEndAllowThreads(__tstate);
5323 if (PyErr_Occurred()) SWIG_fail;
5324 }
5325 {
5326 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5327 }
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 static PyObject *_wrap_GridCellAttr_MergeWith(PyObject *, PyObject *args, PyObject *kwargs) {
5335 PyObject *resultobj = NULL;
5336 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5337 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5338 PyObject * obj0 = 0 ;
5339 PyObject * obj1 = 0 ;
5340 char *kwnames[] = {
5341 (char *) "self",(char *) "mergefrom", NULL
5342 };
5343
5344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) goto fail;
5345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5346 if (SWIG_arg_fail(1)) SWIG_fail;
5347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5348 if (SWIG_arg_fail(2)) SWIG_fail;
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 (arg1)->MergeWith(arg2);
5352
5353 wxPyEndAllowThreads(__tstate);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 Py_INCREF(Py_None); resultobj = Py_None;
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 static PyObject *_wrap_GridCellAttr_IncRef(PyObject *, PyObject *args, PyObject *kwargs) {
5364 PyObject *resultobj = NULL;
5365 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5366 PyObject * obj0 = 0 ;
5367 char *kwnames[] = {
5368 (char *) "self", NULL
5369 };
5370
5371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IncRef",kwnames,&obj0)) goto fail;
5372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5373 if (SWIG_arg_fail(1)) SWIG_fail;
5374 {
5375 PyThreadState* __tstate = wxPyBeginAllowThreads();
5376 (arg1)->IncRef();
5377
5378 wxPyEndAllowThreads(__tstate);
5379 if (PyErr_Occurred()) SWIG_fail;
5380 }
5381 Py_INCREF(Py_None); resultobj = Py_None;
5382 return resultobj;
5383 fail:
5384 return NULL;
5385 }
5386
5387
5388 static PyObject *_wrap_GridCellAttr_DecRef(PyObject *, PyObject *args, PyObject *kwargs) {
5389 PyObject *resultobj = NULL;
5390 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5391 PyObject * obj0 = 0 ;
5392 char *kwnames[] = {
5393 (char *) "self", NULL
5394 };
5395
5396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_DecRef",kwnames,&obj0)) goto fail;
5397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5398 if (SWIG_arg_fail(1)) SWIG_fail;
5399 {
5400 PyThreadState* __tstate = wxPyBeginAllowThreads();
5401 (arg1)->DecRef();
5402
5403 wxPyEndAllowThreads(__tstate);
5404 if (PyErr_Occurred()) SWIG_fail;
5405 }
5406 Py_INCREF(Py_None); resultobj = Py_None;
5407 return resultobj;
5408 fail:
5409 return NULL;
5410 }
5411
5412
5413 static PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5414 PyObject *resultobj = NULL;
5415 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5416 wxColour *arg2 = 0 ;
5417 wxColour temp2 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char *kwnames[] = {
5421 (char *) "self",(char *) "colText", NULL
5422 };
5423
5424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
5425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5426 if (SWIG_arg_fail(1)) SWIG_fail;
5427 {
5428 arg2 = &temp2;
5429 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5430 }
5431 {
5432 PyThreadState* __tstate = wxPyBeginAllowThreads();
5433 (arg1)->SetTextColour((wxColour const &)*arg2);
5434
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 Py_INCREF(Py_None); resultobj = Py_None;
5439 return resultobj;
5440 fail:
5441 return NULL;
5442 }
5443
5444
5445 static PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5446 PyObject *resultobj = NULL;
5447 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5448 wxColour *arg2 = 0 ;
5449 wxColour temp2 ;
5450 PyObject * obj0 = 0 ;
5451 PyObject * obj1 = 0 ;
5452 char *kwnames[] = {
5453 (char *) "self",(char *) "colBack", NULL
5454 };
5455
5456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
5457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5458 if (SWIG_arg_fail(1)) SWIG_fail;
5459 {
5460 arg2 = &temp2;
5461 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5462 }
5463 {
5464 PyThreadState* __tstate = wxPyBeginAllowThreads();
5465 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
5466
5467 wxPyEndAllowThreads(__tstate);
5468 if (PyErr_Occurred()) SWIG_fail;
5469 }
5470 Py_INCREF(Py_None); resultobj = Py_None;
5471 return resultobj;
5472 fail:
5473 return NULL;
5474 }
5475
5476
5477 static PyObject *_wrap_GridCellAttr_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
5478 PyObject *resultobj = NULL;
5479 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5480 wxFont *arg2 = 0 ;
5481 PyObject * obj0 = 0 ;
5482 PyObject * obj1 = 0 ;
5483 char *kwnames[] = {
5484 (char *) "self",(char *) "font", NULL
5485 };
5486
5487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) goto fail;
5488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5489 if (SWIG_arg_fail(1)) SWIG_fail;
5490 {
5491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
5492 if (SWIG_arg_fail(2)) SWIG_fail;
5493 if (arg2 == NULL) {
5494 SWIG_null_ref("wxFont");
5495 }
5496 if (SWIG_arg_fail(2)) SWIG_fail;
5497 }
5498 {
5499 PyThreadState* __tstate = wxPyBeginAllowThreads();
5500 (arg1)->SetFont((wxFont const &)*arg2);
5501
5502 wxPyEndAllowThreads(__tstate);
5503 if (PyErr_Occurred()) SWIG_fail;
5504 }
5505 Py_INCREF(Py_None); resultobj = Py_None;
5506 return resultobj;
5507 fail:
5508 return NULL;
5509 }
5510
5511
5512 static PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5513 PyObject *resultobj = NULL;
5514 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5515 int arg2 ;
5516 int arg3 ;
5517 PyObject * obj0 = 0 ;
5518 PyObject * obj1 = 0 ;
5519 PyObject * obj2 = 0 ;
5520 char *kwnames[] = {
5521 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
5522 };
5523
5524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
5525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5526 if (SWIG_arg_fail(1)) SWIG_fail;
5527 {
5528 arg2 = static_cast<int >(SWIG_As_int(obj1));
5529 if (SWIG_arg_fail(2)) SWIG_fail;
5530 }
5531 {
5532 arg3 = static_cast<int >(SWIG_As_int(obj2));
5533 if (SWIG_arg_fail(3)) SWIG_fail;
5534 }
5535 {
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 (arg1)->SetAlignment(arg2,arg3);
5538
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 Py_INCREF(Py_None); resultobj = Py_None;
5543 return resultobj;
5544 fail:
5545 return NULL;
5546 }
5547
5548
5549 static PyObject *_wrap_GridCellAttr_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5550 PyObject *resultobj = NULL;
5551 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5552 int arg2 ;
5553 int arg3 ;
5554 PyObject * obj0 = 0 ;
5555 PyObject * obj1 = 0 ;
5556 PyObject * obj2 = 0 ;
5557 char *kwnames[] = {
5558 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
5559 };
5560
5561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
5562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5563 if (SWIG_arg_fail(1)) SWIG_fail;
5564 {
5565 arg2 = static_cast<int >(SWIG_As_int(obj1));
5566 if (SWIG_arg_fail(2)) SWIG_fail;
5567 }
5568 {
5569 arg3 = static_cast<int >(SWIG_As_int(obj2));
5570 if (SWIG_arg_fail(3)) SWIG_fail;
5571 }
5572 {
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 (arg1)->SetSize(arg2,arg3);
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 Py_INCREF(Py_None); resultobj = Py_None;
5580 return resultobj;
5581 fail:
5582 return NULL;
5583 }
5584
5585
5586 static PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
5587 PyObject *resultobj = NULL;
5588 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5589 bool arg2 = (bool) true ;
5590 PyObject * obj0 = 0 ;
5591 PyObject * obj1 = 0 ;
5592 char *kwnames[] = {
5593 (char *) "self",(char *) "allow", NULL
5594 };
5595
5596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) goto fail;
5597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5598 if (SWIG_arg_fail(1)) SWIG_fail;
5599 if (obj1) {
5600 {
5601 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
5602 if (SWIG_arg_fail(2)) SWIG_fail;
5603 }
5604 }
5605 {
5606 PyThreadState* __tstate = wxPyBeginAllowThreads();
5607 (arg1)->SetOverflow(arg2);
5608
5609 wxPyEndAllowThreads(__tstate);
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 Py_INCREF(Py_None); resultobj = Py_None;
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 static PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
5620 PyObject *resultobj = NULL;
5621 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5622 bool arg2 = (bool) true ;
5623 PyObject * obj0 = 0 ;
5624 PyObject * obj1 = 0 ;
5625 char *kwnames[] = {
5626 (char *) "self",(char *) "isReadOnly", NULL
5627 };
5628
5629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) goto fail;
5630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5631 if (SWIG_arg_fail(1)) SWIG_fail;
5632 if (obj1) {
5633 {
5634 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
5635 if (SWIG_arg_fail(2)) SWIG_fail;
5636 }
5637 }
5638 {
5639 PyThreadState* __tstate = wxPyBeginAllowThreads();
5640 (arg1)->SetReadOnly(arg2);
5641
5642 wxPyEndAllowThreads(__tstate);
5643 if (PyErr_Occurred()) SWIG_fail;
5644 }
5645 Py_INCREF(Py_None); resultobj = Py_None;
5646 return resultobj;
5647 fail:
5648 return NULL;
5649 }
5650
5651
5652 static PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5653 PyObject *resultobj = NULL;
5654 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5655 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
5656 PyObject * obj0 = 0 ;
5657 PyObject * obj1 = 0 ;
5658 char *kwnames[] = {
5659 (char *) "self",(char *) "renderer", NULL
5660 };
5661
5662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) goto fail;
5663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5664 if (SWIG_arg_fail(1)) SWIG_fail;
5665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
5666 if (SWIG_arg_fail(2)) SWIG_fail;
5667 {
5668 PyThreadState* __tstate = wxPyBeginAllowThreads();
5669 (arg1)->SetRenderer(arg2);
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 Py_INCREF(Py_None); resultobj = Py_None;
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 static PyObject *_wrap_GridCellAttr_SetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj = NULL;
5683 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5684 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
5685 PyObject * obj0 = 0 ;
5686 PyObject * obj1 = 0 ;
5687 char *kwnames[] = {
5688 (char *) "self",(char *) "editor", NULL
5689 };
5690
5691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) goto fail;
5692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5693 if (SWIG_arg_fail(1)) SWIG_fail;
5694 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
5695 if (SWIG_arg_fail(2)) SWIG_fail;
5696 {
5697 PyThreadState* __tstate = wxPyBeginAllowThreads();
5698 (arg1)->SetEditor(arg2);
5699
5700 wxPyEndAllowThreads(__tstate);
5701 if (PyErr_Occurred()) SWIG_fail;
5702 }
5703 Py_INCREF(Py_None); resultobj = Py_None;
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 static PyObject *_wrap_GridCellAttr_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = NULL;
5712 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5713 wxGridCellAttr::wxAttrKind arg2 ;
5714 PyObject * obj0 = 0 ;
5715 PyObject * obj1 = 0 ;
5716 char *kwnames[] = {
5717 (char *) "self",(char *) "kind", NULL
5718 };
5719
5720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) goto fail;
5721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5722 if (SWIG_arg_fail(1)) SWIG_fail;
5723 {
5724 arg2 = static_cast<wxGridCellAttr::wxAttrKind >(SWIG_As_int(obj1));
5725 if (SWIG_arg_fail(2)) SWIG_fail;
5726 }
5727 {
5728 PyThreadState* __tstate = wxPyBeginAllowThreads();
5729 (arg1)->SetKind(arg2);
5730
5731 wxPyEndAllowThreads(__tstate);
5732 if (PyErr_Occurred()) SWIG_fail;
5733 }
5734 Py_INCREF(Py_None); resultobj = Py_None;
5735 return resultobj;
5736 fail:
5737 return NULL;
5738 }
5739
5740
5741 static PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5742 PyObject *resultobj = NULL;
5743 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5744 bool result;
5745 PyObject * obj0 = 0 ;
5746 char *kwnames[] = {
5747 (char *) "self", NULL
5748 };
5749
5750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasTextColour",kwnames,&obj0)) goto fail;
5751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5752 if (SWIG_arg_fail(1)) SWIG_fail;
5753 {
5754 PyThreadState* __tstate = wxPyBeginAllowThreads();
5755 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
5756
5757 wxPyEndAllowThreads(__tstate);
5758 if (PyErr_Occurred()) SWIG_fail;
5759 }
5760 {
5761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5762 }
5763 return resultobj;
5764 fail:
5765 return NULL;
5766 }
5767
5768
5769 static PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5770 PyObject *resultobj = NULL;
5771 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5772 bool result;
5773 PyObject * obj0 = 0 ;
5774 char *kwnames[] = {
5775 (char *) "self", NULL
5776 };
5777
5778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasBackgroundColour",kwnames,&obj0)) goto fail;
5779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5780 if (SWIG_arg_fail(1)) SWIG_fail;
5781 {
5782 PyThreadState* __tstate = wxPyBeginAllowThreads();
5783 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
5784
5785 wxPyEndAllowThreads(__tstate);
5786 if (PyErr_Occurred()) SWIG_fail;
5787 }
5788 {
5789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5790 }
5791 return resultobj;
5792 fail:
5793 return NULL;
5794 }
5795
5796
5797 static PyObject *_wrap_GridCellAttr_HasFont(PyObject *, PyObject *args, PyObject *kwargs) {
5798 PyObject *resultobj = NULL;
5799 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5800 bool result;
5801 PyObject * obj0 = 0 ;
5802 char *kwnames[] = {
5803 (char *) "self", NULL
5804 };
5805
5806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasFont",kwnames,&obj0)) goto fail;
5807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5808 if (SWIG_arg_fail(1)) SWIG_fail;
5809 {
5810 PyThreadState* __tstate = wxPyBeginAllowThreads();
5811 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
5812
5813 wxPyEndAllowThreads(__tstate);
5814 if (PyErr_Occurred()) SWIG_fail;
5815 }
5816 {
5817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5818 }
5819 return resultobj;
5820 fail:
5821 return NULL;
5822 }
5823
5824
5825 static PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
5826 PyObject *resultobj = NULL;
5827 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5828 bool result;
5829 PyObject * obj0 = 0 ;
5830 char *kwnames[] = {
5831 (char *) "self", NULL
5832 };
5833
5834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasAlignment",kwnames,&obj0)) goto fail;
5835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5836 if (SWIG_arg_fail(1)) SWIG_fail;
5837 {
5838 PyThreadState* __tstate = wxPyBeginAllowThreads();
5839 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
5840
5841 wxPyEndAllowThreads(__tstate);
5842 if (PyErr_Occurred()) SWIG_fail;
5843 }
5844 {
5845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5846 }
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj = NULL;
5855 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5856 bool result;
5857 PyObject * obj0 = 0 ;
5858 char *kwnames[] = {
5859 (char *) "self", NULL
5860 };
5861
5862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasRenderer",kwnames,&obj0)) goto fail;
5863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5864 if (SWIG_arg_fail(1)) SWIG_fail;
5865 {
5866 PyThreadState* __tstate = wxPyBeginAllowThreads();
5867 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
5868
5869 wxPyEndAllowThreads(__tstate);
5870 if (PyErr_Occurred()) SWIG_fail;
5871 }
5872 {
5873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5874 }
5875 return resultobj;
5876 fail:
5877 return NULL;
5878 }
5879
5880
5881 static PyObject *_wrap_GridCellAttr_HasEditor(PyObject *, PyObject *args, PyObject *kwargs) {
5882 PyObject *resultobj = NULL;
5883 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5884 bool result;
5885 PyObject * obj0 = 0 ;
5886 char *kwnames[] = {
5887 (char *) "self", NULL
5888 };
5889
5890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasEditor",kwnames,&obj0)) goto fail;
5891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5892 if (SWIG_arg_fail(1)) SWIG_fail;
5893 {
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
5896
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 {
5901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5902 }
5903 return resultobj;
5904 fail:
5905 return NULL;
5906 }
5907
5908
5909 static PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *, PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj = NULL;
5911 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5912 bool result;
5913 PyObject * obj0 = 0 ;
5914 char *kwnames[] = {
5915 (char *) "self", NULL
5916 };
5917
5918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasReadWriteMode",kwnames,&obj0)) goto fail;
5919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5920 if (SWIG_arg_fail(1)) SWIG_fail;
5921 {
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
5924
5925 wxPyEndAllowThreads(__tstate);
5926 if (PyErr_Occurred()) SWIG_fail;
5927 }
5928 {
5929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5930 }
5931 return resultobj;
5932 fail:
5933 return NULL;
5934 }
5935
5936
5937 static PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *, PyObject *args, PyObject *kwargs) {
5938 PyObject *resultobj = NULL;
5939 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5940 bool result;
5941 PyObject * obj0 = 0 ;
5942 char *kwnames[] = {
5943 (char *) "self", NULL
5944 };
5945
5946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_HasOverflowMode",kwnames,&obj0)) goto fail;
5947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5948 if (SWIG_arg_fail(1)) SWIG_fail;
5949 {
5950 PyThreadState* __tstate = wxPyBeginAllowThreads();
5951 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
5952
5953 wxPyEndAllowThreads(__tstate);
5954 if (PyErr_Occurred()) SWIG_fail;
5955 }
5956 {
5957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5958 }
5959 return resultobj;
5960 fail:
5961 return NULL;
5962 }
5963
5964
5965 static PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
5966 PyObject *resultobj = NULL;
5967 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5968 wxColour result;
5969 PyObject * obj0 = 0 ;
5970 char *kwnames[] = {
5971 (char *) "self", NULL
5972 };
5973
5974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetTextColour",kwnames,&obj0)) goto fail;
5975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
5976 if (SWIG_arg_fail(1)) SWIG_fail;
5977 {
5978 PyThreadState* __tstate = wxPyBeginAllowThreads();
5979 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
5980
5981 wxPyEndAllowThreads(__tstate);
5982 if (PyErr_Occurred()) SWIG_fail;
5983 }
5984 {
5985 wxColour * resultptr;
5986 resultptr = new wxColour(static_cast<wxColour & >(result));
5987 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5988 }
5989 return resultobj;
5990 fail:
5991 return NULL;
5992 }
5993
5994
5995 static PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
5996 PyObject *resultobj = NULL;
5997 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5998 wxColour result;
5999 PyObject * obj0 = 0 ;
6000 char *kwnames[] = {
6001 (char *) "self", NULL
6002 };
6003
6004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetBackgroundColour",kwnames,&obj0)) goto fail;
6005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6006 if (SWIG_arg_fail(1)) SWIG_fail;
6007 {
6008 PyThreadState* __tstate = wxPyBeginAllowThreads();
6009 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6010
6011 wxPyEndAllowThreads(__tstate);
6012 if (PyErr_Occurred()) SWIG_fail;
6013 }
6014 {
6015 wxColour * resultptr;
6016 resultptr = new wxColour(static_cast<wxColour & >(result));
6017 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
6018 }
6019 return resultobj;
6020 fail:
6021 return NULL;
6022 }
6023
6024
6025 static PyObject *_wrap_GridCellAttr_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
6026 PyObject *resultobj = NULL;
6027 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6028 wxFont result;
6029 PyObject * obj0 = 0 ;
6030 char *kwnames[] = {
6031 (char *) "self", NULL
6032 };
6033
6034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetFont",kwnames,&obj0)) goto fail;
6035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6036 if (SWIG_arg_fail(1)) SWIG_fail;
6037 {
6038 PyThreadState* __tstate = wxPyBeginAllowThreads();
6039 result = ((wxGridCellAttr const *)arg1)->GetFont();
6040
6041 wxPyEndAllowThreads(__tstate);
6042 if (PyErr_Occurred()) SWIG_fail;
6043 }
6044 {
6045 wxFont * resultptr;
6046 resultptr = new wxFont(static_cast<wxFont & >(result));
6047 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
6048 }
6049 return resultobj;
6050 fail:
6051 return NULL;
6052 }
6053
6054
6055 static PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
6056 PyObject *resultobj = NULL;
6057 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6058 int *arg2 = (int *) 0 ;
6059 int *arg3 = (int *) 0 ;
6060 int temp2 ;
6061 int res2 = 0 ;
6062 int temp3 ;
6063 int res3 = 0 ;
6064 PyObject * obj0 = 0 ;
6065 char *kwnames[] = {
6066 (char *) "self", NULL
6067 };
6068
6069 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6070 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetAlignment",kwnames,&obj0)) goto fail;
6072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6073 if (SWIG_arg_fail(1)) SWIG_fail;
6074 {
6075 PyThreadState* __tstate = wxPyBeginAllowThreads();
6076 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6077
6078 wxPyEndAllowThreads(__tstate);
6079 if (PyErr_Occurred()) SWIG_fail;
6080 }
6081 Py_INCREF(Py_None); resultobj = Py_None;
6082 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6083 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6084 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6085 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6086 return resultobj;
6087 fail:
6088 return NULL;
6089 }
6090
6091
6092 static PyObject *_wrap_GridCellAttr_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6093 PyObject *resultobj = NULL;
6094 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6095 int *arg2 = (int *) 0 ;
6096 int *arg3 = (int *) 0 ;
6097 int temp2 ;
6098 int res2 = 0 ;
6099 int temp3 ;
6100 int res3 = 0 ;
6101 PyObject * obj0 = 0 ;
6102 char *kwnames[] = {
6103 (char *) "self", NULL
6104 };
6105
6106 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6107 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetSize",kwnames,&obj0)) goto fail;
6109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6110 if (SWIG_arg_fail(1)) SWIG_fail;
6111 {
6112 PyThreadState* __tstate = wxPyBeginAllowThreads();
6113 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6114
6115 wxPyEndAllowThreads(__tstate);
6116 if (PyErr_Occurred()) SWIG_fail;
6117 }
6118 Py_INCREF(Py_None); resultobj = Py_None;
6119 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6120 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6121 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6122 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6123 return resultobj;
6124 fail:
6125 return NULL;
6126 }
6127
6128
6129 static PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
6130 PyObject *resultobj = NULL;
6131 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6132 bool result;
6133 PyObject * obj0 = 0 ;
6134 char *kwnames[] = {
6135 (char *) "self", NULL
6136 };
6137
6138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetOverflow",kwnames,&obj0)) goto fail;
6139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6140 if (SWIG_arg_fail(1)) SWIG_fail;
6141 {
6142 PyThreadState* __tstate = wxPyBeginAllowThreads();
6143 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6144
6145 wxPyEndAllowThreads(__tstate);
6146 if (PyErr_Occurred()) SWIG_fail;
6147 }
6148 {
6149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6150 }
6151 return resultobj;
6152 fail:
6153 return NULL;
6154 }
6155
6156
6157 static PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
6158 PyObject *resultobj = NULL;
6159 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6160 wxGrid *arg2 = (wxGrid *) 0 ;
6161 int arg3 ;
6162 int arg4 ;
6163 wxGridCellRenderer *result;
6164 PyObject * obj0 = 0 ;
6165 PyObject * obj1 = 0 ;
6166 PyObject * obj2 = 0 ;
6167 PyObject * obj3 = 0 ;
6168 char *kwnames[] = {
6169 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6170 };
6171
6172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6174 if (SWIG_arg_fail(1)) SWIG_fail;
6175 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6176 if (SWIG_arg_fail(2)) SWIG_fail;
6177 {
6178 arg3 = static_cast<int >(SWIG_As_int(obj2));
6179 if (SWIG_arg_fail(3)) SWIG_fail;
6180 }
6181 {
6182 arg4 = static_cast<int >(SWIG_As_int(obj3));
6183 if (SWIG_arg_fail(4)) SWIG_fail;
6184 }
6185 {
6186 PyThreadState* __tstate = wxPyBeginAllowThreads();
6187 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6188
6189 wxPyEndAllowThreads(__tstate);
6190 if (PyErr_Occurred()) SWIG_fail;
6191 }
6192 {
6193 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6194 }
6195 return resultobj;
6196 fail:
6197 return NULL;
6198 }
6199
6200
6201 static PyObject *_wrap_GridCellAttr_GetEditor(PyObject *, PyObject *args, PyObject *kwargs) {
6202 PyObject *resultobj = NULL;
6203 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6204 wxGrid *arg2 = (wxGrid *) 0 ;
6205 int arg3 ;
6206 int arg4 ;
6207 wxGridCellEditor *result;
6208 PyObject * obj0 = 0 ;
6209 PyObject * obj1 = 0 ;
6210 PyObject * obj2 = 0 ;
6211 PyObject * obj3 = 0 ;
6212 char *kwnames[] = {
6213 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6214 };
6215
6216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6218 if (SWIG_arg_fail(1)) SWIG_fail;
6219 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6220 if (SWIG_arg_fail(2)) SWIG_fail;
6221 {
6222 arg3 = static_cast<int >(SWIG_As_int(obj2));
6223 if (SWIG_arg_fail(3)) SWIG_fail;
6224 }
6225 {
6226 arg4 = static_cast<int >(SWIG_As_int(obj3));
6227 if (SWIG_arg_fail(4)) SWIG_fail;
6228 }
6229 {
6230 PyThreadState* __tstate = wxPyBeginAllowThreads();
6231 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6232
6233 wxPyEndAllowThreads(__tstate);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 {
6237 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6238 }
6239 return resultobj;
6240 fail:
6241 return NULL;
6242 }
6243
6244
6245 static PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
6246 PyObject *resultobj = NULL;
6247 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6248 bool result;
6249 PyObject * obj0 = 0 ;
6250 char *kwnames[] = {
6251 (char *) "self", NULL
6252 };
6253
6254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_IsReadOnly",kwnames,&obj0)) goto fail;
6255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6256 if (SWIG_arg_fail(1)) SWIG_fail;
6257 {
6258 PyThreadState* __tstate = wxPyBeginAllowThreads();
6259 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6260
6261 wxPyEndAllowThreads(__tstate);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 {
6265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6266 }
6267 return resultobj;
6268 fail:
6269 return NULL;
6270 }
6271
6272
6273 static PyObject *_wrap_GridCellAttr_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
6274 PyObject *resultobj = NULL;
6275 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6276 wxGridCellAttr::wxAttrKind result;
6277 PyObject * obj0 = 0 ;
6278 char *kwnames[] = {
6279 (char *) "self", NULL
6280 };
6281
6282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellAttr_GetKind",kwnames,&obj0)) goto fail;
6283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6284 if (SWIG_arg_fail(1)) SWIG_fail;
6285 {
6286 PyThreadState* __tstate = wxPyBeginAllowThreads();
6287 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6288
6289 wxPyEndAllowThreads(__tstate);
6290 if (PyErr_Occurred()) SWIG_fail;
6291 }
6292 resultobj = SWIG_From_int((result));
6293 return resultobj;
6294 fail:
6295 return NULL;
6296 }
6297
6298
6299 static PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6300 PyObject *resultobj = NULL;
6301 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6302 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6303 PyObject * obj0 = 0 ;
6304 PyObject * obj1 = 0 ;
6305 char *kwnames[] = {
6306 (char *) "self",(char *) "defAttr", NULL
6307 };
6308
6309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) goto fail;
6310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6311 if (SWIG_arg_fail(1)) SWIG_fail;
6312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6313 if (SWIG_arg_fail(2)) SWIG_fail;
6314 {
6315 PyThreadState* __tstate = wxPyBeginAllowThreads();
6316 (arg1)->SetDefAttr(arg2);
6317
6318 wxPyEndAllowThreads(__tstate);
6319 if (PyErr_Occurred()) SWIG_fail;
6320 }
6321 Py_INCREF(Py_None); resultobj = Py_None;
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 static PyObject * GridCellAttr_swigregister(PyObject *, PyObject *args) {
6329 PyObject *obj;
6330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6331 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttr, obj);
6332 Py_INCREF(obj);
6333 return Py_BuildValue((char *)"");
6334 }
6335 static PyObject *_wrap_new_GridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6336 PyObject *resultobj = NULL;
6337 wxGridCellAttrProvider *result;
6338 char *kwnames[] = {
6339 NULL
6340 };
6341
6342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GridCellAttrProvider",kwnames)) goto fail;
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
6346
6347 wxPyEndAllowThreads(__tstate);
6348 if (PyErr_Occurred()) SWIG_fail;
6349 }
6350 {
6351 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)1);
6352 }
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 static PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj = NULL;
6361 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6362 PyObject *arg2 = (PyObject *) 0 ;
6363 PyObject * obj0 = 0 ;
6364 PyObject * obj1 = 0 ;
6365 char *kwnames[] = {
6366 (char *) "self",(char *) "_self", NULL
6367 };
6368
6369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6371 if (SWIG_arg_fail(1)) SWIG_fail;
6372 arg2 = obj1;
6373 {
6374 PyThreadState* __tstate = wxPyBeginAllowThreads();
6375 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
6376
6377 wxPyEndAllowThreads(__tstate);
6378 if (PyErr_Occurred()) SWIG_fail;
6379 }
6380 Py_INCREF(Py_None); resultobj = Py_None;
6381 return resultobj;
6382 fail:
6383 return NULL;
6384 }
6385
6386
6387 static PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6388 PyObject *resultobj = NULL;
6389 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6390 int arg2 ;
6391 int arg3 ;
6392 wxGridCellAttr::wxAttrKind arg4 ;
6393 wxGridCellAttr *result;
6394 PyObject * obj0 = 0 ;
6395 PyObject * obj1 = 0 ;
6396 PyObject * obj2 = 0 ;
6397 PyObject * obj3 = 0 ;
6398 char *kwnames[] = {
6399 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6400 };
6401
6402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6404 if (SWIG_arg_fail(1)) SWIG_fail;
6405 {
6406 arg2 = static_cast<int >(SWIG_As_int(obj1));
6407 if (SWIG_arg_fail(2)) SWIG_fail;
6408 }
6409 {
6410 arg3 = static_cast<int >(SWIG_As_int(obj2));
6411 if (SWIG_arg_fail(3)) SWIG_fail;
6412 }
6413 {
6414 arg4 = static_cast<wxGridCellAttr::wxAttrKind >(SWIG_As_int(obj3));
6415 if (SWIG_arg_fail(4)) SWIG_fail;
6416 }
6417 {
6418 PyThreadState* __tstate = wxPyBeginAllowThreads();
6419 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
6420
6421 wxPyEndAllowThreads(__tstate);
6422 if (PyErr_Occurred()) SWIG_fail;
6423 }
6424 {
6425 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6426 }
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 static PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj = NULL;
6435 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6436 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6437 int arg3 ;
6438 int arg4 ;
6439 PyObject * obj0 = 0 ;
6440 PyObject * obj1 = 0 ;
6441 PyObject * obj2 = 0 ;
6442 PyObject * obj3 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6445 };
6446
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6449 if (SWIG_arg_fail(1)) SWIG_fail;
6450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6451 if (SWIG_arg_fail(2)) SWIG_fail;
6452 {
6453 arg3 = static_cast<int >(SWIG_As_int(obj2));
6454 if (SWIG_arg_fail(3)) SWIG_fail;
6455 }
6456 {
6457 arg4 = static_cast<int >(SWIG_As_int(obj3));
6458 if (SWIG_arg_fail(4)) SWIG_fail;
6459 }
6460 {
6461 PyThreadState* __tstate = wxPyBeginAllowThreads();
6462 (arg1)->SetAttr(arg2,arg3,arg4);
6463
6464 wxPyEndAllowThreads(__tstate);
6465 if (PyErr_Occurred()) SWIG_fail;
6466 }
6467 Py_INCREF(Py_None); resultobj = Py_None;
6468 return resultobj;
6469 fail:
6470 return NULL;
6471 }
6472
6473
6474 static PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6475 PyObject *resultobj = NULL;
6476 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6477 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6478 int arg3 ;
6479 PyObject * obj0 = 0 ;
6480 PyObject * obj1 = 0 ;
6481 PyObject * obj2 = 0 ;
6482 char *kwnames[] = {
6483 (char *) "self",(char *) "attr",(char *) "row", NULL
6484 };
6485
6486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6488 if (SWIG_arg_fail(1)) SWIG_fail;
6489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6490 if (SWIG_arg_fail(2)) SWIG_fail;
6491 {
6492 arg3 = static_cast<int >(SWIG_As_int(obj2));
6493 if (SWIG_arg_fail(3)) SWIG_fail;
6494 }
6495 {
6496 PyThreadState* __tstate = wxPyBeginAllowThreads();
6497 (arg1)->SetRowAttr(arg2,arg3);
6498
6499 wxPyEndAllowThreads(__tstate);
6500 if (PyErr_Occurred()) SWIG_fail;
6501 }
6502 Py_INCREF(Py_None); resultobj = Py_None;
6503 return resultobj;
6504 fail:
6505 return NULL;
6506 }
6507
6508
6509 static PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6510 PyObject *resultobj = NULL;
6511 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6512 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6513 int arg3 ;
6514 PyObject * obj0 = 0 ;
6515 PyObject * obj1 = 0 ;
6516 PyObject * obj2 = 0 ;
6517 char *kwnames[] = {
6518 (char *) "self",(char *) "attr",(char *) "col", NULL
6519 };
6520
6521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6523 if (SWIG_arg_fail(1)) SWIG_fail;
6524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6525 if (SWIG_arg_fail(2)) SWIG_fail;
6526 {
6527 arg3 = static_cast<int >(SWIG_As_int(obj2));
6528 if (SWIG_arg_fail(3)) SWIG_fail;
6529 }
6530 {
6531 PyThreadState* __tstate = wxPyBeginAllowThreads();
6532 (arg1)->SetColAttr(arg2,arg3);
6533
6534 wxPyEndAllowThreads(__tstate);
6535 if (PyErr_Occurred()) SWIG_fail;
6536 }
6537 Py_INCREF(Py_None); resultobj = Py_None;
6538 return resultobj;
6539 fail:
6540 return NULL;
6541 }
6542
6543
6544 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *, PyObject *args, PyObject *kwargs) {
6545 PyObject *resultobj = NULL;
6546 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6547 size_t arg2 ;
6548 int arg3 ;
6549 PyObject * obj0 = 0 ;
6550 PyObject * obj1 = 0 ;
6551 PyObject * obj2 = 0 ;
6552 char *kwnames[] = {
6553 (char *) "self",(char *) "pos",(char *) "numRows", NULL
6554 };
6555
6556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
6557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6558 if (SWIG_arg_fail(1)) SWIG_fail;
6559 {
6560 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
6561 if (SWIG_arg_fail(2)) SWIG_fail;
6562 }
6563 {
6564 arg3 = static_cast<int >(SWIG_As_int(obj2));
6565 if (SWIG_arg_fail(3)) SWIG_fail;
6566 }
6567 {
6568 PyThreadState* __tstate = wxPyBeginAllowThreads();
6569 (arg1)->UpdateAttrRows(arg2,arg3);
6570
6571 wxPyEndAllowThreads(__tstate);
6572 if (PyErr_Occurred()) SWIG_fail;
6573 }
6574 Py_INCREF(Py_None); resultobj = Py_None;
6575 return resultobj;
6576 fail:
6577 return NULL;
6578 }
6579
6580
6581 static PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *, PyObject *args, PyObject *kwargs) {
6582 PyObject *resultobj = NULL;
6583 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6584 size_t arg2 ;
6585 int arg3 ;
6586 PyObject * obj0 = 0 ;
6587 PyObject * obj1 = 0 ;
6588 PyObject * obj2 = 0 ;
6589 char *kwnames[] = {
6590 (char *) "self",(char *) "pos",(char *) "numCols", NULL
6591 };
6592
6593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
6594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6595 if (SWIG_arg_fail(1)) SWIG_fail;
6596 {
6597 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
6598 if (SWIG_arg_fail(2)) SWIG_fail;
6599 }
6600 {
6601 arg3 = static_cast<int >(SWIG_As_int(obj2));
6602 if (SWIG_arg_fail(3)) SWIG_fail;
6603 }
6604 {
6605 PyThreadState* __tstate = wxPyBeginAllowThreads();
6606 (arg1)->UpdateAttrCols(arg2,arg3);
6607
6608 wxPyEndAllowThreads(__tstate);
6609 if (PyErr_Occurred()) SWIG_fail;
6610 }
6611 Py_INCREF(Py_None); resultobj = Py_None;
6612 return resultobj;
6613 fail:
6614 return NULL;
6615 }
6616
6617
6618 static PyObject * GridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6619 PyObject *obj;
6620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6621 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellAttrProvider, obj);
6622 Py_INCREF(obj);
6623 return Py_BuildValue((char *)"");
6624 }
6625 static PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6626 PyObject *resultobj = NULL;
6627 wxPyGridCellAttrProvider *result;
6628 char *kwnames[] = {
6629 NULL
6630 };
6631
6632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridCellAttrProvider",kwnames)) goto fail;
6633 {
6634 PyThreadState* __tstate = wxPyBeginAllowThreads();
6635 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
6636
6637 wxPyEndAllowThreads(__tstate);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridCellAttrProvider, 1);
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 static PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6648 PyObject *resultobj = NULL;
6649 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6650 PyObject *arg2 = (PyObject *) 0 ;
6651 PyObject *arg3 = (PyObject *) 0 ;
6652 PyObject * obj0 = 0 ;
6653 PyObject * obj1 = 0 ;
6654 PyObject * obj2 = 0 ;
6655 char *kwnames[] = {
6656 (char *) "self",(char *) "self",(char *) "_class", NULL
6657 };
6658
6659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
6660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6661 if (SWIG_arg_fail(1)) SWIG_fail;
6662 arg2 = obj1;
6663 arg3 = obj2;
6664 {
6665 PyThreadState* __tstate = wxPyBeginAllowThreads();
6666 (arg1)->_setCallbackInfo(arg2,arg3);
6667
6668 wxPyEndAllowThreads(__tstate);
6669 if (PyErr_Occurred()) SWIG_fail;
6670 }
6671 Py_INCREF(Py_None); resultobj = Py_None;
6672 return resultobj;
6673 fail:
6674 return NULL;
6675 }
6676
6677
6678 static PyObject *_wrap_PyGridCellAttrProvider_base_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6679 PyObject *resultobj = NULL;
6680 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6681 int arg2 ;
6682 int arg3 ;
6683 wxGridCellAttr::wxAttrKind arg4 ;
6684 wxGridCellAttr *result;
6685 PyObject * obj0 = 0 ;
6686 PyObject * obj1 = 0 ;
6687 PyObject * obj2 = 0 ;
6688 PyObject * obj3 = 0 ;
6689 char *kwnames[] = {
6690 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
6691 };
6692
6693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_base_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6695 if (SWIG_arg_fail(1)) SWIG_fail;
6696 {
6697 arg2 = static_cast<int >(SWIG_As_int(obj1));
6698 if (SWIG_arg_fail(2)) SWIG_fail;
6699 }
6700 {
6701 arg3 = static_cast<int >(SWIG_As_int(obj2));
6702 if (SWIG_arg_fail(3)) SWIG_fail;
6703 }
6704 {
6705 arg4 = static_cast<wxGridCellAttr::wxAttrKind >(SWIG_As_int(obj3));
6706 if (SWIG_arg_fail(4)) SWIG_fail;
6707 }
6708 {
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 result = (wxGridCellAttr *)(arg1)->base_GetAttr(arg2,arg3,arg4);
6711
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 {
6716 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6717 }
6718 return resultobj;
6719 fail:
6720 return NULL;
6721 }
6722
6723
6724 static PyObject *_wrap_PyGridCellAttrProvider_base_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6725 PyObject *resultobj = NULL;
6726 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6727 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6728 int arg3 ;
6729 int arg4 ;
6730 PyObject * obj0 = 0 ;
6731 PyObject * obj1 = 0 ;
6732 PyObject * obj2 = 0 ;
6733 PyObject * obj3 = 0 ;
6734 char *kwnames[] = {
6735 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
6736 };
6737
6738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_base_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6740 if (SWIG_arg_fail(1)) SWIG_fail;
6741 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6742 if (SWIG_arg_fail(2)) SWIG_fail;
6743 {
6744 arg3 = static_cast<int >(SWIG_As_int(obj2));
6745 if (SWIG_arg_fail(3)) SWIG_fail;
6746 }
6747 {
6748 arg4 = static_cast<int >(SWIG_As_int(obj3));
6749 if (SWIG_arg_fail(4)) SWIG_fail;
6750 }
6751 {
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 (arg1)->base_SetAttr(arg2,arg3,arg4);
6754
6755 wxPyEndAllowThreads(__tstate);
6756 if (PyErr_Occurred()) SWIG_fail;
6757 }
6758 Py_INCREF(Py_None); resultobj = Py_None;
6759 return resultobj;
6760 fail:
6761 return NULL;
6762 }
6763
6764
6765 static PyObject *_wrap_PyGridCellAttrProvider_base_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6766 PyObject *resultobj = NULL;
6767 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6768 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6769 int arg3 ;
6770 PyObject * obj0 = 0 ;
6771 PyObject * obj1 = 0 ;
6772 PyObject * obj2 = 0 ;
6773 char *kwnames[] = {
6774 (char *) "self",(char *) "attr",(char *) "row", NULL
6775 };
6776
6777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_base_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6779 if (SWIG_arg_fail(1)) SWIG_fail;
6780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6781 if (SWIG_arg_fail(2)) SWIG_fail;
6782 {
6783 arg3 = static_cast<int >(SWIG_As_int(obj2));
6784 if (SWIG_arg_fail(3)) SWIG_fail;
6785 }
6786 {
6787 PyThreadState* __tstate = wxPyBeginAllowThreads();
6788 (arg1)->base_SetRowAttr(arg2,arg3);
6789
6790 wxPyEndAllowThreads(__tstate);
6791 if (PyErr_Occurred()) SWIG_fail;
6792 }
6793 Py_INCREF(Py_None); resultobj = Py_None;
6794 return resultobj;
6795 fail:
6796 return NULL;
6797 }
6798
6799
6800 static PyObject *_wrap_PyGridCellAttrProvider_base_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
6801 PyObject *resultobj = NULL;
6802 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
6803 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6804 int arg3 ;
6805 PyObject * obj0 = 0 ;
6806 PyObject * obj1 = 0 ;
6807 PyObject * obj2 = 0 ;
6808 char *kwnames[] = {
6809 (char *) "self",(char *) "attr",(char *) "col", NULL
6810 };
6811
6812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_base_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
6813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6814 if (SWIG_arg_fail(1)) SWIG_fail;
6815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
6816 if (SWIG_arg_fail(2)) SWIG_fail;
6817 {
6818 arg3 = static_cast<int >(SWIG_As_int(obj2));
6819 if (SWIG_arg_fail(3)) SWIG_fail;
6820 }
6821 {
6822 PyThreadState* __tstate = wxPyBeginAllowThreads();
6823 (arg1)->base_SetColAttr(arg2,arg3);
6824
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 Py_INCREF(Py_None); resultobj = Py_None;
6829 return resultobj;
6830 fail:
6831 return NULL;
6832 }
6833
6834
6835 static PyObject * PyGridCellAttrProvider_swigregister(PyObject *, PyObject *args) {
6836 PyObject *obj;
6837 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6838 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, obj);
6839 Py_INCREF(obj);
6840 return Py_BuildValue((char *)"");
6841 }
6842 static PyObject *_wrap_GridTableBase__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6843 PyObject *resultobj = NULL;
6844 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6845 PyObject *arg2 = (PyObject *) 0 ;
6846 PyObject * obj0 = 0 ;
6847 PyObject * obj1 = 0 ;
6848 char *kwnames[] = {
6849 (char *) "self",(char *) "_self", NULL
6850 };
6851
6852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
6853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6854 if (SWIG_arg_fail(1)) SWIG_fail;
6855 arg2 = obj1;
6856 {
6857 PyThreadState* __tstate = wxPyBeginAllowThreads();
6858 wxGridTableBase__setOORInfo(arg1,arg2);
6859
6860 wxPyEndAllowThreads(__tstate);
6861 if (PyErr_Occurred()) SWIG_fail;
6862 }
6863 Py_INCREF(Py_None); resultobj = Py_None;
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 static PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6871 PyObject *resultobj = NULL;
6872 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6873 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
6874 PyObject * obj0 = 0 ;
6875 PyObject * obj1 = 0 ;
6876 char *kwnames[] = {
6877 (char *) "self",(char *) "attrProvider", NULL
6878 };
6879
6880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) goto fail;
6881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6882 if (SWIG_arg_fail(1)) SWIG_fail;
6883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttrProvider, SWIG_POINTER_EXCEPTION | 0);
6884 if (SWIG_arg_fail(2)) SWIG_fail;
6885 {
6886 PyThreadState* __tstate = wxPyBeginAllowThreads();
6887 (arg1)->SetAttrProvider(arg2);
6888
6889 wxPyEndAllowThreads(__tstate);
6890 if (PyErr_Occurred()) SWIG_fail;
6891 }
6892 Py_INCREF(Py_None); resultobj = Py_None;
6893 return resultobj;
6894 fail:
6895 return NULL;
6896 }
6897
6898
6899 static PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *, PyObject *args, PyObject *kwargs) {
6900 PyObject *resultobj = NULL;
6901 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6902 wxGridCellAttrProvider *result;
6903 PyObject * obj0 = 0 ;
6904 char *kwnames[] = {
6905 (char *) "self", NULL
6906 };
6907
6908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetAttrProvider",kwnames,&obj0)) goto fail;
6909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6910 if (SWIG_arg_fail(1)) SWIG_fail;
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
6914
6915 wxPyEndAllowThreads(__tstate);
6916 if (PyErr_Occurred()) SWIG_fail;
6917 }
6918 {
6919 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
6920 }
6921 return resultobj;
6922 fail:
6923 return NULL;
6924 }
6925
6926
6927 static PyObject *_wrap_GridTableBase_SetView(PyObject *, PyObject *args, PyObject *kwargs) {
6928 PyObject *resultobj = NULL;
6929 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6930 wxGrid *arg2 = (wxGrid *) 0 ;
6931 PyObject * obj0 = 0 ;
6932 PyObject * obj1 = 0 ;
6933 char *kwnames[] = {
6934 (char *) "self",(char *) "grid", NULL
6935 };
6936
6937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) goto fail;
6938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6939 if (SWIG_arg_fail(1)) SWIG_fail;
6940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
6941 if (SWIG_arg_fail(2)) SWIG_fail;
6942 {
6943 PyThreadState* __tstate = wxPyBeginAllowThreads();
6944 (arg1)->SetView(arg2);
6945
6946 wxPyEndAllowThreads(__tstate);
6947 if (PyErr_Occurred()) SWIG_fail;
6948 }
6949 Py_INCREF(Py_None); resultobj = Py_None;
6950 return resultobj;
6951 fail:
6952 return NULL;
6953 }
6954
6955
6956 static PyObject *_wrap_GridTableBase_GetView(PyObject *, PyObject *args, PyObject *kwargs) {
6957 PyObject *resultobj = NULL;
6958 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6959 wxGrid *result;
6960 PyObject * obj0 = 0 ;
6961 char *kwnames[] = {
6962 (char *) "self", NULL
6963 };
6964
6965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetView",kwnames,&obj0)) goto fail;
6966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6967 if (SWIG_arg_fail(1)) SWIG_fail;
6968 {
6969 PyThreadState* __tstate = wxPyBeginAllowThreads();
6970 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
6971
6972 wxPyEndAllowThreads(__tstate);
6973 if (PyErr_Occurred()) SWIG_fail;
6974 }
6975 {
6976 resultobj = wxPyMake_wxObject(result, (bool)0);
6977 }
6978 return resultobj;
6979 fail:
6980 return NULL;
6981 }
6982
6983
6984 static PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
6985 PyObject *resultobj = NULL;
6986 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
6987 int result;
6988 PyObject * obj0 = 0 ;
6989 char *kwnames[] = {
6990 (char *) "self", NULL
6991 };
6992
6993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberRows",kwnames,&obj0)) goto fail;
6994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
6995 if (SWIG_arg_fail(1)) SWIG_fail;
6996 {
6997 PyThreadState* __tstate = wxPyBeginAllowThreads();
6998 result = (int)(arg1)->GetNumberRows();
6999
7000 wxPyEndAllowThreads(__tstate);
7001 if (PyErr_Occurred()) SWIG_fail;
7002 }
7003 {
7004 resultobj = SWIG_From_int(static_cast<int >(result));
7005 }
7006 return resultobj;
7007 fail:
7008 return NULL;
7009 }
7010
7011
7012 static PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
7013 PyObject *resultobj = NULL;
7014 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7015 int result;
7016 PyObject * obj0 = 0 ;
7017 char *kwnames[] = {
7018 (char *) "self", NULL
7019 };
7020
7021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_GetNumberCols",kwnames,&obj0)) goto fail;
7022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7023 if (SWIG_arg_fail(1)) SWIG_fail;
7024 {
7025 PyThreadState* __tstate = wxPyBeginAllowThreads();
7026 result = (int)(arg1)->GetNumberCols();
7027
7028 wxPyEndAllowThreads(__tstate);
7029 if (PyErr_Occurred()) SWIG_fail;
7030 }
7031 {
7032 resultobj = SWIG_From_int(static_cast<int >(result));
7033 }
7034 return resultobj;
7035 fail:
7036 return NULL;
7037 }
7038
7039
7040 static PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *, PyObject *args, PyObject *kwargs) {
7041 PyObject *resultobj = NULL;
7042 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7043 int arg2 ;
7044 int arg3 ;
7045 bool result;
7046 PyObject * obj0 = 0 ;
7047 PyObject * obj1 = 0 ;
7048 PyObject * obj2 = 0 ;
7049 char *kwnames[] = {
7050 (char *) "self",(char *) "row",(char *) "col", NULL
7051 };
7052
7053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
7054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7055 if (SWIG_arg_fail(1)) SWIG_fail;
7056 {
7057 arg2 = static_cast<int >(SWIG_As_int(obj1));
7058 if (SWIG_arg_fail(2)) SWIG_fail;
7059 }
7060 {
7061 arg3 = static_cast<int >(SWIG_As_int(obj2));
7062 if (SWIG_arg_fail(3)) SWIG_fail;
7063 }
7064 {
7065 PyThreadState* __tstate = wxPyBeginAllowThreads();
7066 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7067
7068 wxPyEndAllowThreads(__tstate);
7069 if (PyErr_Occurred()) SWIG_fail;
7070 }
7071 {
7072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7073 }
7074 return resultobj;
7075 fail:
7076 return NULL;
7077 }
7078
7079
7080 static PyObject *_wrap_GridTableBase_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
7081 PyObject *resultobj = NULL;
7082 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7083 int arg2 ;
7084 int arg3 ;
7085 wxString result;
7086 PyObject * obj0 = 0 ;
7087 PyObject * obj1 = 0 ;
7088 PyObject * obj2 = 0 ;
7089 char *kwnames[] = {
7090 (char *) "self",(char *) "row",(char *) "col", NULL
7091 };
7092
7093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7095 if (SWIG_arg_fail(1)) SWIG_fail;
7096 {
7097 arg2 = static_cast<int >(SWIG_As_int(obj1));
7098 if (SWIG_arg_fail(2)) SWIG_fail;
7099 }
7100 {
7101 arg3 = static_cast<int >(SWIG_As_int(obj2));
7102 if (SWIG_arg_fail(3)) SWIG_fail;
7103 }
7104 {
7105 PyThreadState* __tstate = wxPyBeginAllowThreads();
7106 result = (arg1)->GetValue(arg2,arg3);
7107
7108 wxPyEndAllowThreads(__tstate);
7109 if (PyErr_Occurred()) SWIG_fail;
7110 }
7111 {
7112 #if wxUSE_UNICODE
7113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7114 #else
7115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7116 #endif
7117 }
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 static PyObject *_wrap_GridTableBase_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
7125 PyObject *resultobj = NULL;
7126 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7127 int arg2 ;
7128 int arg3 ;
7129 wxString *arg4 = 0 ;
7130 bool temp4 = false ;
7131 PyObject * obj0 = 0 ;
7132 PyObject * obj1 = 0 ;
7133 PyObject * obj2 = 0 ;
7134 PyObject * obj3 = 0 ;
7135 char *kwnames[] = {
7136 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7137 };
7138
7139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7141 if (SWIG_arg_fail(1)) SWIG_fail;
7142 {
7143 arg2 = static_cast<int >(SWIG_As_int(obj1));
7144 if (SWIG_arg_fail(2)) SWIG_fail;
7145 }
7146 {
7147 arg3 = static_cast<int >(SWIG_As_int(obj2));
7148 if (SWIG_arg_fail(3)) SWIG_fail;
7149 }
7150 {
7151 arg4 = wxString_in_helper(obj3);
7152 if (arg4 == NULL) SWIG_fail;
7153 temp4 = true;
7154 }
7155 {
7156 PyThreadState* __tstate = wxPyBeginAllowThreads();
7157 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
7158
7159 wxPyEndAllowThreads(__tstate);
7160 if (PyErr_Occurred()) SWIG_fail;
7161 }
7162 Py_INCREF(Py_None); resultobj = Py_None;
7163 {
7164 if (temp4)
7165 delete arg4;
7166 }
7167 return resultobj;
7168 fail:
7169 {
7170 if (temp4)
7171 delete arg4;
7172 }
7173 return NULL;
7174 }
7175
7176
7177 static PyObject *_wrap_GridTableBase_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
7178 PyObject *resultobj = NULL;
7179 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7180 int arg2 ;
7181 int arg3 ;
7182 wxString result;
7183 PyObject * obj0 = 0 ;
7184 PyObject * obj1 = 0 ;
7185 PyObject * obj2 = 0 ;
7186 char *kwnames[] = {
7187 (char *) "self",(char *) "row",(char *) "col", NULL
7188 };
7189
7190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
7191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7192 if (SWIG_arg_fail(1)) SWIG_fail;
7193 {
7194 arg2 = static_cast<int >(SWIG_As_int(obj1));
7195 if (SWIG_arg_fail(2)) SWIG_fail;
7196 }
7197 {
7198 arg3 = static_cast<int >(SWIG_As_int(obj2));
7199 if (SWIG_arg_fail(3)) SWIG_fail;
7200 }
7201 {
7202 PyThreadState* __tstate = wxPyBeginAllowThreads();
7203 result = (arg1)->GetTypeName(arg2,arg3);
7204
7205 wxPyEndAllowThreads(__tstate);
7206 if (PyErr_Occurred()) SWIG_fail;
7207 }
7208 {
7209 #if wxUSE_UNICODE
7210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7211 #else
7212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7213 #endif
7214 }
7215 return resultobj;
7216 fail:
7217 return NULL;
7218 }
7219
7220
7221 static PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj = NULL;
7223 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7224 int arg2 ;
7225 int arg3 ;
7226 wxString *arg4 = 0 ;
7227 bool result;
7228 bool temp4 = false ;
7229 PyObject * obj0 = 0 ;
7230 PyObject * obj1 = 0 ;
7231 PyObject * obj2 = 0 ;
7232 PyObject * obj3 = 0 ;
7233 char *kwnames[] = {
7234 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7235 };
7236
7237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7239 if (SWIG_arg_fail(1)) SWIG_fail;
7240 {
7241 arg2 = static_cast<int >(SWIG_As_int(obj1));
7242 if (SWIG_arg_fail(2)) SWIG_fail;
7243 }
7244 {
7245 arg3 = static_cast<int >(SWIG_As_int(obj2));
7246 if (SWIG_arg_fail(3)) SWIG_fail;
7247 }
7248 {
7249 arg4 = wxString_in_helper(obj3);
7250 if (arg4 == NULL) SWIG_fail;
7251 temp4 = true;
7252 }
7253 {
7254 PyThreadState* __tstate = wxPyBeginAllowThreads();
7255 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
7256
7257 wxPyEndAllowThreads(__tstate);
7258 if (PyErr_Occurred()) SWIG_fail;
7259 }
7260 {
7261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7262 }
7263 {
7264 if (temp4)
7265 delete arg4;
7266 }
7267 return resultobj;
7268 fail:
7269 {
7270 if (temp4)
7271 delete arg4;
7272 }
7273 return NULL;
7274 }
7275
7276
7277 static PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj = NULL;
7279 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7280 int arg2 ;
7281 int arg3 ;
7282 wxString *arg4 = 0 ;
7283 bool result;
7284 bool temp4 = false ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 PyObject * obj2 = 0 ;
7288 PyObject * obj3 = 0 ;
7289 char *kwnames[] = {
7290 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
7291 };
7292
7293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7295 if (SWIG_arg_fail(1)) SWIG_fail;
7296 {
7297 arg2 = static_cast<int >(SWIG_As_int(obj1));
7298 if (SWIG_arg_fail(2)) SWIG_fail;
7299 }
7300 {
7301 arg3 = static_cast<int >(SWIG_As_int(obj2));
7302 if (SWIG_arg_fail(3)) SWIG_fail;
7303 }
7304 {
7305 arg4 = wxString_in_helper(obj3);
7306 if (arg4 == NULL) SWIG_fail;
7307 temp4 = true;
7308 }
7309 {
7310 PyThreadState* __tstate = wxPyBeginAllowThreads();
7311 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
7312
7313 wxPyEndAllowThreads(__tstate);
7314 if (PyErr_Occurred()) SWIG_fail;
7315 }
7316 {
7317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7318 }
7319 {
7320 if (temp4)
7321 delete arg4;
7322 }
7323 return resultobj;
7324 fail:
7325 {
7326 if (temp4)
7327 delete arg4;
7328 }
7329 return NULL;
7330 }
7331
7332
7333 static PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7334 PyObject *resultobj = NULL;
7335 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7336 int arg2 ;
7337 int arg3 ;
7338 long result;
7339 PyObject * obj0 = 0 ;
7340 PyObject * obj1 = 0 ;
7341 PyObject * obj2 = 0 ;
7342 char *kwnames[] = {
7343 (char *) "self",(char *) "row",(char *) "col", NULL
7344 };
7345
7346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) goto fail;
7347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7348 if (SWIG_arg_fail(1)) SWIG_fail;
7349 {
7350 arg2 = static_cast<int >(SWIG_As_int(obj1));
7351 if (SWIG_arg_fail(2)) SWIG_fail;
7352 }
7353 {
7354 arg3 = static_cast<int >(SWIG_As_int(obj2));
7355 if (SWIG_arg_fail(3)) SWIG_fail;
7356 }
7357 {
7358 PyThreadState* __tstate = wxPyBeginAllowThreads();
7359 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
7360
7361 wxPyEndAllowThreads(__tstate);
7362 if (PyErr_Occurred()) SWIG_fail;
7363 }
7364 {
7365 resultobj = SWIG_From_long(static_cast<long >(result));
7366 }
7367 return resultobj;
7368 fail:
7369 return NULL;
7370 }
7371
7372
7373 static PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7374 PyObject *resultobj = NULL;
7375 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7376 int arg2 ;
7377 int arg3 ;
7378 double result;
7379 PyObject * obj0 = 0 ;
7380 PyObject * obj1 = 0 ;
7381 PyObject * obj2 = 0 ;
7382 char *kwnames[] = {
7383 (char *) "self",(char *) "row",(char *) "col", NULL
7384 };
7385
7386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) goto fail;
7387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7388 if (SWIG_arg_fail(1)) SWIG_fail;
7389 {
7390 arg2 = static_cast<int >(SWIG_As_int(obj1));
7391 if (SWIG_arg_fail(2)) SWIG_fail;
7392 }
7393 {
7394 arg3 = static_cast<int >(SWIG_As_int(obj2));
7395 if (SWIG_arg_fail(3)) SWIG_fail;
7396 }
7397 {
7398 PyThreadState* __tstate = wxPyBeginAllowThreads();
7399 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
7400
7401 wxPyEndAllowThreads(__tstate);
7402 if (PyErr_Occurred()) SWIG_fail;
7403 }
7404 {
7405 resultobj = SWIG_From_double(static_cast<double >(result));
7406 }
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 static PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj = NULL;
7415 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7416 int arg2 ;
7417 int arg3 ;
7418 bool result;
7419 PyObject * obj0 = 0 ;
7420 PyObject * obj1 = 0 ;
7421 PyObject * obj2 = 0 ;
7422 char *kwnames[] = {
7423 (char *) "self",(char *) "row",(char *) "col", NULL
7424 };
7425
7426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
7427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7428 if (SWIG_arg_fail(1)) SWIG_fail;
7429 {
7430 arg2 = static_cast<int >(SWIG_As_int(obj1));
7431 if (SWIG_arg_fail(2)) SWIG_fail;
7432 }
7433 {
7434 arg3 = static_cast<int >(SWIG_As_int(obj2));
7435 if (SWIG_arg_fail(3)) SWIG_fail;
7436 }
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
7440
7441 wxPyEndAllowThreads(__tstate);
7442 if (PyErr_Occurred()) SWIG_fail;
7443 }
7444 {
7445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7446 }
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj = NULL;
7455 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7456 int arg2 ;
7457 int arg3 ;
7458 long arg4 ;
7459 PyObject * obj0 = 0 ;
7460 PyObject * obj1 = 0 ;
7461 PyObject * obj2 = 0 ;
7462 PyObject * obj3 = 0 ;
7463 char *kwnames[] = {
7464 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7465 };
7466
7467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7469 if (SWIG_arg_fail(1)) SWIG_fail;
7470 {
7471 arg2 = static_cast<int >(SWIG_As_int(obj1));
7472 if (SWIG_arg_fail(2)) SWIG_fail;
7473 }
7474 {
7475 arg3 = static_cast<int >(SWIG_As_int(obj2));
7476 if (SWIG_arg_fail(3)) SWIG_fail;
7477 }
7478 {
7479 arg4 = static_cast<long >(SWIG_As_long(obj3));
7480 if (SWIG_arg_fail(4)) SWIG_fail;
7481 }
7482 {
7483 PyThreadState* __tstate = wxPyBeginAllowThreads();
7484 (arg1)->SetValueAsLong(arg2,arg3,arg4);
7485
7486 wxPyEndAllowThreads(__tstate);
7487 if (PyErr_Occurred()) SWIG_fail;
7488 }
7489 Py_INCREF(Py_None); resultobj = Py_None;
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 static PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *, PyObject *args, PyObject *kwargs) {
7497 PyObject *resultobj = NULL;
7498 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7499 int arg2 ;
7500 int arg3 ;
7501 double arg4 ;
7502 PyObject * obj0 = 0 ;
7503 PyObject * obj1 = 0 ;
7504 PyObject * obj2 = 0 ;
7505 PyObject * obj3 = 0 ;
7506 char *kwnames[] = {
7507 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7508 };
7509
7510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(1)) SWIG_fail;
7513 {
7514 arg2 = static_cast<int >(SWIG_As_int(obj1));
7515 if (SWIG_arg_fail(2)) SWIG_fail;
7516 }
7517 {
7518 arg3 = static_cast<int >(SWIG_As_int(obj2));
7519 if (SWIG_arg_fail(3)) SWIG_fail;
7520 }
7521 {
7522 arg4 = static_cast<double >(SWIG_As_double(obj3));
7523 if (SWIG_arg_fail(4)) SWIG_fail;
7524 }
7525 {
7526 PyThreadState* __tstate = wxPyBeginAllowThreads();
7527 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
7528
7529 wxPyEndAllowThreads(__tstate);
7530 if (PyErr_Occurred()) SWIG_fail;
7531 }
7532 Py_INCREF(Py_None); resultobj = Py_None;
7533 return resultobj;
7534 fail:
7535 return NULL;
7536 }
7537
7538
7539 static PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *, PyObject *args, PyObject *kwargs) {
7540 PyObject *resultobj = NULL;
7541 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7542 int arg2 ;
7543 int arg3 ;
7544 bool arg4 ;
7545 PyObject * obj0 = 0 ;
7546 PyObject * obj1 = 0 ;
7547 PyObject * obj2 = 0 ;
7548 PyObject * obj3 = 0 ;
7549 char *kwnames[] = {
7550 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7551 };
7552
7553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7555 if (SWIG_arg_fail(1)) SWIG_fail;
7556 {
7557 arg2 = static_cast<int >(SWIG_As_int(obj1));
7558 if (SWIG_arg_fail(2)) SWIG_fail;
7559 }
7560 {
7561 arg3 = static_cast<int >(SWIG_As_int(obj2));
7562 if (SWIG_arg_fail(3)) SWIG_fail;
7563 }
7564 {
7565 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
7566 if (SWIG_arg_fail(4)) SWIG_fail;
7567 }
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 (arg1)->SetValueAsBool(arg2,arg3,arg4);
7571
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 Py_INCREF(Py_None); resultobj = Py_None;
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 static PyObject *_wrap_GridTableBase_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj = NULL;
7584 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7585 PyObject * obj0 = 0 ;
7586 char *kwnames[] = {
7587 (char *) "self", NULL
7588 };
7589
7590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_Clear",kwnames,&obj0)) goto fail;
7591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7592 if (SWIG_arg_fail(1)) SWIG_fail;
7593 {
7594 PyThreadState* __tstate = wxPyBeginAllowThreads();
7595 (arg1)->Clear();
7596
7597 wxPyEndAllowThreads(__tstate);
7598 if (PyErr_Occurred()) SWIG_fail;
7599 }
7600 Py_INCREF(Py_None); resultobj = Py_None;
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 static PyObject *_wrap_GridTableBase_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
7608 PyObject *resultobj = NULL;
7609 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7610 size_t arg2 = (size_t) 0 ;
7611 size_t arg3 = (size_t) 1 ;
7612 bool result;
7613 PyObject * obj0 = 0 ;
7614 PyObject * obj1 = 0 ;
7615 PyObject * obj2 = 0 ;
7616 char *kwnames[] = {
7617 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7618 };
7619
7620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7622 if (SWIG_arg_fail(1)) SWIG_fail;
7623 if (obj1) {
7624 {
7625 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7626 if (SWIG_arg_fail(2)) SWIG_fail;
7627 }
7628 }
7629 if (obj2) {
7630 {
7631 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
7632 if (SWIG_arg_fail(3)) SWIG_fail;
7633 }
7634 }
7635 {
7636 PyThreadState* __tstate = wxPyBeginAllowThreads();
7637 result = (bool)(arg1)->InsertRows(arg2,arg3);
7638
7639 wxPyEndAllowThreads(__tstate);
7640 if (PyErr_Occurred()) SWIG_fail;
7641 }
7642 {
7643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7644 }
7645 return resultobj;
7646 fail:
7647 return NULL;
7648 }
7649
7650
7651 static PyObject *_wrap_GridTableBase_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
7652 PyObject *resultobj = NULL;
7653 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7654 size_t arg2 = (size_t) 1 ;
7655 bool result;
7656 PyObject * obj0 = 0 ;
7657 PyObject * obj1 = 0 ;
7658 char *kwnames[] = {
7659 (char *) "self",(char *) "numRows", NULL
7660 };
7661
7662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) goto fail;
7663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7664 if (SWIG_arg_fail(1)) SWIG_fail;
7665 if (obj1) {
7666 {
7667 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7668 if (SWIG_arg_fail(2)) SWIG_fail;
7669 }
7670 }
7671 {
7672 PyThreadState* __tstate = wxPyBeginAllowThreads();
7673 result = (bool)(arg1)->AppendRows(arg2);
7674
7675 wxPyEndAllowThreads(__tstate);
7676 if (PyErr_Occurred()) SWIG_fail;
7677 }
7678 {
7679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7680 }
7681 return resultobj;
7682 fail:
7683 return NULL;
7684 }
7685
7686
7687 static PyObject *_wrap_GridTableBase_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
7688 PyObject *resultobj = NULL;
7689 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7690 size_t arg2 = (size_t) 0 ;
7691 size_t arg3 = (size_t) 1 ;
7692 bool result;
7693 PyObject * obj0 = 0 ;
7694 PyObject * obj1 = 0 ;
7695 PyObject * obj2 = 0 ;
7696 char *kwnames[] = {
7697 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7698 };
7699
7700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
7701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7702 if (SWIG_arg_fail(1)) SWIG_fail;
7703 if (obj1) {
7704 {
7705 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7706 if (SWIG_arg_fail(2)) SWIG_fail;
7707 }
7708 }
7709 if (obj2) {
7710 {
7711 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
7712 if (SWIG_arg_fail(3)) SWIG_fail;
7713 }
7714 }
7715 {
7716 PyThreadState* __tstate = wxPyBeginAllowThreads();
7717 result = (bool)(arg1)->DeleteRows(arg2,arg3);
7718
7719 wxPyEndAllowThreads(__tstate);
7720 if (PyErr_Occurred()) SWIG_fail;
7721 }
7722 {
7723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7724 }
7725 return resultobj;
7726 fail:
7727 return NULL;
7728 }
7729
7730
7731 static PyObject *_wrap_GridTableBase_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
7732 PyObject *resultobj = NULL;
7733 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7734 size_t arg2 = (size_t) 0 ;
7735 size_t arg3 = (size_t) 1 ;
7736 bool result;
7737 PyObject * obj0 = 0 ;
7738 PyObject * obj1 = 0 ;
7739 PyObject * obj2 = 0 ;
7740 char *kwnames[] = {
7741 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7742 };
7743
7744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7746 if (SWIG_arg_fail(1)) SWIG_fail;
7747 if (obj1) {
7748 {
7749 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7750 if (SWIG_arg_fail(2)) SWIG_fail;
7751 }
7752 }
7753 if (obj2) {
7754 {
7755 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
7756 if (SWIG_arg_fail(3)) SWIG_fail;
7757 }
7758 }
7759 {
7760 PyThreadState* __tstate = wxPyBeginAllowThreads();
7761 result = (bool)(arg1)->InsertCols(arg2,arg3);
7762
7763 wxPyEndAllowThreads(__tstate);
7764 if (PyErr_Occurred()) SWIG_fail;
7765 }
7766 {
7767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7768 }
7769 return resultobj;
7770 fail:
7771 return NULL;
7772 }
7773
7774
7775 static PyObject *_wrap_GridTableBase_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
7776 PyObject *resultobj = NULL;
7777 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7778 size_t arg2 = (size_t) 1 ;
7779 bool result;
7780 PyObject * obj0 = 0 ;
7781 PyObject * obj1 = 0 ;
7782 char *kwnames[] = {
7783 (char *) "self",(char *) "numCols", NULL
7784 };
7785
7786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) goto fail;
7787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7788 if (SWIG_arg_fail(1)) SWIG_fail;
7789 if (obj1) {
7790 {
7791 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7792 if (SWIG_arg_fail(2)) SWIG_fail;
7793 }
7794 }
7795 {
7796 PyThreadState* __tstate = wxPyBeginAllowThreads();
7797 result = (bool)(arg1)->AppendCols(arg2);
7798
7799 wxPyEndAllowThreads(__tstate);
7800 if (PyErr_Occurred()) SWIG_fail;
7801 }
7802 {
7803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7804 }
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 static PyObject *_wrap_GridTableBase_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj = NULL;
7813 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7814 size_t arg2 = (size_t) 0 ;
7815 size_t arg3 = (size_t) 1 ;
7816 bool result;
7817 PyObject * obj0 = 0 ;
7818 PyObject * obj1 = 0 ;
7819 PyObject * obj2 = 0 ;
7820 char *kwnames[] = {
7821 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7822 };
7823
7824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
7825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7826 if (SWIG_arg_fail(1)) SWIG_fail;
7827 if (obj1) {
7828 {
7829 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
7830 if (SWIG_arg_fail(2)) SWIG_fail;
7831 }
7832 }
7833 if (obj2) {
7834 {
7835 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
7836 if (SWIG_arg_fail(3)) SWIG_fail;
7837 }
7838 }
7839 {
7840 PyThreadState* __tstate = wxPyBeginAllowThreads();
7841 result = (bool)(arg1)->DeleteCols(arg2,arg3);
7842
7843 wxPyEndAllowThreads(__tstate);
7844 if (PyErr_Occurred()) SWIG_fail;
7845 }
7846 {
7847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7848 }
7849 return resultobj;
7850 fail:
7851 return NULL;
7852 }
7853
7854
7855 static PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7856 PyObject *resultobj = NULL;
7857 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7858 int arg2 ;
7859 wxString result;
7860 PyObject * obj0 = 0 ;
7861 PyObject * obj1 = 0 ;
7862 char *kwnames[] = {
7863 (char *) "self",(char *) "row", NULL
7864 };
7865
7866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
7867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7868 if (SWIG_arg_fail(1)) SWIG_fail;
7869 {
7870 arg2 = static_cast<int >(SWIG_As_int(obj1));
7871 if (SWIG_arg_fail(2)) SWIG_fail;
7872 }
7873 {
7874 PyThreadState* __tstate = wxPyBeginAllowThreads();
7875 result = (arg1)->GetRowLabelValue(arg2);
7876
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 {
7881 #if wxUSE_UNICODE
7882 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7883 #else
7884 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7885 #endif
7886 }
7887 return resultobj;
7888 fail:
7889 return NULL;
7890 }
7891
7892
7893 static PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7894 PyObject *resultobj = NULL;
7895 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7896 int arg2 ;
7897 wxString result;
7898 PyObject * obj0 = 0 ;
7899 PyObject * obj1 = 0 ;
7900 char *kwnames[] = {
7901 (char *) "self",(char *) "col", NULL
7902 };
7903
7904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
7905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7906 if (SWIG_arg_fail(1)) SWIG_fail;
7907 {
7908 arg2 = static_cast<int >(SWIG_As_int(obj1));
7909 if (SWIG_arg_fail(2)) SWIG_fail;
7910 }
7911 {
7912 PyThreadState* __tstate = wxPyBeginAllowThreads();
7913 result = (arg1)->GetColLabelValue(arg2);
7914
7915 wxPyEndAllowThreads(__tstate);
7916 if (PyErr_Occurred()) SWIG_fail;
7917 }
7918 {
7919 #if wxUSE_UNICODE
7920 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7921 #else
7922 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7923 #endif
7924 }
7925 return resultobj;
7926 fail:
7927 return NULL;
7928 }
7929
7930
7931 static PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7932 PyObject *resultobj = NULL;
7933 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7934 int arg2 ;
7935 wxString *arg3 = 0 ;
7936 bool temp3 = false ;
7937 PyObject * obj0 = 0 ;
7938 PyObject * obj1 = 0 ;
7939 PyObject * obj2 = 0 ;
7940 char *kwnames[] = {
7941 (char *) "self",(char *) "row",(char *) "value", NULL
7942 };
7943
7944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7946 if (SWIG_arg_fail(1)) SWIG_fail;
7947 {
7948 arg2 = static_cast<int >(SWIG_As_int(obj1));
7949 if (SWIG_arg_fail(2)) SWIG_fail;
7950 }
7951 {
7952 arg3 = wxString_in_helper(obj2);
7953 if (arg3 == NULL) SWIG_fail;
7954 temp3 = true;
7955 }
7956 {
7957 PyThreadState* __tstate = wxPyBeginAllowThreads();
7958 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
7959
7960 wxPyEndAllowThreads(__tstate);
7961 if (PyErr_Occurred()) SWIG_fail;
7962 }
7963 Py_INCREF(Py_None); resultobj = Py_None;
7964 {
7965 if (temp3)
7966 delete arg3;
7967 }
7968 return resultobj;
7969 fail:
7970 {
7971 if (temp3)
7972 delete arg3;
7973 }
7974 return NULL;
7975 }
7976
7977
7978 static PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
7979 PyObject *resultobj = NULL;
7980 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7981 int arg2 ;
7982 wxString *arg3 = 0 ;
7983 bool temp3 = false ;
7984 PyObject * obj0 = 0 ;
7985 PyObject * obj1 = 0 ;
7986 PyObject * obj2 = 0 ;
7987 char *kwnames[] = {
7988 (char *) "self",(char *) "col",(char *) "value", NULL
7989 };
7990
7991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
7992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
7993 if (SWIG_arg_fail(1)) SWIG_fail;
7994 {
7995 arg2 = static_cast<int >(SWIG_As_int(obj1));
7996 if (SWIG_arg_fail(2)) SWIG_fail;
7997 }
7998 {
7999 arg3 = wxString_in_helper(obj2);
8000 if (arg3 == NULL) SWIG_fail;
8001 temp3 = true;
8002 }
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
8006
8007 wxPyEndAllowThreads(__tstate);
8008 if (PyErr_Occurred()) SWIG_fail;
8009 }
8010 Py_INCREF(Py_None); resultobj = Py_None;
8011 {
8012 if (temp3)
8013 delete arg3;
8014 }
8015 return resultobj;
8016 fail:
8017 {
8018 if (temp3)
8019 delete arg3;
8020 }
8021 return NULL;
8022 }
8023
8024
8025 static PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8026 PyObject *resultobj = NULL;
8027 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8028 bool result;
8029 PyObject * obj0 = 0 ;
8030 char *kwnames[] = {
8031 (char *) "self", NULL
8032 };
8033
8034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableBase_CanHaveAttributes",kwnames,&obj0)) goto fail;
8035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8036 if (SWIG_arg_fail(1)) SWIG_fail;
8037 {
8038 PyThreadState* __tstate = wxPyBeginAllowThreads();
8039 result = (bool)(arg1)->CanHaveAttributes();
8040
8041 wxPyEndAllowThreads(__tstate);
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 {
8045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8046 }
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 static PyObject *_wrap_GridTableBase_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8054 PyObject *resultobj = NULL;
8055 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8056 int arg2 ;
8057 int arg3 ;
8058 wxGridCellAttr::wxAttrKind arg4 ;
8059 wxGridCellAttr *result;
8060 PyObject * obj0 = 0 ;
8061 PyObject * obj1 = 0 ;
8062 PyObject * obj2 = 0 ;
8063 PyObject * obj3 = 0 ;
8064 char *kwnames[] = {
8065 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
8066 };
8067
8068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8070 if (SWIG_arg_fail(1)) SWIG_fail;
8071 {
8072 arg2 = static_cast<int >(SWIG_As_int(obj1));
8073 if (SWIG_arg_fail(2)) SWIG_fail;
8074 }
8075 {
8076 arg3 = static_cast<int >(SWIG_As_int(obj2));
8077 if (SWIG_arg_fail(3)) SWIG_fail;
8078 }
8079 {
8080 arg4 = static_cast<wxGridCellAttr::wxAttrKind >(SWIG_As_int(obj3));
8081 if (SWIG_arg_fail(4)) SWIG_fail;
8082 }
8083 {
8084 PyThreadState* __tstate = wxPyBeginAllowThreads();
8085 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
8086
8087 wxPyEndAllowThreads(__tstate);
8088 if (PyErr_Occurred()) SWIG_fail;
8089 }
8090 {
8091 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
8092 }
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 static PyObject *_wrap_GridTableBase_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8100 PyObject *resultobj = NULL;
8101 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8102 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8103 int arg3 ;
8104 int arg4 ;
8105 PyObject * obj0 = 0 ;
8106 PyObject * obj1 = 0 ;
8107 PyObject * obj2 = 0 ;
8108 PyObject * obj3 = 0 ;
8109 char *kwnames[] = {
8110 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
8111 };
8112
8113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8115 if (SWIG_arg_fail(1)) SWIG_fail;
8116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8117 if (SWIG_arg_fail(2)) SWIG_fail;
8118 {
8119 arg3 = static_cast<int >(SWIG_As_int(obj2));
8120 if (SWIG_arg_fail(3)) SWIG_fail;
8121 }
8122 {
8123 arg4 = static_cast<int >(SWIG_As_int(obj3));
8124 if (SWIG_arg_fail(4)) SWIG_fail;
8125 }
8126 {
8127 PyThreadState* __tstate = wxPyBeginAllowThreads();
8128 (arg1)->SetAttr(arg2,arg3,arg4);
8129
8130 wxPyEndAllowThreads(__tstate);
8131 if (PyErr_Occurred()) SWIG_fail;
8132 }
8133 Py_INCREF(Py_None); resultobj = Py_None;
8134 return resultobj;
8135 fail:
8136 return NULL;
8137 }
8138
8139
8140 static PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8141 PyObject *resultobj = NULL;
8142 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8143 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8144 int arg3 ;
8145 PyObject * obj0 = 0 ;
8146 PyObject * obj1 = 0 ;
8147 PyObject * obj2 = 0 ;
8148 char *kwnames[] = {
8149 (char *) "self",(char *) "attr",(char *) "row", NULL
8150 };
8151
8152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8154 if (SWIG_arg_fail(1)) SWIG_fail;
8155 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8156 if (SWIG_arg_fail(2)) SWIG_fail;
8157 {
8158 arg3 = static_cast<int >(SWIG_As_int(obj2));
8159 if (SWIG_arg_fail(3)) SWIG_fail;
8160 }
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 (arg1)->SetRowAttr(arg2,arg3);
8164
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 Py_INCREF(Py_None); resultobj = Py_None;
8169 return resultobj;
8170 fail:
8171 return NULL;
8172 }
8173
8174
8175 static PyObject *_wrap_GridTableBase_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8176 PyObject *resultobj = NULL;
8177 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8178 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8179 int arg3 ;
8180 PyObject * obj0 = 0 ;
8181 PyObject * obj1 = 0 ;
8182 PyObject * obj2 = 0 ;
8183 char *kwnames[] = {
8184 (char *) "self",(char *) "attr",(char *) "col", NULL
8185 };
8186
8187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
8188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8189 if (SWIG_arg_fail(1)) SWIG_fail;
8190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8191 if (SWIG_arg_fail(2)) SWIG_fail;
8192 {
8193 arg3 = static_cast<int >(SWIG_As_int(obj2));
8194 if (SWIG_arg_fail(3)) SWIG_fail;
8195 }
8196 {
8197 PyThreadState* __tstate = wxPyBeginAllowThreads();
8198 (arg1)->SetColAttr(arg2,arg3);
8199
8200 wxPyEndAllowThreads(__tstate);
8201 if (PyErr_Occurred()) SWIG_fail;
8202 }
8203 Py_INCREF(Py_None); resultobj = Py_None;
8204 return resultobj;
8205 fail:
8206 return NULL;
8207 }
8208
8209
8210 static PyObject * GridTableBase_swigregister(PyObject *, PyObject *args) {
8211 PyObject *obj;
8212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8213 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableBase, obj);
8214 Py_INCREF(obj);
8215 return Py_BuildValue((char *)"");
8216 }
8217 static PyObject *_wrap_new_PyGridTableBase(PyObject *, PyObject *args, PyObject *kwargs) {
8218 PyObject *resultobj = NULL;
8219 wxPyGridTableBase *result;
8220 char *kwnames[] = {
8221 NULL
8222 };
8223
8224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyGridTableBase",kwnames)) goto fail;
8225 {
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 result = (wxPyGridTableBase *)new wxPyGridTableBase();
8228
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyGridTableBase, 1);
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 static PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj = NULL;
8241 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8242 PyObject *arg2 = (PyObject *) 0 ;
8243 PyObject *arg3 = (PyObject *) 0 ;
8244 PyObject * obj0 = 0 ;
8245 PyObject * obj1 = 0 ;
8246 PyObject * obj2 = 0 ;
8247 char *kwnames[] = {
8248 (char *) "self",(char *) "self",(char *) "_class", NULL
8249 };
8250
8251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8253 if (SWIG_arg_fail(1)) SWIG_fail;
8254 arg2 = obj1;
8255 arg3 = obj2;
8256 {
8257 PyThreadState* __tstate = wxPyBeginAllowThreads();
8258 (arg1)->_setCallbackInfo(arg2,arg3);
8259
8260 wxPyEndAllowThreads(__tstate);
8261 if (PyErr_Occurred()) SWIG_fail;
8262 }
8263 Py_INCREF(Py_None); resultobj = Py_None;
8264 return resultobj;
8265 fail:
8266 return NULL;
8267 }
8268
8269
8270 static PyObject *_wrap_PyGridTableBase_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
8271 PyObject *resultobj = NULL;
8272 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8273 PyObject * obj0 = 0 ;
8274 char *kwnames[] = {
8275 (char *) "self", NULL
8276 };
8277
8278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_Destroy",kwnames,&obj0)) goto fail;
8279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8280 if (SWIG_arg_fail(1)) SWIG_fail;
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 wxPyGridTableBase_Destroy(arg1);
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 Py_INCREF(Py_None); resultobj = Py_None;
8289 return resultobj;
8290 fail:
8291 return NULL;
8292 }
8293
8294
8295 static PyObject *_wrap_PyGridTableBase_base_GetTypeName(PyObject *, PyObject *args, PyObject *kwargs) {
8296 PyObject *resultobj = NULL;
8297 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8298 int arg2 ;
8299 int arg3 ;
8300 wxString result;
8301 PyObject * obj0 = 0 ;
8302 PyObject * obj1 = 0 ;
8303 PyObject * obj2 = 0 ;
8304 char *kwnames[] = {
8305 (char *) "self",(char *) "row",(char *) "col", NULL
8306 };
8307
8308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_GetTypeName",kwnames,&obj0,&obj1,&obj2)) goto fail;
8309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8310 if (SWIG_arg_fail(1)) SWIG_fail;
8311 {
8312 arg2 = static_cast<int >(SWIG_As_int(obj1));
8313 if (SWIG_arg_fail(2)) SWIG_fail;
8314 }
8315 {
8316 arg3 = static_cast<int >(SWIG_As_int(obj2));
8317 if (SWIG_arg_fail(3)) SWIG_fail;
8318 }
8319 {
8320 PyThreadState* __tstate = wxPyBeginAllowThreads();
8321 result = (arg1)->base_GetTypeName(arg2,arg3);
8322
8323 wxPyEndAllowThreads(__tstate);
8324 if (PyErr_Occurred()) SWIG_fail;
8325 }
8326 {
8327 #if wxUSE_UNICODE
8328 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8329 #else
8330 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8331 #endif
8332 }
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 static PyObject *_wrap_PyGridTableBase_base_CanGetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = NULL;
8341 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8342 int arg2 ;
8343 int arg3 ;
8344 wxString *arg4 = 0 ;
8345 bool result;
8346 bool temp4 = false ;
8347 PyObject * obj0 = 0 ;
8348 PyObject * obj1 = 0 ;
8349 PyObject * obj2 = 0 ;
8350 PyObject * obj3 = 0 ;
8351 char *kwnames[] = {
8352 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8353 };
8354
8355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8357 if (SWIG_arg_fail(1)) SWIG_fail;
8358 {
8359 arg2 = static_cast<int >(SWIG_As_int(obj1));
8360 if (SWIG_arg_fail(2)) SWIG_fail;
8361 }
8362 {
8363 arg3 = static_cast<int >(SWIG_As_int(obj2));
8364 if (SWIG_arg_fail(3)) SWIG_fail;
8365 }
8366 {
8367 arg4 = wxString_in_helper(obj3);
8368 if (arg4 == NULL) SWIG_fail;
8369 temp4 = true;
8370 }
8371 {
8372 PyThreadState* __tstate = wxPyBeginAllowThreads();
8373 result = (bool)(arg1)->base_CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8374
8375 wxPyEndAllowThreads(__tstate);
8376 if (PyErr_Occurred()) SWIG_fail;
8377 }
8378 {
8379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8380 }
8381 {
8382 if (temp4)
8383 delete arg4;
8384 }
8385 return resultobj;
8386 fail:
8387 {
8388 if (temp4)
8389 delete arg4;
8390 }
8391 return NULL;
8392 }
8393
8394
8395 static PyObject *_wrap_PyGridTableBase_base_CanSetValueAs(PyObject *, PyObject *args, PyObject *kwargs) {
8396 PyObject *resultobj = NULL;
8397 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8398 int arg2 ;
8399 int arg3 ;
8400 wxString *arg4 = 0 ;
8401 bool result;
8402 bool temp4 = false ;
8403 PyObject * obj0 = 0 ;
8404 PyObject * obj1 = 0 ;
8405 PyObject * obj2 = 0 ;
8406 PyObject * obj3 = 0 ;
8407 char *kwnames[] = {
8408 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8409 };
8410
8411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8413 if (SWIG_arg_fail(1)) SWIG_fail;
8414 {
8415 arg2 = static_cast<int >(SWIG_As_int(obj1));
8416 if (SWIG_arg_fail(2)) SWIG_fail;
8417 }
8418 {
8419 arg3 = static_cast<int >(SWIG_As_int(obj2));
8420 if (SWIG_arg_fail(3)) SWIG_fail;
8421 }
8422 {
8423 arg4 = wxString_in_helper(obj3);
8424 if (arg4 == NULL) SWIG_fail;
8425 temp4 = true;
8426 }
8427 {
8428 PyThreadState* __tstate = wxPyBeginAllowThreads();
8429 result = (bool)(arg1)->base_CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8430
8431 wxPyEndAllowThreads(__tstate);
8432 if (PyErr_Occurred()) SWIG_fail;
8433 }
8434 {
8435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8436 }
8437 {
8438 if (temp4)
8439 delete arg4;
8440 }
8441 return resultobj;
8442 fail:
8443 {
8444 if (temp4)
8445 delete arg4;
8446 }
8447 return NULL;
8448 }
8449
8450
8451 static PyObject *_wrap_PyGridTableBase_base_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
8452 PyObject *resultobj = NULL;
8453 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8454 PyObject * obj0 = 0 ;
8455 char *kwnames[] = {
8456 (char *) "self", NULL
8457 };
8458
8459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_base_Clear",kwnames,&obj0)) goto fail;
8460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8461 if (SWIG_arg_fail(1)) SWIG_fail;
8462 {
8463 PyThreadState* __tstate = wxPyBeginAllowThreads();
8464 (arg1)->base_Clear();
8465
8466 wxPyEndAllowThreads(__tstate);
8467 if (PyErr_Occurred()) SWIG_fail;
8468 }
8469 Py_INCREF(Py_None); resultobj = Py_None;
8470 return resultobj;
8471 fail:
8472 return NULL;
8473 }
8474
8475
8476 static PyObject *_wrap_PyGridTableBase_base_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
8477 PyObject *resultobj = NULL;
8478 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8479 size_t arg2 = (size_t) 0 ;
8480 size_t arg3 = (size_t) 1 ;
8481 bool result;
8482 PyObject * obj0 = 0 ;
8483 PyObject * obj1 = 0 ;
8484 PyObject * obj2 = 0 ;
8485 char *kwnames[] = {
8486 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8487 };
8488
8489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_InsertRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8491 if (SWIG_arg_fail(1)) SWIG_fail;
8492 if (obj1) {
8493 {
8494 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8495 if (SWIG_arg_fail(2)) SWIG_fail;
8496 }
8497 }
8498 if (obj2) {
8499 {
8500 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
8501 if (SWIG_arg_fail(3)) SWIG_fail;
8502 }
8503 }
8504 {
8505 PyThreadState* __tstate = wxPyBeginAllowThreads();
8506 result = (bool)(arg1)->base_InsertRows(arg2,arg3);
8507
8508 wxPyEndAllowThreads(__tstate);
8509 if (PyErr_Occurred()) SWIG_fail;
8510 }
8511 {
8512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8513 }
8514 return resultobj;
8515 fail:
8516 return NULL;
8517 }
8518
8519
8520 static PyObject *_wrap_PyGridTableBase_base_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
8521 PyObject *resultobj = NULL;
8522 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8523 size_t arg2 = (size_t) 1 ;
8524 bool result;
8525 PyObject * obj0 = 0 ;
8526 PyObject * obj1 = 0 ;
8527 char *kwnames[] = {
8528 (char *) "self",(char *) "numRows", NULL
8529 };
8530
8531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_base_AppendRows",kwnames,&obj0,&obj1)) goto fail;
8532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8533 if (SWIG_arg_fail(1)) SWIG_fail;
8534 if (obj1) {
8535 {
8536 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8537 if (SWIG_arg_fail(2)) SWIG_fail;
8538 }
8539 }
8540 {
8541 PyThreadState* __tstate = wxPyBeginAllowThreads();
8542 result = (bool)(arg1)->base_AppendRows(arg2);
8543
8544 wxPyEndAllowThreads(__tstate);
8545 if (PyErr_Occurred()) SWIG_fail;
8546 }
8547 {
8548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8549 }
8550 return resultobj;
8551 fail:
8552 return NULL;
8553 }
8554
8555
8556 static PyObject *_wrap_PyGridTableBase_base_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
8557 PyObject *resultobj = NULL;
8558 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8559 size_t arg2 = (size_t) 0 ;
8560 size_t arg3 = (size_t) 1 ;
8561 bool result;
8562 PyObject * obj0 = 0 ;
8563 PyObject * obj1 = 0 ;
8564 PyObject * obj2 = 0 ;
8565 char *kwnames[] = {
8566 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8567 };
8568
8569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_DeleteRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
8570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8571 if (SWIG_arg_fail(1)) SWIG_fail;
8572 if (obj1) {
8573 {
8574 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8575 if (SWIG_arg_fail(2)) SWIG_fail;
8576 }
8577 }
8578 if (obj2) {
8579 {
8580 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
8581 if (SWIG_arg_fail(3)) SWIG_fail;
8582 }
8583 }
8584 {
8585 PyThreadState* __tstate = wxPyBeginAllowThreads();
8586 result = (bool)(arg1)->base_DeleteRows(arg2,arg3);
8587
8588 wxPyEndAllowThreads(__tstate);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 {
8592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8593 }
8594 return resultobj;
8595 fail:
8596 return NULL;
8597 }
8598
8599
8600 static PyObject *_wrap_PyGridTableBase_base_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
8601 PyObject *resultobj = NULL;
8602 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8603 size_t arg2 = (size_t) 0 ;
8604 size_t arg3 = (size_t) 1 ;
8605 bool result;
8606 PyObject * obj0 = 0 ;
8607 PyObject * obj1 = 0 ;
8608 PyObject * obj2 = 0 ;
8609 char *kwnames[] = {
8610 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8611 };
8612
8613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_InsertCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8615 if (SWIG_arg_fail(1)) SWIG_fail;
8616 if (obj1) {
8617 {
8618 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8619 if (SWIG_arg_fail(2)) SWIG_fail;
8620 }
8621 }
8622 if (obj2) {
8623 {
8624 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
8625 if (SWIG_arg_fail(3)) SWIG_fail;
8626 }
8627 }
8628 {
8629 PyThreadState* __tstate = wxPyBeginAllowThreads();
8630 result = (bool)(arg1)->base_InsertCols(arg2,arg3);
8631
8632 wxPyEndAllowThreads(__tstate);
8633 if (PyErr_Occurred()) SWIG_fail;
8634 }
8635 {
8636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8637 }
8638 return resultobj;
8639 fail:
8640 return NULL;
8641 }
8642
8643
8644 static PyObject *_wrap_PyGridTableBase_base_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
8645 PyObject *resultobj = NULL;
8646 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8647 size_t arg2 = (size_t) 1 ;
8648 bool result;
8649 PyObject * obj0 = 0 ;
8650 PyObject * obj1 = 0 ;
8651 char *kwnames[] = {
8652 (char *) "self",(char *) "numCols", NULL
8653 };
8654
8655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyGridTableBase_base_AppendCols",kwnames,&obj0,&obj1)) goto fail;
8656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8657 if (SWIG_arg_fail(1)) SWIG_fail;
8658 if (obj1) {
8659 {
8660 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8661 if (SWIG_arg_fail(2)) SWIG_fail;
8662 }
8663 }
8664 {
8665 PyThreadState* __tstate = wxPyBeginAllowThreads();
8666 result = (bool)(arg1)->base_AppendCols(arg2);
8667
8668 wxPyEndAllowThreads(__tstate);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 {
8672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8673 }
8674 return resultobj;
8675 fail:
8676 return NULL;
8677 }
8678
8679
8680 static PyObject *_wrap_PyGridTableBase_base_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
8681 PyObject *resultobj = NULL;
8682 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8683 size_t arg2 = (size_t) 0 ;
8684 size_t arg3 = (size_t) 1 ;
8685 bool result;
8686 PyObject * obj0 = 0 ;
8687 PyObject * obj1 = 0 ;
8688 PyObject * obj2 = 0 ;
8689 char *kwnames[] = {
8690 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8691 };
8692
8693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:PyGridTableBase_base_DeleteCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
8694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8695 if (SWIG_arg_fail(1)) SWIG_fail;
8696 if (obj1) {
8697 {
8698 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8699 if (SWIG_arg_fail(2)) SWIG_fail;
8700 }
8701 }
8702 if (obj2) {
8703 {
8704 arg3 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj2));
8705 if (SWIG_arg_fail(3)) SWIG_fail;
8706 }
8707 }
8708 {
8709 PyThreadState* __tstate = wxPyBeginAllowThreads();
8710 result = (bool)(arg1)->base_DeleteCols(arg2,arg3);
8711
8712 wxPyEndAllowThreads(__tstate);
8713 if (PyErr_Occurred()) SWIG_fail;
8714 }
8715 {
8716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8717 }
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 static PyObject *_wrap_PyGridTableBase_base_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8725 PyObject *resultobj = NULL;
8726 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8727 int arg2 ;
8728 wxString result;
8729 PyObject * obj0 = 0 ;
8730 PyObject * obj1 = 0 ;
8731 char *kwnames[] = {
8732 (char *) "self",(char *) "row", NULL
8733 };
8734
8735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_base_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
8736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8737 if (SWIG_arg_fail(1)) SWIG_fail;
8738 {
8739 arg2 = static_cast<int >(SWIG_As_int(obj1));
8740 if (SWIG_arg_fail(2)) SWIG_fail;
8741 }
8742 {
8743 PyThreadState* __tstate = wxPyBeginAllowThreads();
8744 result = (arg1)->base_GetRowLabelValue(arg2);
8745
8746 wxPyEndAllowThreads(__tstate);
8747 if (PyErr_Occurred()) SWIG_fail;
8748 }
8749 {
8750 #if wxUSE_UNICODE
8751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8752 #else
8753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8754 #endif
8755 }
8756 return resultobj;
8757 fail:
8758 return NULL;
8759 }
8760
8761
8762 static PyObject *_wrap_PyGridTableBase_base_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8763 PyObject *resultobj = NULL;
8764 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8765 int arg2 ;
8766 wxString result;
8767 PyObject * obj0 = 0 ;
8768 PyObject * obj1 = 0 ;
8769 char *kwnames[] = {
8770 (char *) "self",(char *) "col", NULL
8771 };
8772
8773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridTableBase_base_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
8774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8775 if (SWIG_arg_fail(1)) SWIG_fail;
8776 {
8777 arg2 = static_cast<int >(SWIG_As_int(obj1));
8778 if (SWIG_arg_fail(2)) SWIG_fail;
8779 }
8780 {
8781 PyThreadState* __tstate = wxPyBeginAllowThreads();
8782 result = (arg1)->base_GetColLabelValue(arg2);
8783
8784 wxPyEndAllowThreads(__tstate);
8785 if (PyErr_Occurred()) SWIG_fail;
8786 }
8787 {
8788 #if wxUSE_UNICODE
8789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8790 #else
8791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8792 #endif
8793 }
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 static PyObject *_wrap_PyGridTableBase_base_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8801 PyObject *resultobj = NULL;
8802 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8803 int arg2 ;
8804 wxString *arg3 = 0 ;
8805 bool temp3 = false ;
8806 PyObject * obj0 = 0 ;
8807 PyObject * obj1 = 0 ;
8808 PyObject * obj2 = 0 ;
8809 char *kwnames[] = {
8810 (char *) "self",(char *) "row",(char *) "value", NULL
8811 };
8812
8813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8815 if (SWIG_arg_fail(1)) SWIG_fail;
8816 {
8817 arg2 = static_cast<int >(SWIG_As_int(obj1));
8818 if (SWIG_arg_fail(2)) SWIG_fail;
8819 }
8820 {
8821 arg3 = wxString_in_helper(obj2);
8822 if (arg3 == NULL) SWIG_fail;
8823 temp3 = true;
8824 }
8825 {
8826 PyThreadState* __tstate = wxPyBeginAllowThreads();
8827 (arg1)->base_SetRowLabelValue(arg2,(wxString const &)*arg3);
8828
8829 wxPyEndAllowThreads(__tstate);
8830 if (PyErr_Occurred()) SWIG_fail;
8831 }
8832 Py_INCREF(Py_None); resultobj = Py_None;
8833 {
8834 if (temp3)
8835 delete arg3;
8836 }
8837 return resultobj;
8838 fail:
8839 {
8840 if (temp3)
8841 delete arg3;
8842 }
8843 return NULL;
8844 }
8845
8846
8847 static PyObject *_wrap_PyGridTableBase_base_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
8848 PyObject *resultobj = NULL;
8849 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8850 int arg2 ;
8851 wxString *arg3 = 0 ;
8852 bool temp3 = false ;
8853 PyObject * obj0 = 0 ;
8854 PyObject * obj1 = 0 ;
8855 PyObject * obj2 = 0 ;
8856 char *kwnames[] = {
8857 (char *) "self",(char *) "col",(char *) "value", NULL
8858 };
8859
8860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
8861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8862 if (SWIG_arg_fail(1)) SWIG_fail;
8863 {
8864 arg2 = static_cast<int >(SWIG_As_int(obj1));
8865 if (SWIG_arg_fail(2)) SWIG_fail;
8866 }
8867 {
8868 arg3 = wxString_in_helper(obj2);
8869 if (arg3 == NULL) SWIG_fail;
8870 temp3 = true;
8871 }
8872 {
8873 PyThreadState* __tstate = wxPyBeginAllowThreads();
8874 (arg1)->base_SetColLabelValue(arg2,(wxString const &)*arg3);
8875
8876 wxPyEndAllowThreads(__tstate);
8877 if (PyErr_Occurred()) SWIG_fail;
8878 }
8879 Py_INCREF(Py_None); resultobj = Py_None;
8880 {
8881 if (temp3)
8882 delete arg3;
8883 }
8884 return resultobj;
8885 fail:
8886 {
8887 if (temp3)
8888 delete arg3;
8889 }
8890 return NULL;
8891 }
8892
8893
8894 static PyObject *_wrap_PyGridTableBase_base_CanHaveAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
8895 PyObject *resultobj = NULL;
8896 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8897 bool result;
8898 PyObject * obj0 = 0 ;
8899 char *kwnames[] = {
8900 (char *) "self", NULL
8901 };
8902
8903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyGridTableBase_base_CanHaveAttributes",kwnames,&obj0)) goto fail;
8904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8905 if (SWIG_arg_fail(1)) SWIG_fail;
8906 {
8907 PyThreadState* __tstate = wxPyBeginAllowThreads();
8908 result = (bool)(arg1)->base_CanHaveAttributes();
8909
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 {
8914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8915 }
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 static PyObject *_wrap_PyGridTableBase_base_GetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8923 PyObject *resultobj = NULL;
8924 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8925 int arg2 ;
8926 int arg3 ;
8927 wxGridCellAttr::wxAttrKind arg4 ;
8928 wxGridCellAttr *result;
8929 PyObject * obj0 = 0 ;
8930 PyObject * obj1 = 0 ;
8931 PyObject * obj2 = 0 ;
8932 PyObject * obj3 = 0 ;
8933 char *kwnames[] = {
8934 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
8935 };
8936
8937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8939 if (SWIG_arg_fail(1)) SWIG_fail;
8940 {
8941 arg2 = static_cast<int >(SWIG_As_int(obj1));
8942 if (SWIG_arg_fail(2)) SWIG_fail;
8943 }
8944 {
8945 arg3 = static_cast<int >(SWIG_As_int(obj2));
8946 if (SWIG_arg_fail(3)) SWIG_fail;
8947 }
8948 {
8949 arg4 = static_cast<wxGridCellAttr::wxAttrKind >(SWIG_As_int(obj3));
8950 if (SWIG_arg_fail(4)) SWIG_fail;
8951 }
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 result = (wxGridCellAttr *)(arg1)->base_GetAttr(arg2,arg3,arg4);
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 {
8960 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
8961 }
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 static PyObject *_wrap_PyGridTableBase_base_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj = NULL;
8970 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
8971 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
8972 int arg3 ;
8973 int arg4 ;
8974 PyObject * obj0 = 0 ;
8975 PyObject * obj1 = 0 ;
8976 PyObject * obj2 = 0 ;
8977 PyObject * obj3 = 0 ;
8978 char *kwnames[] = {
8979 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
8980 };
8981
8982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridTableBase_base_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
8984 if (SWIG_arg_fail(1)) SWIG_fail;
8985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
8986 if (SWIG_arg_fail(2)) SWIG_fail;
8987 {
8988 arg3 = static_cast<int >(SWIG_As_int(obj2));
8989 if (SWIG_arg_fail(3)) SWIG_fail;
8990 }
8991 {
8992 arg4 = static_cast<int >(SWIG_As_int(obj3));
8993 if (SWIG_arg_fail(4)) SWIG_fail;
8994 }
8995 {
8996 PyThreadState* __tstate = wxPyBeginAllowThreads();
8997 (arg1)->base_SetAttr(arg2,arg3,arg4);
8998
8999 wxPyEndAllowThreads(__tstate);
9000 if (PyErr_Occurred()) SWIG_fail;
9001 }
9002 Py_INCREF(Py_None); resultobj = Py_None;
9003 return resultobj;
9004 fail:
9005 return NULL;
9006 }
9007
9008
9009 static PyObject *_wrap_PyGridTableBase_base_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
9010 PyObject *resultobj = NULL;
9011 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9012 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9013 int arg3 ;
9014 PyObject * obj0 = 0 ;
9015 PyObject * obj1 = 0 ;
9016 PyObject * obj2 = 0 ;
9017 char *kwnames[] = {
9018 (char *) "self",(char *) "attr",(char *) "row", NULL
9019 };
9020
9021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
9022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
9023 if (SWIG_arg_fail(1)) SWIG_fail;
9024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
9025 if (SWIG_arg_fail(2)) SWIG_fail;
9026 {
9027 arg3 = static_cast<int >(SWIG_As_int(obj2));
9028 if (SWIG_arg_fail(3)) SWIG_fail;
9029 }
9030 {
9031 PyThreadState* __tstate = wxPyBeginAllowThreads();
9032 (arg1)->base_SetRowAttr(arg2,arg3);
9033
9034 wxPyEndAllowThreads(__tstate);
9035 if (PyErr_Occurred()) SWIG_fail;
9036 }
9037 Py_INCREF(Py_None); resultobj = Py_None;
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 static PyObject *_wrap_PyGridTableBase_base_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
9045 PyObject *resultobj = NULL;
9046 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9047 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9048 int arg3 ;
9049 PyObject * obj0 = 0 ;
9050 PyObject * obj1 = 0 ;
9051 PyObject * obj2 = 0 ;
9052 char *kwnames[] = {
9053 (char *) "self",(char *) "attr",(char *) "col", NULL
9054 };
9055
9056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase_base_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
9057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_EXCEPTION | 0);
9058 if (SWIG_arg_fail(1)) SWIG_fail;
9059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
9060 if (SWIG_arg_fail(2)) SWIG_fail;
9061 {
9062 arg3 = static_cast<int >(SWIG_As_int(obj2));
9063 if (SWIG_arg_fail(3)) SWIG_fail;
9064 }
9065 {
9066 PyThreadState* __tstate = wxPyBeginAllowThreads();
9067 (arg1)->base_SetColAttr(arg2,arg3);
9068
9069 wxPyEndAllowThreads(__tstate);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 Py_INCREF(Py_None); resultobj = Py_None;
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 static PyObject * PyGridTableBase_swigregister(PyObject *, PyObject *args) {
9080 PyObject *obj;
9081 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9082 SWIG_TypeClientData(SWIGTYPE_p_wxPyGridTableBase, obj);
9083 Py_INCREF(obj);
9084 return Py_BuildValue((char *)"");
9085 }
9086 static PyObject *_wrap_new_GridStringTable(PyObject *, PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj = NULL;
9088 int arg1 = (int) 0 ;
9089 int arg2 = (int) 0 ;
9090 wxGridStringTable *result;
9091 PyObject * obj0 = 0 ;
9092 PyObject * obj1 = 0 ;
9093 char *kwnames[] = {
9094 (char *) "numRows",(char *) "numCols", NULL
9095 };
9096
9097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) goto fail;
9098 if (obj0) {
9099 {
9100 arg1 = static_cast<int >(SWIG_As_int(obj0));
9101 if (SWIG_arg_fail(1)) SWIG_fail;
9102 }
9103 }
9104 if (obj1) {
9105 {
9106 arg2 = static_cast<int >(SWIG_As_int(obj1));
9107 if (SWIG_arg_fail(2)) SWIG_fail;
9108 }
9109 }
9110 {
9111 PyThreadState* __tstate = wxPyBeginAllowThreads();
9112 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9113
9114 wxPyEndAllowThreads(__tstate);
9115 if (PyErr_Occurred()) SWIG_fail;
9116 }
9117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridStringTable, 1);
9118 return resultobj;
9119 fail:
9120 return NULL;
9121 }
9122
9123
9124 static PyObject * GridStringTable_swigregister(PyObject *, PyObject *args) {
9125 PyObject *obj;
9126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9127 SWIG_TypeClientData(SWIGTYPE_p_wxGridStringTable, obj);
9128 Py_INCREF(obj);
9129 return Py_BuildValue((char *)"");
9130 }
9131 static PyObject *_wrap_new_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9132 PyObject *resultobj = NULL;
9133 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9134 int arg2 ;
9135 int arg3 = (int) -1 ;
9136 int arg4 = (int) -1 ;
9137 wxGridTableMessage *result;
9138 PyObject * obj0 = 0 ;
9139 PyObject * obj1 = 0 ;
9140 PyObject * obj2 = 0 ;
9141 PyObject * obj3 = 0 ;
9142 char *kwnames[] = {
9143 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9144 };
9145
9146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
9148 if (SWIG_arg_fail(1)) SWIG_fail;
9149 {
9150 arg2 = static_cast<int >(SWIG_As_int(obj1));
9151 if (SWIG_arg_fail(2)) SWIG_fail;
9152 }
9153 if (obj2) {
9154 {
9155 arg3 = static_cast<int >(SWIG_As_int(obj2));
9156 if (SWIG_arg_fail(3)) SWIG_fail;
9157 }
9158 }
9159 if (obj3) {
9160 {
9161 arg4 = static_cast<int >(SWIG_As_int(obj3));
9162 if (SWIG_arg_fail(4)) SWIG_fail;
9163 }
9164 }
9165 {
9166 PyThreadState* __tstate = wxPyBeginAllowThreads();
9167 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9168
9169 wxPyEndAllowThreads(__tstate);
9170 if (PyErr_Occurred()) SWIG_fail;
9171 }
9172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridTableMessage, 1);
9173 return resultobj;
9174 fail:
9175 return NULL;
9176 }
9177
9178
9179 static PyObject *_wrap_delete_GridTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9180 PyObject *resultobj = NULL;
9181 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9182 PyObject * obj0 = 0 ;
9183 char *kwnames[] = {
9184 (char *) "self", NULL
9185 };
9186
9187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridTableMessage",kwnames,&obj0)) goto fail;
9188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9189 if (SWIG_arg_fail(1)) SWIG_fail;
9190 {
9191 PyThreadState* __tstate = wxPyBeginAllowThreads();
9192 delete arg1;
9193
9194 wxPyEndAllowThreads(__tstate);
9195 if (PyErr_Occurred()) SWIG_fail;
9196 }
9197 Py_INCREF(Py_None); resultobj = Py_None;
9198 return resultobj;
9199 fail:
9200 return NULL;
9201 }
9202
9203
9204 static PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
9205 PyObject *resultobj = NULL;
9206 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9207 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9208 PyObject * obj0 = 0 ;
9209 PyObject * obj1 = 0 ;
9210 char *kwnames[] = {
9211 (char *) "self",(char *) "table", NULL
9212 };
9213
9214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) goto fail;
9215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9216 if (SWIG_arg_fail(1)) SWIG_fail;
9217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
9218 if (SWIG_arg_fail(2)) SWIG_fail;
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 (arg1)->SetTableObject(arg2);
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 Py_INCREF(Py_None); resultobj = Py_None;
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 static PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *, PyObject *args, PyObject *kwargs) {
9234 PyObject *resultobj = NULL;
9235 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9236 wxGridTableBase *result;
9237 PyObject * obj0 = 0 ;
9238 char *kwnames[] = {
9239 (char *) "self", NULL
9240 };
9241
9242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetTableObject",kwnames,&obj0)) goto fail;
9243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9244 if (SWIG_arg_fail(1)) SWIG_fail;
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9248
9249 wxPyEndAllowThreads(__tstate);
9250 if (PyErr_Occurred()) SWIG_fail;
9251 }
9252 {
9253 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9254 }
9255 return resultobj;
9256 fail:
9257 return NULL;
9258 }
9259
9260
9261 static PyObject *_wrap_GridTableMessage_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
9262 PyObject *resultobj = NULL;
9263 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9264 int arg2 ;
9265 PyObject * obj0 = 0 ;
9266 PyObject * obj1 = 0 ;
9267 char *kwnames[] = {
9268 (char *) "self",(char *) "id", NULL
9269 };
9270
9271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) goto fail;
9272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9273 if (SWIG_arg_fail(1)) SWIG_fail;
9274 {
9275 arg2 = static_cast<int >(SWIG_As_int(obj1));
9276 if (SWIG_arg_fail(2)) SWIG_fail;
9277 }
9278 {
9279 PyThreadState* __tstate = wxPyBeginAllowThreads();
9280 (arg1)->SetId(arg2);
9281
9282 wxPyEndAllowThreads(__tstate);
9283 if (PyErr_Occurred()) SWIG_fail;
9284 }
9285 Py_INCREF(Py_None); resultobj = Py_None;
9286 return resultobj;
9287 fail:
9288 return NULL;
9289 }
9290
9291
9292 static PyObject *_wrap_GridTableMessage_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
9293 PyObject *resultobj = NULL;
9294 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9295 int result;
9296 PyObject * obj0 = 0 ;
9297 char *kwnames[] = {
9298 (char *) "self", NULL
9299 };
9300
9301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetId",kwnames,&obj0)) goto fail;
9302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9303 if (SWIG_arg_fail(1)) SWIG_fail;
9304 {
9305 PyThreadState* __tstate = wxPyBeginAllowThreads();
9306 result = (int)(arg1)->GetId();
9307
9308 wxPyEndAllowThreads(__tstate);
9309 if (PyErr_Occurred()) SWIG_fail;
9310 }
9311 {
9312 resultobj = SWIG_From_int(static_cast<int >(result));
9313 }
9314 return resultobj;
9315 fail:
9316 return NULL;
9317 }
9318
9319
9320 static PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9321 PyObject *resultobj = NULL;
9322 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9323 int arg2 ;
9324 PyObject * obj0 = 0 ;
9325 PyObject * obj1 = 0 ;
9326 char *kwnames[] = {
9327 (char *) "self",(char *) "comInt1", NULL
9328 };
9329
9330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) goto fail;
9331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9332 if (SWIG_arg_fail(1)) SWIG_fail;
9333 {
9334 arg2 = static_cast<int >(SWIG_As_int(obj1));
9335 if (SWIG_arg_fail(2)) SWIG_fail;
9336 }
9337 {
9338 PyThreadState* __tstate = wxPyBeginAllowThreads();
9339 (arg1)->SetCommandInt(arg2);
9340
9341 wxPyEndAllowThreads(__tstate);
9342 if (PyErr_Occurred()) SWIG_fail;
9343 }
9344 Py_INCREF(Py_None); resultobj = Py_None;
9345 return resultobj;
9346 fail:
9347 return NULL;
9348 }
9349
9350
9351 static PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *, PyObject *args, PyObject *kwargs) {
9352 PyObject *resultobj = NULL;
9353 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9354 int result;
9355 PyObject * obj0 = 0 ;
9356 char *kwnames[] = {
9357 (char *) "self", NULL
9358 };
9359
9360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt",kwnames,&obj0)) goto fail;
9361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9362 if (SWIG_arg_fail(1)) SWIG_fail;
9363 {
9364 PyThreadState* __tstate = wxPyBeginAllowThreads();
9365 result = (int)(arg1)->GetCommandInt();
9366
9367 wxPyEndAllowThreads(__tstate);
9368 if (PyErr_Occurred()) SWIG_fail;
9369 }
9370 {
9371 resultobj = SWIG_From_int(static_cast<int >(result));
9372 }
9373 return resultobj;
9374 fail:
9375 return NULL;
9376 }
9377
9378
9379 static PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9380 PyObject *resultobj = NULL;
9381 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9382 int arg2 ;
9383 PyObject * obj0 = 0 ;
9384 PyObject * obj1 = 0 ;
9385 char *kwnames[] = {
9386 (char *) "self",(char *) "comInt2", NULL
9387 };
9388
9389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) goto fail;
9390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9391 if (SWIG_arg_fail(1)) SWIG_fail;
9392 {
9393 arg2 = static_cast<int >(SWIG_As_int(obj1));
9394 if (SWIG_arg_fail(2)) SWIG_fail;
9395 }
9396 {
9397 PyThreadState* __tstate = wxPyBeginAllowThreads();
9398 (arg1)->SetCommandInt2(arg2);
9399
9400 wxPyEndAllowThreads(__tstate);
9401 if (PyErr_Occurred()) SWIG_fail;
9402 }
9403 Py_INCREF(Py_None); resultobj = Py_None;
9404 return resultobj;
9405 fail:
9406 return NULL;
9407 }
9408
9409
9410 static PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *, PyObject *args, PyObject *kwargs) {
9411 PyObject *resultobj = NULL;
9412 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9413 int result;
9414 PyObject * obj0 = 0 ;
9415 char *kwnames[] = {
9416 (char *) "self", NULL
9417 };
9418
9419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridTableMessage_GetCommandInt2",kwnames,&obj0)) goto fail;
9420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
9421 if (SWIG_arg_fail(1)) SWIG_fail;
9422 {
9423 PyThreadState* __tstate = wxPyBeginAllowThreads();
9424 result = (int)(arg1)->GetCommandInt2();
9425
9426 wxPyEndAllowThreads(__tstate);
9427 if (PyErr_Occurred()) SWIG_fail;
9428 }
9429 {
9430 resultobj = SWIG_From_int(static_cast<int >(result));
9431 }
9432 return resultobj;
9433 fail:
9434 return NULL;
9435 }
9436
9437
9438 static PyObject * GridTableMessage_swigregister(PyObject *, PyObject *args) {
9439 PyObject *obj;
9440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9441 SWIG_TypeClientData(SWIGTYPE_p_wxGridTableMessage, obj);
9442 Py_INCREF(obj);
9443 return Py_BuildValue((char *)"");
9444 }
9445 static PyObject *_wrap_new_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = NULL;
9447 int arg1 = (int) -1 ;
9448 int arg2 = (int) -1 ;
9449 wxGridCellCoords *result;
9450 PyObject * obj0 = 0 ;
9451 PyObject * obj1 = 0 ;
9452 char *kwnames[] = {
9453 (char *) "r",(char *) "c", NULL
9454 };
9455
9456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) goto fail;
9457 if (obj0) {
9458 {
9459 arg1 = static_cast<int >(SWIG_As_int(obj0));
9460 if (SWIG_arg_fail(1)) SWIG_fail;
9461 }
9462 }
9463 if (obj1) {
9464 {
9465 arg2 = static_cast<int >(SWIG_As_int(obj1));
9466 if (SWIG_arg_fail(2)) SWIG_fail;
9467 }
9468 }
9469 {
9470 PyThreadState* __tstate = wxPyBeginAllowThreads();
9471 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9472
9473 wxPyEndAllowThreads(__tstate);
9474 if (PyErr_Occurred()) SWIG_fail;
9475 }
9476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridCellCoords, 1);
9477 return resultobj;
9478 fail:
9479 return NULL;
9480 }
9481
9482
9483 static PyObject *_wrap_delete_GridCellCoords(PyObject *, PyObject *args, PyObject *kwargs) {
9484 PyObject *resultobj = NULL;
9485 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9486 PyObject * obj0 = 0 ;
9487 char *kwnames[] = {
9488 (char *) "self", NULL
9489 };
9490
9491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GridCellCoords",kwnames,&obj0)) goto fail;
9492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9493 if (SWIG_arg_fail(1)) SWIG_fail;
9494 {
9495 PyThreadState* __tstate = wxPyBeginAllowThreads();
9496 delete arg1;
9497
9498 wxPyEndAllowThreads(__tstate);
9499 if (PyErr_Occurred()) SWIG_fail;
9500 }
9501 Py_INCREF(Py_None); resultobj = Py_None;
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 static PyObject *_wrap_GridCellCoords_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj = NULL;
9510 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9511 int result;
9512 PyObject * obj0 = 0 ;
9513 char *kwnames[] = {
9514 (char *) "self", NULL
9515 };
9516
9517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetRow",kwnames,&obj0)) goto fail;
9518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9519 if (SWIG_arg_fail(1)) SWIG_fail;
9520 {
9521 PyThreadState* __tstate = wxPyBeginAllowThreads();
9522 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9523
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 {
9528 resultobj = SWIG_From_int(static_cast<int >(result));
9529 }
9530 return resultobj;
9531 fail:
9532 return NULL;
9533 }
9534
9535
9536 static PyObject *_wrap_GridCellCoords_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
9537 PyObject *resultobj = NULL;
9538 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9539 int arg2 ;
9540 PyObject * obj0 = 0 ;
9541 PyObject * obj1 = 0 ;
9542 char *kwnames[] = {
9543 (char *) "self",(char *) "n", NULL
9544 };
9545
9546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) goto fail;
9547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9548 if (SWIG_arg_fail(1)) SWIG_fail;
9549 {
9550 arg2 = static_cast<int >(SWIG_As_int(obj1));
9551 if (SWIG_arg_fail(2)) SWIG_fail;
9552 }
9553 {
9554 PyThreadState* __tstate = wxPyBeginAllowThreads();
9555 (arg1)->SetRow(arg2);
9556
9557 wxPyEndAllowThreads(__tstate);
9558 if (PyErr_Occurred()) SWIG_fail;
9559 }
9560 Py_INCREF(Py_None); resultobj = Py_None;
9561 return resultobj;
9562 fail:
9563 return NULL;
9564 }
9565
9566
9567 static PyObject *_wrap_GridCellCoords_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9568 PyObject *resultobj = NULL;
9569 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9570 int result;
9571 PyObject * obj0 = 0 ;
9572 char *kwnames[] = {
9573 (char *) "self", NULL
9574 };
9575
9576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_GetCol",kwnames,&obj0)) goto fail;
9577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9578 if (SWIG_arg_fail(1)) SWIG_fail;
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
9582
9583 wxPyEndAllowThreads(__tstate);
9584 if (PyErr_Occurred()) SWIG_fail;
9585 }
9586 {
9587 resultobj = SWIG_From_int(static_cast<int >(result));
9588 }
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 static PyObject *_wrap_GridCellCoords_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj = NULL;
9597 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9598 int arg2 ;
9599 PyObject * obj0 = 0 ;
9600 PyObject * obj1 = 0 ;
9601 char *kwnames[] = {
9602 (char *) "self",(char *) "n", NULL
9603 };
9604
9605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) goto fail;
9606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9607 if (SWIG_arg_fail(1)) SWIG_fail;
9608 {
9609 arg2 = static_cast<int >(SWIG_As_int(obj1));
9610 if (SWIG_arg_fail(2)) SWIG_fail;
9611 }
9612 {
9613 PyThreadState* __tstate = wxPyBeginAllowThreads();
9614 (arg1)->SetCol(arg2);
9615
9616 wxPyEndAllowThreads(__tstate);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 Py_INCREF(Py_None); resultobj = Py_None;
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 static PyObject *_wrap_GridCellCoords_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj = NULL;
9628 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9629 int arg2 ;
9630 int arg3 ;
9631 PyObject * obj0 = 0 ;
9632 PyObject * obj1 = 0 ;
9633 PyObject * obj2 = 0 ;
9634 char *kwnames[] = {
9635 (char *) "self",(char *) "row",(char *) "col", NULL
9636 };
9637
9638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
9639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9640 if (SWIG_arg_fail(1)) SWIG_fail;
9641 {
9642 arg2 = static_cast<int >(SWIG_As_int(obj1));
9643 if (SWIG_arg_fail(2)) SWIG_fail;
9644 }
9645 {
9646 arg3 = static_cast<int >(SWIG_As_int(obj2));
9647 if (SWIG_arg_fail(3)) SWIG_fail;
9648 }
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 (arg1)->Set(arg2,arg3);
9652
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 Py_INCREF(Py_None); resultobj = Py_None;
9657 return resultobj;
9658 fail:
9659 return NULL;
9660 }
9661
9662
9663 static PyObject *_wrap_GridCellCoords___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9664 PyObject *resultobj = NULL;
9665 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9666 wxGridCellCoords *arg2 = 0 ;
9667 bool result;
9668 wxGridCellCoords temp2 ;
9669 PyObject * obj0 = 0 ;
9670 PyObject * obj1 = 0 ;
9671 char *kwnames[] = {
9672 (char *) "self",(char *) "other", NULL
9673 };
9674
9675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) goto fail;
9676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9677 if (SWIG_arg_fail(1)) SWIG_fail;
9678 {
9679 arg2 = &temp2;
9680 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9681 }
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 result = (bool)((wxGridCellCoords const *)arg1)->operator ==((wxGridCellCoords const &)*arg2);
9685
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 {
9690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9691 }
9692 return resultobj;
9693 fail:
9694 return NULL;
9695 }
9696
9697
9698 static PyObject *_wrap_GridCellCoords___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9699 PyObject *resultobj = NULL;
9700 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9701 wxGridCellCoords *arg2 = 0 ;
9702 bool result;
9703 wxGridCellCoords temp2 ;
9704 PyObject * obj0 = 0 ;
9705 PyObject * obj1 = 0 ;
9706 char *kwnames[] = {
9707 (char *) "self",(char *) "other", NULL
9708 };
9709
9710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) goto fail;
9711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9712 if (SWIG_arg_fail(1)) SWIG_fail;
9713 {
9714 arg2 = &temp2;
9715 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
9716 }
9717 {
9718 PyThreadState* __tstate = wxPyBeginAllowThreads();
9719 result = (bool)((wxGridCellCoords const *)arg1)->operator !=((wxGridCellCoords const &)*arg2);
9720
9721 wxPyEndAllowThreads(__tstate);
9722 if (PyErr_Occurred()) SWIG_fail;
9723 }
9724 {
9725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9726 }
9727 return resultobj;
9728 fail:
9729 return NULL;
9730 }
9731
9732
9733 static PyObject *_wrap_GridCellCoords_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9734 PyObject *resultobj = NULL;
9735 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9736 PyObject *result;
9737 PyObject * obj0 = 0 ;
9738 char *kwnames[] = {
9739 (char *) "self", NULL
9740 };
9741
9742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellCoords_Get",kwnames,&obj0)) goto fail;
9743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_EXCEPTION | 0);
9744 if (SWIG_arg_fail(1)) SWIG_fail;
9745 {
9746 PyThreadState* __tstate = wxPyBeginAllowThreads();
9747 result = (PyObject *)wxGridCellCoords_Get(arg1);
9748
9749 wxPyEndAllowThreads(__tstate);
9750 if (PyErr_Occurred()) SWIG_fail;
9751 }
9752 resultobj = result;
9753 return resultobj;
9754 fail:
9755 return NULL;
9756 }
9757
9758
9759 static PyObject * GridCellCoords_swigregister(PyObject *, PyObject *args) {
9760 PyObject *obj;
9761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9762 SWIG_TypeClientData(SWIGTYPE_p_wxGridCellCoords, obj);
9763 Py_INCREF(obj);
9764 return Py_BuildValue((char *)"");
9765 }
9766 static PyObject *_wrap_new_Grid(PyObject *, PyObject *args, PyObject *kwargs) {
9767 PyObject *resultobj = NULL;
9768 wxWindow *arg1 = (wxWindow *) 0 ;
9769 int arg2 = (int) -1 ;
9770 wxPoint const &arg3_defvalue = wxDefaultPosition ;
9771 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
9772 wxSize const &arg4_defvalue = wxDefaultSize ;
9773 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
9774 long arg5 = (long) wxWANTS_CHARS ;
9775 wxString const &arg6_defvalue = wxPyPanelNameStr ;
9776 wxString *arg6 = (wxString *) &arg6_defvalue ;
9777 wxGrid *result;
9778 wxPoint temp3 ;
9779 wxSize temp4 ;
9780 bool temp6 = false ;
9781 PyObject * obj0 = 0 ;
9782 PyObject * obj1 = 0 ;
9783 PyObject * obj2 = 0 ;
9784 PyObject * obj3 = 0 ;
9785 PyObject * obj4 = 0 ;
9786 PyObject * obj5 = 0 ;
9787 char *kwnames[] = {
9788 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9789 };
9790
9791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
9792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9793 if (SWIG_arg_fail(1)) SWIG_fail;
9794 if (obj1) {
9795 {
9796 arg2 = static_cast<int >(SWIG_As_int(obj1));
9797 if (SWIG_arg_fail(2)) SWIG_fail;
9798 }
9799 }
9800 if (obj2) {
9801 {
9802 arg3 = &temp3;
9803 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
9804 }
9805 }
9806 if (obj3) {
9807 {
9808 arg4 = &temp4;
9809 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
9810 }
9811 }
9812 if (obj4) {
9813 {
9814 arg5 = static_cast<long >(SWIG_As_long(obj4));
9815 if (SWIG_arg_fail(5)) SWIG_fail;
9816 }
9817 }
9818 if (obj5) {
9819 {
9820 arg6 = wxString_in_helper(obj5);
9821 if (arg6 == NULL) SWIG_fail;
9822 temp6 = true;
9823 }
9824 }
9825 {
9826 if (!wxPyCheckForApp()) SWIG_fail;
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
9829
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9834 {
9835 if (temp6)
9836 delete arg6;
9837 }
9838 return resultobj;
9839 fail:
9840 {
9841 if (temp6)
9842 delete arg6;
9843 }
9844 return NULL;
9845 }
9846
9847
9848 static PyObject *_wrap_new_PreGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9849 PyObject *resultobj = NULL;
9850 wxGrid *result;
9851 char *kwnames[] = {
9852 NULL
9853 };
9854
9855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGrid",kwnames)) goto fail;
9856 {
9857 if (!wxPyCheckForApp()) SWIG_fail;
9858 PyThreadState* __tstate = wxPyBeginAllowThreads();
9859 result = (wxGrid *)new wxGrid();
9860
9861 wxPyEndAllowThreads(__tstate);
9862 if (PyErr_Occurred()) SWIG_fail;
9863 }
9864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGrid, 1);
9865 return resultobj;
9866 fail:
9867 return NULL;
9868 }
9869
9870
9871 static PyObject *_wrap_Grid_Create(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj = NULL;
9873 wxGrid *arg1 = (wxGrid *) 0 ;
9874 wxWindow *arg2 = (wxWindow *) 0 ;
9875 int arg3 = (int) -1 ;
9876 wxPoint const &arg4_defvalue = wxDefaultPosition ;
9877 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
9878 wxSize const &arg5_defvalue = wxDefaultSize ;
9879 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
9880 long arg6 = (long) wxWANTS_CHARS ;
9881 wxString const &arg7_defvalue = wxPyPanelNameStr ;
9882 wxString *arg7 = (wxString *) &arg7_defvalue ;
9883 bool result;
9884 wxPoint temp4 ;
9885 wxSize temp5 ;
9886 bool temp7 = false ;
9887 PyObject * obj0 = 0 ;
9888 PyObject * obj1 = 0 ;
9889 PyObject * obj2 = 0 ;
9890 PyObject * obj3 = 0 ;
9891 PyObject * obj4 = 0 ;
9892 PyObject * obj5 = 0 ;
9893 PyObject * obj6 = 0 ;
9894 char *kwnames[] = {
9895 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
9896 };
9897
9898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9900 if (SWIG_arg_fail(1)) SWIG_fail;
9901 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9902 if (SWIG_arg_fail(2)) SWIG_fail;
9903 if (obj2) {
9904 {
9905 arg3 = static_cast<int >(SWIG_As_int(obj2));
9906 if (SWIG_arg_fail(3)) SWIG_fail;
9907 }
9908 }
9909 if (obj3) {
9910 {
9911 arg4 = &temp4;
9912 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
9913 }
9914 }
9915 if (obj4) {
9916 {
9917 arg5 = &temp5;
9918 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
9919 }
9920 }
9921 if (obj5) {
9922 {
9923 arg6 = static_cast<long >(SWIG_As_long(obj5));
9924 if (SWIG_arg_fail(6)) SWIG_fail;
9925 }
9926 }
9927 if (obj6) {
9928 {
9929 arg7 = wxString_in_helper(obj6);
9930 if (arg7 == NULL) SWIG_fail;
9931 temp7 = true;
9932 }
9933 }
9934 {
9935 PyThreadState* __tstate = wxPyBeginAllowThreads();
9936 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
9937
9938 wxPyEndAllowThreads(__tstate);
9939 if (PyErr_Occurred()) SWIG_fail;
9940 }
9941 {
9942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9943 }
9944 {
9945 if (temp7)
9946 delete arg7;
9947 }
9948 return resultobj;
9949 fail:
9950 {
9951 if (temp7)
9952 delete arg7;
9953 }
9954 return NULL;
9955 }
9956
9957
9958 static PyObject *_wrap_Grid_CreateGrid(PyObject *, PyObject *args, PyObject *kwargs) {
9959 PyObject *resultobj = NULL;
9960 wxGrid *arg1 = (wxGrid *) 0 ;
9961 int arg2 ;
9962 int arg3 ;
9963 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
9964 bool result;
9965 PyObject * obj0 = 0 ;
9966 PyObject * obj1 = 0 ;
9967 PyObject * obj2 = 0 ;
9968 PyObject * obj3 = 0 ;
9969 char *kwnames[] = {
9970 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
9971 };
9972
9973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
9975 if (SWIG_arg_fail(1)) SWIG_fail;
9976 {
9977 arg2 = static_cast<int >(SWIG_As_int(obj1));
9978 if (SWIG_arg_fail(2)) SWIG_fail;
9979 }
9980 {
9981 arg3 = static_cast<int >(SWIG_As_int(obj2));
9982 if (SWIG_arg_fail(3)) SWIG_fail;
9983 }
9984 if (obj3) {
9985 {
9986 arg4 = static_cast<WXGRIDSELECTIONMODES >(SWIG_As_int(obj3));
9987 if (SWIG_arg_fail(4)) SWIG_fail;
9988 }
9989 }
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
9993
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 {
9998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9999 }
10000 return resultobj;
10001 fail:
10002 return NULL;
10003 }
10004
10005
10006 static PyObject *_wrap_Grid_SetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
10007 PyObject *resultobj = NULL;
10008 wxGrid *arg1 = (wxGrid *) 0 ;
10009 WXGRIDSELECTIONMODES arg2 ;
10010 PyObject * obj0 = 0 ;
10011 PyObject * obj1 = 0 ;
10012 char *kwnames[] = {
10013 (char *) "self",(char *) "selmode", NULL
10014 };
10015
10016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) goto fail;
10017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10018 if (SWIG_arg_fail(1)) SWIG_fail;
10019 {
10020 arg2 = static_cast<WXGRIDSELECTIONMODES >(SWIG_As_int(obj1));
10021 if (SWIG_arg_fail(2)) SWIG_fail;
10022 }
10023 {
10024 PyThreadState* __tstate = wxPyBeginAllowThreads();
10025 (arg1)->SetSelectionMode(arg2);
10026
10027 wxPyEndAllowThreads(__tstate);
10028 if (PyErr_Occurred()) SWIG_fail;
10029 }
10030 Py_INCREF(Py_None); resultobj = Py_None;
10031 return resultobj;
10032 fail:
10033 return NULL;
10034 }
10035
10036
10037 static PyObject *_wrap_Grid_GetSelectionMode(PyObject *, PyObject *args, PyObject *kwargs) {
10038 PyObject *resultobj = NULL;
10039 wxGrid *arg1 = (wxGrid *) 0 ;
10040 WXGRIDSELECTIONMODES result;
10041 PyObject * obj0 = 0 ;
10042 char *kwnames[] = {
10043 (char *) "self", NULL
10044 };
10045
10046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionMode",kwnames,&obj0)) goto fail;
10047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10048 if (SWIG_arg_fail(1)) SWIG_fail;
10049 {
10050 PyThreadState* __tstate = wxPyBeginAllowThreads();
10051 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10052
10053 wxPyEndAllowThreads(__tstate);
10054 if (PyErr_Occurred()) SWIG_fail;
10055 }
10056 {
10057 resultobj = SWIG_From_int(static_cast<int >(result));
10058 }
10059 return resultobj;
10060 fail:
10061 return NULL;
10062 }
10063
10064
10065 static PyObject *_wrap_Grid_GetNumberRows(PyObject *, PyObject *args, PyObject *kwargs) {
10066 PyObject *resultobj = NULL;
10067 wxGrid *arg1 = (wxGrid *) 0 ;
10068 int result;
10069 PyObject * obj0 = 0 ;
10070 char *kwnames[] = {
10071 (char *) "self", NULL
10072 };
10073
10074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberRows",kwnames,&obj0)) goto fail;
10075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10076 if (SWIG_arg_fail(1)) SWIG_fail;
10077 {
10078 PyThreadState* __tstate = wxPyBeginAllowThreads();
10079 result = (int)(arg1)->GetNumberRows();
10080
10081 wxPyEndAllowThreads(__tstate);
10082 if (PyErr_Occurred()) SWIG_fail;
10083 }
10084 {
10085 resultobj = SWIG_From_int(static_cast<int >(result));
10086 }
10087 return resultobj;
10088 fail:
10089 return NULL;
10090 }
10091
10092
10093 static PyObject *_wrap_Grid_GetNumberCols(PyObject *, PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj = NULL;
10095 wxGrid *arg1 = (wxGrid *) 0 ;
10096 int result;
10097 PyObject * obj0 = 0 ;
10098 char *kwnames[] = {
10099 (char *) "self", NULL
10100 };
10101
10102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetNumberCols",kwnames,&obj0)) goto fail;
10103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10104 if (SWIG_arg_fail(1)) SWIG_fail;
10105 {
10106 PyThreadState* __tstate = wxPyBeginAllowThreads();
10107 result = (int)(arg1)->GetNumberCols();
10108
10109 wxPyEndAllowThreads(__tstate);
10110 if (PyErr_Occurred()) SWIG_fail;
10111 }
10112 {
10113 resultobj = SWIG_From_int(static_cast<int >(result));
10114 }
10115 return resultobj;
10116 fail:
10117 return NULL;
10118 }
10119
10120
10121 static PyObject *_wrap_Grid_ProcessTableMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10122 PyObject *resultobj = NULL;
10123 wxGrid *arg1 = (wxGrid *) 0 ;
10124 wxGridTableMessage *arg2 = 0 ;
10125 bool result;
10126 PyObject * obj0 = 0 ;
10127 PyObject * obj1 = 0 ;
10128 char *kwnames[] = {
10129 (char *) "self","arg2", NULL
10130 };
10131
10132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) goto fail;
10133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10134 if (SWIG_arg_fail(1)) SWIG_fail;
10135 {
10136 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_EXCEPTION | 0);
10137 if (SWIG_arg_fail(2)) SWIG_fail;
10138 if (arg2 == NULL) {
10139 SWIG_null_ref("wxGridTableMessage");
10140 }
10141 if (SWIG_arg_fail(2)) SWIG_fail;
10142 }
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10146
10147 wxPyEndAllowThreads(__tstate);
10148 if (PyErr_Occurred()) SWIG_fail;
10149 }
10150 {
10151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10152 }
10153 return resultobj;
10154 fail:
10155 return NULL;
10156 }
10157
10158
10159 static PyObject *_wrap_Grid_GetTable(PyObject *, PyObject *args, PyObject *kwargs) {
10160 PyObject *resultobj = NULL;
10161 wxGrid *arg1 = (wxGrid *) 0 ;
10162 wxGridTableBase *result;
10163 PyObject * obj0 = 0 ;
10164 char *kwnames[] = {
10165 (char *) "self", NULL
10166 };
10167
10168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetTable",kwnames,&obj0)) goto fail;
10169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10170 if (SWIG_arg_fail(1)) SWIG_fail;
10171 {
10172 PyThreadState* __tstate = wxPyBeginAllowThreads();
10173 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10174
10175 wxPyEndAllowThreads(__tstate);
10176 if (PyErr_Occurred()) SWIG_fail;
10177 }
10178 {
10179 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10180 }
10181 return resultobj;
10182 fail:
10183 return NULL;
10184 }
10185
10186
10187 static PyObject *_wrap_Grid_SetTable(PyObject *, PyObject *args, PyObject *kwargs) {
10188 PyObject *resultobj = NULL;
10189 wxGrid *arg1 = (wxGrid *) 0 ;
10190 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10191 bool arg3 = (bool) false ;
10192 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10193 bool result;
10194 PyObject * obj0 = 0 ;
10195 PyObject * obj1 = 0 ;
10196 PyObject * obj2 = 0 ;
10197 PyObject * obj3 = 0 ;
10198 char *kwnames[] = {
10199 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10200 };
10201
10202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10204 if (SWIG_arg_fail(1)) SWIG_fail;
10205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_EXCEPTION | 0);
10206 if (SWIG_arg_fail(2)) SWIG_fail;
10207 if (obj2) {
10208 {
10209 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
10210 if (SWIG_arg_fail(3)) SWIG_fail;
10211 }
10212 }
10213 if (obj3) {
10214 {
10215 arg4 = static_cast<WXGRIDSELECTIONMODES >(SWIG_As_int(obj3));
10216 if (SWIG_arg_fail(4)) SWIG_fail;
10217 }
10218 }
10219 {
10220 PyThreadState* __tstate = wxPyBeginAllowThreads();
10221 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10222
10223 wxPyEndAllowThreads(__tstate);
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 {
10227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10228 }
10229 return resultobj;
10230 fail:
10231 return NULL;
10232 }
10233
10234
10235 static PyObject *_wrap_Grid_ClearGrid(PyObject *, PyObject *args, PyObject *kwargs) {
10236 PyObject *resultobj = NULL;
10237 wxGrid *arg1 = (wxGrid *) 0 ;
10238 PyObject * obj0 = 0 ;
10239 char *kwnames[] = {
10240 (char *) "self", NULL
10241 };
10242
10243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearGrid",kwnames,&obj0)) goto fail;
10244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10245 if (SWIG_arg_fail(1)) SWIG_fail;
10246 {
10247 PyThreadState* __tstate = wxPyBeginAllowThreads();
10248 (arg1)->ClearGrid();
10249
10250 wxPyEndAllowThreads(__tstate);
10251 if (PyErr_Occurred()) SWIG_fail;
10252 }
10253 Py_INCREF(Py_None); resultobj = Py_None;
10254 return resultobj;
10255 fail:
10256 return NULL;
10257 }
10258
10259
10260 static PyObject *_wrap_Grid_InsertRows(PyObject *, PyObject *args, PyObject *kwargs) {
10261 PyObject *resultobj = NULL;
10262 wxGrid *arg1 = (wxGrid *) 0 ;
10263 int arg2 = (int) 0 ;
10264 int arg3 = (int) 1 ;
10265 bool arg4 = (bool) true ;
10266 bool result;
10267 PyObject * obj0 = 0 ;
10268 PyObject * obj1 = 0 ;
10269 PyObject * obj2 = 0 ;
10270 PyObject * obj3 = 0 ;
10271 char *kwnames[] = {
10272 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10273 };
10274
10275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10277 if (SWIG_arg_fail(1)) SWIG_fail;
10278 if (obj1) {
10279 {
10280 arg2 = static_cast<int >(SWIG_As_int(obj1));
10281 if (SWIG_arg_fail(2)) SWIG_fail;
10282 }
10283 }
10284 if (obj2) {
10285 {
10286 arg3 = static_cast<int >(SWIG_As_int(obj2));
10287 if (SWIG_arg_fail(3)) SWIG_fail;
10288 }
10289 }
10290 if (obj3) {
10291 {
10292 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10293 if (SWIG_arg_fail(4)) SWIG_fail;
10294 }
10295 }
10296 {
10297 PyThreadState* __tstate = wxPyBeginAllowThreads();
10298 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10299
10300 wxPyEndAllowThreads(__tstate);
10301 if (PyErr_Occurred()) SWIG_fail;
10302 }
10303 {
10304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10305 }
10306 return resultobj;
10307 fail:
10308 return NULL;
10309 }
10310
10311
10312 static PyObject *_wrap_Grid_AppendRows(PyObject *, PyObject *args, PyObject *kwargs) {
10313 PyObject *resultobj = NULL;
10314 wxGrid *arg1 = (wxGrid *) 0 ;
10315 int arg2 = (int) 1 ;
10316 bool arg3 = (bool) true ;
10317 bool result;
10318 PyObject * obj0 = 0 ;
10319 PyObject * obj1 = 0 ;
10320 PyObject * obj2 = 0 ;
10321 char *kwnames[] = {
10322 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10323 };
10324
10325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) goto fail;
10326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10327 if (SWIG_arg_fail(1)) SWIG_fail;
10328 if (obj1) {
10329 {
10330 arg2 = static_cast<int >(SWIG_As_int(obj1));
10331 if (SWIG_arg_fail(2)) SWIG_fail;
10332 }
10333 }
10334 if (obj2) {
10335 {
10336 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
10337 if (SWIG_arg_fail(3)) SWIG_fail;
10338 }
10339 }
10340 {
10341 PyThreadState* __tstate = wxPyBeginAllowThreads();
10342 result = (bool)(arg1)->AppendRows(arg2,arg3);
10343
10344 wxPyEndAllowThreads(__tstate);
10345 if (PyErr_Occurred()) SWIG_fail;
10346 }
10347 {
10348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10349 }
10350 return resultobj;
10351 fail:
10352 return NULL;
10353 }
10354
10355
10356 static PyObject *_wrap_Grid_DeleteRows(PyObject *, PyObject *args, PyObject *kwargs) {
10357 PyObject *resultobj = NULL;
10358 wxGrid *arg1 = (wxGrid *) 0 ;
10359 int arg2 = (int) 0 ;
10360 int arg3 = (int) 1 ;
10361 bool arg4 = (bool) true ;
10362 bool result;
10363 PyObject * obj0 = 0 ;
10364 PyObject * obj1 = 0 ;
10365 PyObject * obj2 = 0 ;
10366 PyObject * obj3 = 0 ;
10367 char *kwnames[] = {
10368 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10369 };
10370
10371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10373 if (SWIG_arg_fail(1)) SWIG_fail;
10374 if (obj1) {
10375 {
10376 arg2 = static_cast<int >(SWIG_As_int(obj1));
10377 if (SWIG_arg_fail(2)) SWIG_fail;
10378 }
10379 }
10380 if (obj2) {
10381 {
10382 arg3 = static_cast<int >(SWIG_As_int(obj2));
10383 if (SWIG_arg_fail(3)) SWIG_fail;
10384 }
10385 }
10386 if (obj3) {
10387 {
10388 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10389 if (SWIG_arg_fail(4)) SWIG_fail;
10390 }
10391 }
10392 {
10393 PyThreadState* __tstate = wxPyBeginAllowThreads();
10394 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10395
10396 wxPyEndAllowThreads(__tstate);
10397 if (PyErr_Occurred()) SWIG_fail;
10398 }
10399 {
10400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10401 }
10402 return resultobj;
10403 fail:
10404 return NULL;
10405 }
10406
10407
10408 static PyObject *_wrap_Grid_InsertCols(PyObject *, PyObject *args, PyObject *kwargs) {
10409 PyObject *resultobj = NULL;
10410 wxGrid *arg1 = (wxGrid *) 0 ;
10411 int arg2 = (int) 0 ;
10412 int arg3 = (int) 1 ;
10413 bool arg4 = (bool) true ;
10414 bool result;
10415 PyObject * obj0 = 0 ;
10416 PyObject * obj1 = 0 ;
10417 PyObject * obj2 = 0 ;
10418 PyObject * obj3 = 0 ;
10419 char *kwnames[] = {
10420 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10421 };
10422
10423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10425 if (SWIG_arg_fail(1)) SWIG_fail;
10426 if (obj1) {
10427 {
10428 arg2 = static_cast<int >(SWIG_As_int(obj1));
10429 if (SWIG_arg_fail(2)) SWIG_fail;
10430 }
10431 }
10432 if (obj2) {
10433 {
10434 arg3 = static_cast<int >(SWIG_As_int(obj2));
10435 if (SWIG_arg_fail(3)) SWIG_fail;
10436 }
10437 }
10438 if (obj3) {
10439 {
10440 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10441 if (SWIG_arg_fail(4)) SWIG_fail;
10442 }
10443 }
10444 {
10445 PyThreadState* __tstate = wxPyBeginAllowThreads();
10446 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
10447
10448 wxPyEndAllowThreads(__tstate);
10449 if (PyErr_Occurred()) SWIG_fail;
10450 }
10451 {
10452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10453 }
10454 return resultobj;
10455 fail:
10456 return NULL;
10457 }
10458
10459
10460 static PyObject *_wrap_Grid_AppendCols(PyObject *, PyObject *args, PyObject *kwargs) {
10461 PyObject *resultobj = NULL;
10462 wxGrid *arg1 = (wxGrid *) 0 ;
10463 int arg2 = (int) 1 ;
10464 bool arg3 = (bool) true ;
10465 bool result;
10466 PyObject * obj0 = 0 ;
10467 PyObject * obj1 = 0 ;
10468 PyObject * obj2 = 0 ;
10469 char *kwnames[] = {
10470 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
10471 };
10472
10473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) goto fail;
10474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10475 if (SWIG_arg_fail(1)) SWIG_fail;
10476 if (obj1) {
10477 {
10478 arg2 = static_cast<int >(SWIG_As_int(obj1));
10479 if (SWIG_arg_fail(2)) SWIG_fail;
10480 }
10481 }
10482 if (obj2) {
10483 {
10484 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
10485 if (SWIG_arg_fail(3)) SWIG_fail;
10486 }
10487 }
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (bool)(arg1)->AppendCols(arg2,arg3);
10491
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 {
10496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10497 }
10498 return resultobj;
10499 fail:
10500 return NULL;
10501 }
10502
10503
10504 static PyObject *_wrap_Grid_DeleteCols(PyObject *, PyObject *args, PyObject *kwargs) {
10505 PyObject *resultobj = NULL;
10506 wxGrid *arg1 = (wxGrid *) 0 ;
10507 int arg2 = (int) 0 ;
10508 int arg3 = (int) 1 ;
10509 bool arg4 = (bool) true ;
10510 bool result;
10511 PyObject * obj0 = 0 ;
10512 PyObject * obj1 = 0 ;
10513 PyObject * obj2 = 0 ;
10514 PyObject * obj3 = 0 ;
10515 char *kwnames[] = {
10516 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10517 };
10518
10519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10521 if (SWIG_arg_fail(1)) SWIG_fail;
10522 if (obj1) {
10523 {
10524 arg2 = static_cast<int >(SWIG_As_int(obj1));
10525 if (SWIG_arg_fail(2)) SWIG_fail;
10526 }
10527 }
10528 if (obj2) {
10529 {
10530 arg3 = static_cast<int >(SWIG_As_int(obj2));
10531 if (SWIG_arg_fail(3)) SWIG_fail;
10532 }
10533 }
10534 if (obj3) {
10535 {
10536 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10537 if (SWIG_arg_fail(4)) SWIG_fail;
10538 }
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
10543
10544 wxPyEndAllowThreads(__tstate);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 {
10548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10549 }
10550 return resultobj;
10551 fail:
10552 return NULL;
10553 }
10554
10555
10556 static PyObject *_wrap_Grid_DrawCellHighlight(PyObject *, PyObject *args, PyObject *kwargs) {
10557 PyObject *resultobj = NULL;
10558 wxGrid *arg1 = (wxGrid *) 0 ;
10559 wxDC *arg2 = 0 ;
10560 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
10561 PyObject * obj0 = 0 ;
10562 PyObject * obj1 = 0 ;
10563 PyObject * obj2 = 0 ;
10564 char *kwnames[] = {
10565 (char *) "self",(char *) "dc",(char *) "attr", NULL
10566 };
10567
10568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) goto fail;
10569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10570 if (SWIG_arg_fail(1)) SWIG_fail;
10571 {
10572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10573 if (SWIG_arg_fail(2)) SWIG_fail;
10574 if (arg2 == NULL) {
10575 SWIG_null_ref("wxDC");
10576 }
10577 if (SWIG_arg_fail(2)) SWIG_fail;
10578 }
10579 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
10580 if (SWIG_arg_fail(3)) SWIG_fail;
10581 {
10582 PyThreadState* __tstate = wxPyBeginAllowThreads();
10583 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
10584
10585 wxPyEndAllowThreads(__tstate);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 Py_INCREF(Py_None); resultobj = Py_None;
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 static PyObject *_wrap_Grid_DrawTextRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
10596 PyObject *resultobj = NULL;
10597 wxGrid *arg1 = (wxGrid *) 0 ;
10598 wxDC *arg2 = 0 ;
10599 wxString *arg3 = 0 ;
10600 wxRect *arg4 = 0 ;
10601 int arg5 = (int) wxLEFT ;
10602 int arg6 = (int) wxTOP ;
10603 int arg7 = (int) wxHORIZONTAL ;
10604 bool temp3 = false ;
10605 wxRect temp4 ;
10606 PyObject * obj0 = 0 ;
10607 PyObject * obj1 = 0 ;
10608 PyObject * obj2 = 0 ;
10609 PyObject * obj3 = 0 ;
10610 PyObject * obj4 = 0 ;
10611 PyObject * obj5 = 0 ;
10612 PyObject * obj6 = 0 ;
10613 char *kwnames[] = {
10614 (char *) "self",(char *) "dc","arg3","arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
10615 };
10616
10617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10619 if (SWIG_arg_fail(1)) SWIG_fail;
10620 {
10621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10622 if (SWIG_arg_fail(2)) SWIG_fail;
10623 if (arg2 == NULL) {
10624 SWIG_null_ref("wxDC");
10625 }
10626 if (SWIG_arg_fail(2)) SWIG_fail;
10627 }
10628 {
10629 arg3 = wxString_in_helper(obj2);
10630 if (arg3 == NULL) SWIG_fail;
10631 temp3 = true;
10632 }
10633 {
10634 arg4 = &temp4;
10635 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
10636 }
10637 if (obj4) {
10638 {
10639 arg5 = static_cast<int >(SWIG_As_int(obj4));
10640 if (SWIG_arg_fail(5)) SWIG_fail;
10641 }
10642 }
10643 if (obj5) {
10644 {
10645 arg6 = static_cast<int >(SWIG_As_int(obj5));
10646 if (SWIG_arg_fail(6)) SWIG_fail;
10647 }
10648 }
10649 if (obj6) {
10650 {
10651 arg7 = static_cast<int >(SWIG_As_int(obj6));
10652 if (SWIG_arg_fail(7)) SWIG_fail;
10653 }
10654 }
10655 {
10656 PyThreadState* __tstate = wxPyBeginAllowThreads();
10657 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
10658
10659 wxPyEndAllowThreads(__tstate);
10660 if (PyErr_Occurred()) SWIG_fail;
10661 }
10662 Py_INCREF(Py_None); resultobj = Py_None;
10663 {
10664 if (temp3)
10665 delete arg3;
10666 }
10667 return resultobj;
10668 fail:
10669 {
10670 if (temp3)
10671 delete arg3;
10672 }
10673 return NULL;
10674 }
10675
10676
10677 static PyObject *_wrap_Grid_GetTextBoxSize(PyObject *, PyObject *args, PyObject *kwargs) {
10678 PyObject *resultobj = NULL;
10679 wxGrid *arg1 = (wxGrid *) 0 ;
10680 wxDC *arg2 = 0 ;
10681 wxArrayString *arg3 = 0 ;
10682 long *arg4 = (long *) 0 ;
10683 long *arg5 = (long *) 0 ;
10684 bool temp3 = false ;
10685 long temp4 ;
10686 int res4 = 0 ;
10687 long temp5 ;
10688 int res5 = 0 ;
10689 PyObject * obj0 = 0 ;
10690 PyObject * obj1 = 0 ;
10691 PyObject * obj2 = 0 ;
10692 char *kwnames[] = {
10693 (char *) "self",(char *) "dc",(char *) "lines", NULL
10694 };
10695
10696 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10697 arg5 = &temp5; res5 = SWIG_NEWOBJ;
10698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
10699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10700 if (SWIG_arg_fail(1)) SWIG_fail;
10701 {
10702 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
10703 if (SWIG_arg_fail(2)) SWIG_fail;
10704 if (arg2 == NULL) {
10705 SWIG_null_ref("wxDC");
10706 }
10707 if (SWIG_arg_fail(2)) SWIG_fail;
10708 }
10709 {
10710 if (! PySequence_Check(obj2)) {
10711 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
10712 SWIG_fail;
10713 }
10714 arg3 = new wxArrayString;
10715 temp3 = true;
10716 int i, len=PySequence_Length(obj2);
10717 for (i=0; i<len; i++) {
10718 PyObject* item = PySequence_GetItem(obj2, i);
10719 wxString* s = wxString_in_helper(item);
10720 if (PyErr_Occurred()) SWIG_fail;
10721 arg3->Add(*s);
10722 delete s;
10723 Py_DECREF(item);
10724 }
10725 }
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
10729
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 Py_INCREF(Py_None); resultobj = Py_None;
10734 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10735 SWIG_From_long((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, 0)));
10736 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
10737 SWIG_From_long((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, 0)));
10738 {
10739 if (temp3) delete arg3;
10740 }
10741 return resultobj;
10742 fail:
10743 {
10744 if (temp3) delete arg3;
10745 }
10746 return NULL;
10747 }
10748
10749
10750 static PyObject *_wrap_Grid_BeginBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10751 PyObject *resultobj = NULL;
10752 wxGrid *arg1 = (wxGrid *) 0 ;
10753 PyObject * obj0 = 0 ;
10754 char *kwnames[] = {
10755 (char *) "self", NULL
10756 };
10757
10758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_BeginBatch",kwnames,&obj0)) goto fail;
10759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10760 if (SWIG_arg_fail(1)) SWIG_fail;
10761 {
10762 PyThreadState* __tstate = wxPyBeginAllowThreads();
10763 (arg1)->BeginBatch();
10764
10765 wxPyEndAllowThreads(__tstate);
10766 if (PyErr_Occurred()) SWIG_fail;
10767 }
10768 Py_INCREF(Py_None); resultobj = Py_None;
10769 return resultobj;
10770 fail:
10771 return NULL;
10772 }
10773
10774
10775 static PyObject *_wrap_Grid_EndBatch(PyObject *, PyObject *args, PyObject *kwargs) {
10776 PyObject *resultobj = NULL;
10777 wxGrid *arg1 = (wxGrid *) 0 ;
10778 PyObject * obj0 = 0 ;
10779 char *kwnames[] = {
10780 (char *) "self", NULL
10781 };
10782
10783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_EndBatch",kwnames,&obj0)) goto fail;
10784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10785 if (SWIG_arg_fail(1)) SWIG_fail;
10786 {
10787 PyThreadState* __tstate = wxPyBeginAllowThreads();
10788 (arg1)->EndBatch();
10789
10790 wxPyEndAllowThreads(__tstate);
10791 if (PyErr_Occurred()) SWIG_fail;
10792 }
10793 Py_INCREF(Py_None); resultobj = Py_None;
10794 return resultobj;
10795 fail:
10796 return NULL;
10797 }
10798
10799
10800 static PyObject *_wrap_Grid_GetBatchCount(PyObject *, PyObject *args, PyObject *kwargs) {
10801 PyObject *resultobj = NULL;
10802 wxGrid *arg1 = (wxGrid *) 0 ;
10803 int result;
10804 PyObject * obj0 = 0 ;
10805 char *kwnames[] = {
10806 (char *) "self", NULL
10807 };
10808
10809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetBatchCount",kwnames,&obj0)) goto fail;
10810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10811 if (SWIG_arg_fail(1)) SWIG_fail;
10812 {
10813 PyThreadState* __tstate = wxPyBeginAllowThreads();
10814 result = (int)(arg1)->GetBatchCount();
10815
10816 wxPyEndAllowThreads(__tstate);
10817 if (PyErr_Occurred()) SWIG_fail;
10818 }
10819 {
10820 resultobj = SWIG_From_int(static_cast<int >(result));
10821 }
10822 return resultobj;
10823 fail:
10824 return NULL;
10825 }
10826
10827
10828 static PyObject *_wrap_Grid_ForceRefresh(PyObject *, PyObject *args, PyObject *kwargs) {
10829 PyObject *resultobj = NULL;
10830 wxGrid *arg1 = (wxGrid *) 0 ;
10831 PyObject * obj0 = 0 ;
10832 char *kwnames[] = {
10833 (char *) "self", NULL
10834 };
10835
10836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ForceRefresh",kwnames,&obj0)) goto fail;
10837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10838 if (SWIG_arg_fail(1)) SWIG_fail;
10839 {
10840 PyThreadState* __tstate = wxPyBeginAllowThreads();
10841 (arg1)->ForceRefresh();
10842
10843 wxPyEndAllowThreads(__tstate);
10844 if (PyErr_Occurred()) SWIG_fail;
10845 }
10846 Py_INCREF(Py_None); resultobj = Py_None;
10847 return resultobj;
10848 fail:
10849 return NULL;
10850 }
10851
10852
10853 static PyObject *_wrap_Grid_IsEditable(PyObject *, PyObject *args, PyObject *kwargs) {
10854 PyObject *resultobj = NULL;
10855 wxGrid *arg1 = (wxGrid *) 0 ;
10856 bool result;
10857 PyObject * obj0 = 0 ;
10858 char *kwnames[] = {
10859 (char *) "self", NULL
10860 };
10861
10862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsEditable",kwnames,&obj0)) goto fail;
10863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10864 if (SWIG_arg_fail(1)) SWIG_fail;
10865 {
10866 PyThreadState* __tstate = wxPyBeginAllowThreads();
10867 result = (bool)(arg1)->IsEditable();
10868
10869 wxPyEndAllowThreads(__tstate);
10870 if (PyErr_Occurred()) SWIG_fail;
10871 }
10872 {
10873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10874 }
10875 return resultobj;
10876 fail:
10877 return NULL;
10878 }
10879
10880
10881 static PyObject *_wrap_Grid_EnableEditing(PyObject *, PyObject *args, PyObject *kwargs) {
10882 PyObject *resultobj = NULL;
10883 wxGrid *arg1 = (wxGrid *) 0 ;
10884 bool arg2 ;
10885 PyObject * obj0 = 0 ;
10886 PyObject * obj1 = 0 ;
10887 char *kwnames[] = {
10888 (char *) "self",(char *) "edit", NULL
10889 };
10890
10891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) goto fail;
10892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10893 if (SWIG_arg_fail(1)) SWIG_fail;
10894 {
10895 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10896 if (SWIG_arg_fail(2)) SWIG_fail;
10897 }
10898 {
10899 PyThreadState* __tstate = wxPyBeginAllowThreads();
10900 (arg1)->EnableEditing(arg2);
10901
10902 wxPyEndAllowThreads(__tstate);
10903 if (PyErr_Occurred()) SWIG_fail;
10904 }
10905 Py_INCREF(Py_None); resultobj = Py_None;
10906 return resultobj;
10907 fail:
10908 return NULL;
10909 }
10910
10911
10912 static PyObject *_wrap_Grid_EnableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10913 PyObject *resultobj = NULL;
10914 wxGrid *arg1 = (wxGrid *) 0 ;
10915 bool arg2 = (bool) true ;
10916 PyObject * obj0 = 0 ;
10917 PyObject * obj1 = 0 ;
10918 char *kwnames[] = {
10919 (char *) "self",(char *) "enable", NULL
10920 };
10921
10922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) goto fail;
10923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10924 if (SWIG_arg_fail(1)) SWIG_fail;
10925 if (obj1) {
10926 {
10927 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10928 if (SWIG_arg_fail(2)) SWIG_fail;
10929 }
10930 }
10931 {
10932 PyThreadState* __tstate = wxPyBeginAllowThreads();
10933 (arg1)->EnableCellEditControl(arg2);
10934
10935 wxPyEndAllowThreads(__tstate);
10936 if (PyErr_Occurred()) SWIG_fail;
10937 }
10938 Py_INCREF(Py_None); resultobj = Py_None;
10939 return resultobj;
10940 fail:
10941 return NULL;
10942 }
10943
10944
10945 static PyObject *_wrap_Grid_DisableCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
10946 PyObject *resultobj = NULL;
10947 wxGrid *arg1 = (wxGrid *) 0 ;
10948 PyObject * obj0 = 0 ;
10949 char *kwnames[] = {
10950 (char *) "self", NULL
10951 };
10952
10953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableCellEditControl",kwnames,&obj0)) goto fail;
10954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10955 if (SWIG_arg_fail(1)) SWIG_fail;
10956 {
10957 PyThreadState* __tstate = wxPyBeginAllowThreads();
10958 (arg1)->DisableCellEditControl();
10959
10960 wxPyEndAllowThreads(__tstate);
10961 if (PyErr_Occurred()) SWIG_fail;
10962 }
10963 Py_INCREF(Py_None); resultobj = Py_None;
10964 return resultobj;
10965 fail:
10966 return NULL;
10967 }
10968
10969
10970 static PyObject *_wrap_Grid_CanEnableCellControl(PyObject *, PyObject *args, PyObject *kwargs) {
10971 PyObject *resultobj = NULL;
10972 wxGrid *arg1 = (wxGrid *) 0 ;
10973 bool result;
10974 PyObject * obj0 = 0 ;
10975 char *kwnames[] = {
10976 (char *) "self", NULL
10977 };
10978
10979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanEnableCellControl",kwnames,&obj0)) goto fail;
10980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
10981 if (SWIG_arg_fail(1)) SWIG_fail;
10982 {
10983 PyThreadState* __tstate = wxPyBeginAllowThreads();
10984 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
10985
10986 wxPyEndAllowThreads(__tstate);
10987 if (PyErr_Occurred()) SWIG_fail;
10988 }
10989 {
10990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10991 }
10992 return resultobj;
10993 fail:
10994 return NULL;
10995 }
10996
10997
10998 static PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
10999 PyObject *resultobj = NULL;
11000 wxGrid *arg1 = (wxGrid *) 0 ;
11001 bool result;
11002 PyObject * obj0 = 0 ;
11003 char *kwnames[] = {
11004 (char *) "self", NULL
11005 };
11006
11007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlEnabled",kwnames,&obj0)) goto fail;
11008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11009 if (SWIG_arg_fail(1)) SWIG_fail;
11010 {
11011 PyThreadState* __tstate = wxPyBeginAllowThreads();
11012 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11013
11014 wxPyEndAllowThreads(__tstate);
11015 if (PyErr_Occurred()) SWIG_fail;
11016 }
11017 {
11018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11019 }
11020 return resultobj;
11021 fail:
11022 return NULL;
11023 }
11024
11025
11026 static PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *, PyObject *args, PyObject *kwargs) {
11027 PyObject *resultobj = NULL;
11028 wxGrid *arg1 = (wxGrid *) 0 ;
11029 bool result;
11030 PyObject * obj0 = 0 ;
11031 char *kwnames[] = {
11032 (char *) "self", NULL
11033 };
11034
11035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCellEditControlShown",kwnames,&obj0)) goto fail;
11036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11037 if (SWIG_arg_fail(1)) SWIG_fail;
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11041
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 {
11046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11047 }
11048 return resultobj;
11049 fail:
11050 return NULL;
11051 }
11052
11053
11054 static PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
11055 PyObject *resultobj = NULL;
11056 wxGrid *arg1 = (wxGrid *) 0 ;
11057 bool result;
11058 PyObject * obj0 = 0 ;
11059 char *kwnames[] = {
11060 (char *) "self", NULL
11061 };
11062
11063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsCurrentCellReadOnly",kwnames,&obj0)) goto fail;
11064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11065 if (SWIG_arg_fail(1)) SWIG_fail;
11066 {
11067 PyThreadState* __tstate = wxPyBeginAllowThreads();
11068 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11069
11070 wxPyEndAllowThreads(__tstate);
11071 if (PyErr_Occurred()) SWIG_fail;
11072 }
11073 {
11074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11075 }
11076 return resultobj;
11077 fail:
11078 return NULL;
11079 }
11080
11081
11082 static PyObject *_wrap_Grid_ShowCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
11083 PyObject *resultobj = NULL;
11084 wxGrid *arg1 = (wxGrid *) 0 ;
11085 PyObject * obj0 = 0 ;
11086 char *kwnames[] = {
11087 (char *) "self", NULL
11088 };
11089
11090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ShowCellEditControl",kwnames,&obj0)) goto fail;
11091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11092 if (SWIG_arg_fail(1)) SWIG_fail;
11093 {
11094 PyThreadState* __tstate = wxPyBeginAllowThreads();
11095 (arg1)->ShowCellEditControl();
11096
11097 wxPyEndAllowThreads(__tstate);
11098 if (PyErr_Occurred()) SWIG_fail;
11099 }
11100 Py_INCREF(Py_None); resultobj = Py_None;
11101 return resultobj;
11102 fail:
11103 return NULL;
11104 }
11105
11106
11107 static PyObject *_wrap_Grid_HideCellEditControl(PyObject *, PyObject *args, PyObject *kwargs) {
11108 PyObject *resultobj = NULL;
11109 wxGrid *arg1 = (wxGrid *) 0 ;
11110 PyObject * obj0 = 0 ;
11111 char *kwnames[] = {
11112 (char *) "self", NULL
11113 };
11114
11115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_HideCellEditControl",kwnames,&obj0)) goto fail;
11116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11117 if (SWIG_arg_fail(1)) SWIG_fail;
11118 {
11119 PyThreadState* __tstate = wxPyBeginAllowThreads();
11120 (arg1)->HideCellEditControl();
11121
11122 wxPyEndAllowThreads(__tstate);
11123 if (PyErr_Occurred()) SWIG_fail;
11124 }
11125 Py_INCREF(Py_None); resultobj = Py_None;
11126 return resultobj;
11127 fail:
11128 return NULL;
11129 }
11130
11131
11132 static PyObject *_wrap_Grid_SaveEditControlValue(PyObject *, PyObject *args, PyObject *kwargs) {
11133 PyObject *resultobj = NULL;
11134 wxGrid *arg1 = (wxGrid *) 0 ;
11135 PyObject * obj0 = 0 ;
11136 char *kwnames[] = {
11137 (char *) "self", NULL
11138 };
11139
11140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SaveEditControlValue",kwnames,&obj0)) goto fail;
11141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11142 if (SWIG_arg_fail(1)) SWIG_fail;
11143 {
11144 PyThreadState* __tstate = wxPyBeginAllowThreads();
11145 (arg1)->SaveEditControlValue();
11146
11147 wxPyEndAllowThreads(__tstate);
11148 if (PyErr_Occurred()) SWIG_fail;
11149 }
11150 Py_INCREF(Py_None); resultobj = Py_None;
11151 return resultobj;
11152 fail:
11153 return NULL;
11154 }
11155
11156
11157 static PyObject *_wrap_Grid_XYToCell(PyObject *, PyObject *args, PyObject *kwargs) {
11158 PyObject *resultobj = NULL;
11159 wxGrid *arg1 = (wxGrid *) 0 ;
11160 int arg2 ;
11161 int arg3 ;
11162 wxGridCellCoords result;
11163 PyObject * obj0 = 0 ;
11164 PyObject * obj1 = 0 ;
11165 PyObject * obj2 = 0 ;
11166 char *kwnames[] = {
11167 (char *) "self",(char *) "x",(char *) "y", NULL
11168 };
11169
11170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
11171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11172 if (SWIG_arg_fail(1)) SWIG_fail;
11173 {
11174 arg2 = static_cast<int >(SWIG_As_int(obj1));
11175 if (SWIG_arg_fail(2)) SWIG_fail;
11176 }
11177 {
11178 arg3 = static_cast<int >(SWIG_As_int(obj2));
11179 if (SWIG_arg_fail(3)) SWIG_fail;
11180 }
11181 {
11182 PyThreadState* __tstate = wxPyBeginAllowThreads();
11183 result = wxGrid_XYToCell(arg1,arg2,arg3);
11184
11185 wxPyEndAllowThreads(__tstate);
11186 if (PyErr_Occurred()) SWIG_fail;
11187 }
11188 {
11189 wxGridCellCoords * resultptr;
11190 resultptr = new wxGridCellCoords(static_cast<wxGridCellCoords & >(result));
11191 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
11192 }
11193 return resultobj;
11194 fail:
11195 return NULL;
11196 }
11197
11198
11199 static PyObject *_wrap_Grid_YToRow(PyObject *, PyObject *args, PyObject *kwargs) {
11200 PyObject *resultobj = NULL;
11201 wxGrid *arg1 = (wxGrid *) 0 ;
11202 int arg2 ;
11203 int result;
11204 PyObject * obj0 = 0 ;
11205 PyObject * obj1 = 0 ;
11206 char *kwnames[] = {
11207 (char *) "self",(char *) "y", NULL
11208 };
11209
11210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) goto fail;
11211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11212 if (SWIG_arg_fail(1)) SWIG_fail;
11213 {
11214 arg2 = static_cast<int >(SWIG_As_int(obj1));
11215 if (SWIG_arg_fail(2)) SWIG_fail;
11216 }
11217 {
11218 PyThreadState* __tstate = wxPyBeginAllowThreads();
11219 result = (int)(arg1)->YToRow(arg2);
11220
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 {
11225 resultobj = SWIG_From_int(static_cast<int >(result));
11226 }
11227 return resultobj;
11228 fail:
11229 return NULL;
11230 }
11231
11232
11233 static PyObject *_wrap_Grid_XToCol(PyObject *, PyObject *args, PyObject *kwargs) {
11234 PyObject *resultobj = NULL;
11235 wxGrid *arg1 = (wxGrid *) 0 ;
11236 int arg2 ;
11237 int result;
11238 PyObject * obj0 = 0 ;
11239 PyObject * obj1 = 0 ;
11240 char *kwnames[] = {
11241 (char *) "self",(char *) "x", NULL
11242 };
11243
11244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToCol",kwnames,&obj0,&obj1)) goto fail;
11245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11246 if (SWIG_arg_fail(1)) SWIG_fail;
11247 {
11248 arg2 = static_cast<int >(SWIG_As_int(obj1));
11249 if (SWIG_arg_fail(2)) SWIG_fail;
11250 }
11251 {
11252 PyThreadState* __tstate = wxPyBeginAllowThreads();
11253 result = (int)(arg1)->XToCol(arg2);
11254
11255 wxPyEndAllowThreads(__tstate);
11256 if (PyErr_Occurred()) SWIG_fail;
11257 }
11258 {
11259 resultobj = SWIG_From_int(static_cast<int >(result));
11260 }
11261 return resultobj;
11262 fail:
11263 return NULL;
11264 }
11265
11266
11267 static PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *, PyObject *args, PyObject *kwargs) {
11268 PyObject *resultobj = NULL;
11269 wxGrid *arg1 = (wxGrid *) 0 ;
11270 int arg2 ;
11271 int result;
11272 PyObject * obj0 = 0 ;
11273 PyObject * obj1 = 0 ;
11274 char *kwnames[] = {
11275 (char *) "self",(char *) "y", NULL
11276 };
11277
11278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) goto fail;
11279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11280 if (SWIG_arg_fail(1)) SWIG_fail;
11281 {
11282 arg2 = static_cast<int >(SWIG_As_int(obj1));
11283 if (SWIG_arg_fail(2)) SWIG_fail;
11284 }
11285 {
11286 PyThreadState* __tstate = wxPyBeginAllowThreads();
11287 result = (int)(arg1)->YToEdgeOfRow(arg2);
11288
11289 wxPyEndAllowThreads(__tstate);
11290 if (PyErr_Occurred()) SWIG_fail;
11291 }
11292 {
11293 resultobj = SWIG_From_int(static_cast<int >(result));
11294 }
11295 return resultobj;
11296 fail:
11297 return NULL;
11298 }
11299
11300
11301 static PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *, PyObject *args, PyObject *kwargs) {
11302 PyObject *resultobj = NULL;
11303 wxGrid *arg1 = (wxGrid *) 0 ;
11304 int arg2 ;
11305 int result;
11306 PyObject * obj0 = 0 ;
11307 PyObject * obj1 = 0 ;
11308 char *kwnames[] = {
11309 (char *) "self",(char *) "x", NULL
11310 };
11311
11312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) goto fail;
11313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11314 if (SWIG_arg_fail(1)) SWIG_fail;
11315 {
11316 arg2 = static_cast<int >(SWIG_As_int(obj1));
11317 if (SWIG_arg_fail(2)) SWIG_fail;
11318 }
11319 {
11320 PyThreadState* __tstate = wxPyBeginAllowThreads();
11321 result = (int)(arg1)->XToEdgeOfCol(arg2);
11322
11323 wxPyEndAllowThreads(__tstate);
11324 if (PyErr_Occurred()) SWIG_fail;
11325 }
11326 {
11327 resultobj = SWIG_From_int(static_cast<int >(result));
11328 }
11329 return resultobj;
11330 fail:
11331 return NULL;
11332 }
11333
11334
11335 static PyObject *_wrap_Grid_CellToRect(PyObject *, PyObject *args, PyObject *kwargs) {
11336 PyObject *resultobj = NULL;
11337 wxGrid *arg1 = (wxGrid *) 0 ;
11338 int arg2 ;
11339 int arg3 ;
11340 wxRect result;
11341 PyObject * obj0 = 0 ;
11342 PyObject * obj1 = 0 ;
11343 PyObject * obj2 = 0 ;
11344 char *kwnames[] = {
11345 (char *) "self",(char *) "row",(char *) "col", NULL
11346 };
11347
11348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
11349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11350 if (SWIG_arg_fail(1)) SWIG_fail;
11351 {
11352 arg2 = static_cast<int >(SWIG_As_int(obj1));
11353 if (SWIG_arg_fail(2)) SWIG_fail;
11354 }
11355 {
11356 arg3 = static_cast<int >(SWIG_As_int(obj2));
11357 if (SWIG_arg_fail(3)) SWIG_fail;
11358 }
11359 {
11360 PyThreadState* __tstate = wxPyBeginAllowThreads();
11361 result = (arg1)->CellToRect(arg2,arg3);
11362
11363 wxPyEndAllowThreads(__tstate);
11364 if (PyErr_Occurred()) SWIG_fail;
11365 }
11366 {
11367 wxRect * resultptr;
11368 resultptr = new wxRect(static_cast<wxRect & >(result));
11369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
11370 }
11371 return resultobj;
11372 fail:
11373 return NULL;
11374 }
11375
11376
11377 static PyObject *_wrap_Grid_GetGridCursorRow(PyObject *, PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj = NULL;
11379 wxGrid *arg1 = (wxGrid *) 0 ;
11380 int result;
11381 PyObject * obj0 = 0 ;
11382 char *kwnames[] = {
11383 (char *) "self", NULL
11384 };
11385
11386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorRow",kwnames,&obj0)) goto fail;
11387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11388 if (SWIG_arg_fail(1)) SWIG_fail;
11389 {
11390 PyThreadState* __tstate = wxPyBeginAllowThreads();
11391 result = (int)(arg1)->GetGridCursorRow();
11392
11393 wxPyEndAllowThreads(__tstate);
11394 if (PyErr_Occurred()) SWIG_fail;
11395 }
11396 {
11397 resultobj = SWIG_From_int(static_cast<int >(result));
11398 }
11399 return resultobj;
11400 fail:
11401 return NULL;
11402 }
11403
11404
11405 static PyObject *_wrap_Grid_GetGridCursorCol(PyObject *, PyObject *args, PyObject *kwargs) {
11406 PyObject *resultobj = NULL;
11407 wxGrid *arg1 = (wxGrid *) 0 ;
11408 int result;
11409 PyObject * obj0 = 0 ;
11410 char *kwnames[] = {
11411 (char *) "self", NULL
11412 };
11413
11414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCursorCol",kwnames,&obj0)) goto fail;
11415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11416 if (SWIG_arg_fail(1)) SWIG_fail;
11417 {
11418 PyThreadState* __tstate = wxPyBeginAllowThreads();
11419 result = (int)(arg1)->GetGridCursorCol();
11420
11421 wxPyEndAllowThreads(__tstate);
11422 if (PyErr_Occurred()) SWIG_fail;
11423 }
11424 {
11425 resultobj = SWIG_From_int(static_cast<int >(result));
11426 }
11427 return resultobj;
11428 fail:
11429 return NULL;
11430 }
11431
11432
11433 static PyObject *_wrap_Grid_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11434 PyObject *resultobj = NULL;
11435 wxGrid *arg1 = (wxGrid *) 0 ;
11436 int arg2 ;
11437 int arg3 ;
11438 bool arg4 = (bool) true ;
11439 bool result;
11440 PyObject * obj0 = 0 ;
11441 PyObject * obj1 = 0 ;
11442 PyObject * obj2 = 0 ;
11443 PyObject * obj3 = 0 ;
11444 char *kwnames[] = {
11445 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
11446 };
11447
11448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11450 if (SWIG_arg_fail(1)) SWIG_fail;
11451 {
11452 arg2 = static_cast<int >(SWIG_As_int(obj1));
11453 if (SWIG_arg_fail(2)) SWIG_fail;
11454 }
11455 {
11456 arg3 = static_cast<int >(SWIG_As_int(obj2));
11457 if (SWIG_arg_fail(3)) SWIG_fail;
11458 }
11459 if (obj3) {
11460 {
11461 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11462 if (SWIG_arg_fail(4)) SWIG_fail;
11463 }
11464 }
11465 {
11466 PyThreadState* __tstate = wxPyBeginAllowThreads();
11467 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
11468
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 {
11473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11474 }
11475 return resultobj;
11476 fail:
11477 return NULL;
11478 }
11479
11480
11481 static PyObject *_wrap_Grid_MakeCellVisible(PyObject *, PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj = NULL;
11483 wxGrid *arg1 = (wxGrid *) 0 ;
11484 int arg2 ;
11485 int arg3 ;
11486 PyObject * obj0 = 0 ;
11487 PyObject * obj1 = 0 ;
11488 PyObject * obj2 = 0 ;
11489 char *kwnames[] = {
11490 (char *) "self",(char *) "row",(char *) "col", NULL
11491 };
11492
11493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) goto fail;
11494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11495 if (SWIG_arg_fail(1)) SWIG_fail;
11496 {
11497 arg2 = static_cast<int >(SWIG_As_int(obj1));
11498 if (SWIG_arg_fail(2)) SWIG_fail;
11499 }
11500 {
11501 arg3 = static_cast<int >(SWIG_As_int(obj2));
11502 if (SWIG_arg_fail(3)) SWIG_fail;
11503 }
11504 {
11505 PyThreadState* __tstate = wxPyBeginAllowThreads();
11506 (arg1)->MakeCellVisible(arg2,arg3);
11507
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 Py_INCREF(Py_None); resultobj = Py_None;
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 static PyObject *_wrap_Grid_SetGridCursor(PyObject *, PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj = NULL;
11520 wxGrid *arg1 = (wxGrid *) 0 ;
11521 int arg2 ;
11522 int arg3 ;
11523 PyObject * obj0 = 0 ;
11524 PyObject * obj1 = 0 ;
11525 PyObject * obj2 = 0 ;
11526 char *kwnames[] = {
11527 (char *) "self",(char *) "row",(char *) "col", NULL
11528 };
11529
11530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
11531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11532 if (SWIG_arg_fail(1)) SWIG_fail;
11533 {
11534 arg2 = static_cast<int >(SWIG_As_int(obj1));
11535 if (SWIG_arg_fail(2)) SWIG_fail;
11536 }
11537 {
11538 arg3 = static_cast<int >(SWIG_As_int(obj2));
11539 if (SWIG_arg_fail(3)) SWIG_fail;
11540 }
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 (arg1)->SetGridCursor(arg2,arg3);
11544
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 Py_INCREF(Py_None); resultobj = Py_None;
11549 return resultobj;
11550 fail:
11551 return NULL;
11552 }
11553
11554
11555 static PyObject *_wrap_Grid_MoveCursorUp(PyObject *, PyObject *args, PyObject *kwargs) {
11556 PyObject *resultobj = NULL;
11557 wxGrid *arg1 = (wxGrid *) 0 ;
11558 bool arg2 ;
11559 bool result;
11560 PyObject * obj0 = 0 ;
11561 PyObject * obj1 = 0 ;
11562 char *kwnames[] = {
11563 (char *) "self",(char *) "expandSelection", NULL
11564 };
11565
11566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) goto fail;
11567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11568 if (SWIG_arg_fail(1)) SWIG_fail;
11569 {
11570 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11571 if (SWIG_arg_fail(2)) SWIG_fail;
11572 }
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 result = (bool)(arg1)->MoveCursorUp(arg2);
11576
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 {
11581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11582 }
11583 return resultobj;
11584 fail:
11585 return NULL;
11586 }
11587
11588
11589 static PyObject *_wrap_Grid_MoveCursorDown(PyObject *, PyObject *args, PyObject *kwargs) {
11590 PyObject *resultobj = NULL;
11591 wxGrid *arg1 = (wxGrid *) 0 ;
11592 bool arg2 ;
11593 bool result;
11594 PyObject * obj0 = 0 ;
11595 PyObject * obj1 = 0 ;
11596 char *kwnames[] = {
11597 (char *) "self",(char *) "expandSelection", NULL
11598 };
11599
11600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) goto fail;
11601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11602 if (SWIG_arg_fail(1)) SWIG_fail;
11603 {
11604 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11605 if (SWIG_arg_fail(2)) SWIG_fail;
11606 }
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (bool)(arg1)->MoveCursorDown(arg2);
11610
11611 wxPyEndAllowThreads(__tstate);
11612 if (PyErr_Occurred()) SWIG_fail;
11613 }
11614 {
11615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11616 }
11617 return resultobj;
11618 fail:
11619 return NULL;
11620 }
11621
11622
11623 static PyObject *_wrap_Grid_MoveCursorLeft(PyObject *, PyObject *args, PyObject *kwargs) {
11624 PyObject *resultobj = NULL;
11625 wxGrid *arg1 = (wxGrid *) 0 ;
11626 bool arg2 ;
11627 bool result;
11628 PyObject * obj0 = 0 ;
11629 PyObject * obj1 = 0 ;
11630 char *kwnames[] = {
11631 (char *) "self",(char *) "expandSelection", NULL
11632 };
11633
11634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) goto fail;
11635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11636 if (SWIG_arg_fail(1)) SWIG_fail;
11637 {
11638 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11639 if (SWIG_arg_fail(2)) SWIG_fail;
11640 }
11641 {
11642 PyThreadState* __tstate = wxPyBeginAllowThreads();
11643 result = (bool)(arg1)->MoveCursorLeft(arg2);
11644
11645 wxPyEndAllowThreads(__tstate);
11646 if (PyErr_Occurred()) SWIG_fail;
11647 }
11648 {
11649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11650 }
11651 return resultobj;
11652 fail:
11653 return NULL;
11654 }
11655
11656
11657 static PyObject *_wrap_Grid_MoveCursorRight(PyObject *, PyObject *args, PyObject *kwargs) {
11658 PyObject *resultobj = NULL;
11659 wxGrid *arg1 = (wxGrid *) 0 ;
11660 bool arg2 ;
11661 bool result;
11662 PyObject * obj0 = 0 ;
11663 PyObject * obj1 = 0 ;
11664 char *kwnames[] = {
11665 (char *) "self",(char *) "expandSelection", NULL
11666 };
11667
11668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) goto fail;
11669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11670 if (SWIG_arg_fail(1)) SWIG_fail;
11671 {
11672 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11673 if (SWIG_arg_fail(2)) SWIG_fail;
11674 }
11675 {
11676 PyThreadState* __tstate = wxPyBeginAllowThreads();
11677 result = (bool)(arg1)->MoveCursorRight(arg2);
11678
11679 wxPyEndAllowThreads(__tstate);
11680 if (PyErr_Occurred()) SWIG_fail;
11681 }
11682 {
11683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11684 }
11685 return resultobj;
11686 fail:
11687 return NULL;
11688 }
11689
11690
11691 static PyObject *_wrap_Grid_MovePageDown(PyObject *, PyObject *args, PyObject *kwargs) {
11692 PyObject *resultobj = NULL;
11693 wxGrid *arg1 = (wxGrid *) 0 ;
11694 bool result;
11695 PyObject * obj0 = 0 ;
11696 char *kwnames[] = {
11697 (char *) "self", NULL
11698 };
11699
11700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageDown",kwnames,&obj0)) goto fail;
11701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11702 if (SWIG_arg_fail(1)) SWIG_fail;
11703 {
11704 PyThreadState* __tstate = wxPyBeginAllowThreads();
11705 result = (bool)(arg1)->MovePageDown();
11706
11707 wxPyEndAllowThreads(__tstate);
11708 if (PyErr_Occurred()) SWIG_fail;
11709 }
11710 {
11711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11712 }
11713 return resultobj;
11714 fail:
11715 return NULL;
11716 }
11717
11718
11719 static PyObject *_wrap_Grid_MovePageUp(PyObject *, PyObject *args, PyObject *kwargs) {
11720 PyObject *resultobj = NULL;
11721 wxGrid *arg1 = (wxGrid *) 0 ;
11722 bool result;
11723 PyObject * obj0 = 0 ;
11724 char *kwnames[] = {
11725 (char *) "self", NULL
11726 };
11727
11728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_MovePageUp",kwnames,&obj0)) goto fail;
11729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11730 if (SWIG_arg_fail(1)) SWIG_fail;
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 result = (bool)(arg1)->MovePageUp();
11734
11735 wxPyEndAllowThreads(__tstate);
11736 if (PyErr_Occurred()) SWIG_fail;
11737 }
11738 {
11739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11740 }
11741 return resultobj;
11742 fail:
11743 return NULL;
11744 }
11745
11746
11747 static PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11748 PyObject *resultobj = NULL;
11749 wxGrid *arg1 = (wxGrid *) 0 ;
11750 bool arg2 ;
11751 bool result;
11752 PyObject * obj0 = 0 ;
11753 PyObject * obj1 = 0 ;
11754 char *kwnames[] = {
11755 (char *) "self",(char *) "expandSelection", NULL
11756 };
11757
11758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) goto fail;
11759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11760 if (SWIG_arg_fail(1)) SWIG_fail;
11761 {
11762 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11763 if (SWIG_arg_fail(2)) SWIG_fail;
11764 }
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
11768
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11774 }
11775 return resultobj;
11776 fail:
11777 return NULL;
11778 }
11779
11780
11781 static PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11782 PyObject *resultobj = NULL;
11783 wxGrid *arg1 = (wxGrid *) 0 ;
11784 bool arg2 ;
11785 bool result;
11786 PyObject * obj0 = 0 ;
11787 PyObject * obj1 = 0 ;
11788 char *kwnames[] = {
11789 (char *) "self",(char *) "expandSelection", NULL
11790 };
11791
11792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) goto fail;
11793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11794 if (SWIG_arg_fail(1)) SWIG_fail;
11795 {
11796 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11797 if (SWIG_arg_fail(2)) SWIG_fail;
11798 }
11799 {
11800 PyThreadState* __tstate = wxPyBeginAllowThreads();
11801 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
11802
11803 wxPyEndAllowThreads(__tstate);
11804 if (PyErr_Occurred()) SWIG_fail;
11805 }
11806 {
11807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11808 }
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 static PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11816 PyObject *resultobj = NULL;
11817 wxGrid *arg1 = (wxGrid *) 0 ;
11818 bool arg2 ;
11819 bool result;
11820 PyObject * obj0 = 0 ;
11821 PyObject * obj1 = 0 ;
11822 char *kwnames[] = {
11823 (char *) "self",(char *) "expandSelection", NULL
11824 };
11825
11826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) goto fail;
11827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11828 if (SWIG_arg_fail(1)) SWIG_fail;
11829 {
11830 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11831 if (SWIG_arg_fail(2)) SWIG_fail;
11832 }
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
11836
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 {
11841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11842 }
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 static PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *, PyObject *args, PyObject *kwargs) {
11850 PyObject *resultobj = NULL;
11851 wxGrid *arg1 = (wxGrid *) 0 ;
11852 bool arg2 ;
11853 bool result;
11854 PyObject * obj0 = 0 ;
11855 PyObject * obj1 = 0 ;
11856 char *kwnames[] = {
11857 (char *) "self",(char *) "expandSelection", NULL
11858 };
11859
11860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) goto fail;
11861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11862 if (SWIG_arg_fail(1)) SWIG_fail;
11863 {
11864 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
11865 if (SWIG_arg_fail(2)) SWIG_fail;
11866 }
11867 {
11868 PyThreadState* __tstate = wxPyBeginAllowThreads();
11869 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
11870
11871 wxPyEndAllowThreads(__tstate);
11872 if (PyErr_Occurred()) SWIG_fail;
11873 }
11874 {
11875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11876 }
11877 return resultobj;
11878 fail:
11879 return NULL;
11880 }
11881
11882
11883 static PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11884 PyObject *resultobj = NULL;
11885 wxGrid *arg1 = (wxGrid *) 0 ;
11886 int result;
11887 PyObject * obj0 = 0 ;
11888 char *kwnames[] = {
11889 (char *) "self", NULL
11890 };
11891
11892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowLabelSize",kwnames,&obj0)) goto fail;
11893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11894 if (SWIG_arg_fail(1)) SWIG_fail;
11895 {
11896 PyThreadState* __tstate = wxPyBeginAllowThreads();
11897 result = (int)(arg1)->GetDefaultRowLabelSize();
11898
11899 wxPyEndAllowThreads(__tstate);
11900 if (PyErr_Occurred()) SWIG_fail;
11901 }
11902 {
11903 resultobj = SWIG_From_int(static_cast<int >(result));
11904 }
11905 return resultobj;
11906 fail:
11907 return NULL;
11908 }
11909
11910
11911 static PyObject *_wrap_Grid_GetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11912 PyObject *resultobj = NULL;
11913 wxGrid *arg1 = (wxGrid *) 0 ;
11914 int result;
11915 PyObject * obj0 = 0 ;
11916 char *kwnames[] = {
11917 (char *) "self", NULL
11918 };
11919
11920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelSize",kwnames,&obj0)) goto fail;
11921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11922 if (SWIG_arg_fail(1)) SWIG_fail;
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 result = (int)(arg1)->GetRowLabelSize();
11926
11927 wxPyEndAllowThreads(__tstate);
11928 if (PyErr_Occurred()) SWIG_fail;
11929 }
11930 {
11931 resultobj = SWIG_From_int(static_cast<int >(result));
11932 }
11933 return resultobj;
11934 fail:
11935 return NULL;
11936 }
11937
11938
11939 static PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11940 PyObject *resultobj = NULL;
11941 wxGrid *arg1 = (wxGrid *) 0 ;
11942 int result;
11943 PyObject * obj0 = 0 ;
11944 char *kwnames[] = {
11945 (char *) "self", NULL
11946 };
11947
11948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColLabelSize",kwnames,&obj0)) goto fail;
11949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11950 if (SWIG_arg_fail(1)) SWIG_fail;
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (int)(arg1)->GetDefaultColLabelSize();
11954
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 {
11959 resultobj = SWIG_From_int(static_cast<int >(result));
11960 }
11961 return resultobj;
11962 fail:
11963 return NULL;
11964 }
11965
11966
11967 static PyObject *_wrap_Grid_GetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
11968 PyObject *resultobj = NULL;
11969 wxGrid *arg1 = (wxGrid *) 0 ;
11970 int result;
11971 PyObject * obj0 = 0 ;
11972 char *kwnames[] = {
11973 (char *) "self", NULL
11974 };
11975
11976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelSize",kwnames,&obj0)) goto fail;
11977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
11978 if (SWIG_arg_fail(1)) SWIG_fail;
11979 {
11980 PyThreadState* __tstate = wxPyBeginAllowThreads();
11981 result = (int)(arg1)->GetColLabelSize();
11982
11983 wxPyEndAllowThreads(__tstate);
11984 if (PyErr_Occurred()) SWIG_fail;
11985 }
11986 {
11987 resultobj = SWIG_From_int(static_cast<int >(result));
11988 }
11989 return resultobj;
11990 fail:
11991 return NULL;
11992 }
11993
11994
11995 static PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
11996 PyObject *resultobj = NULL;
11997 wxGrid *arg1 = (wxGrid *) 0 ;
11998 wxColour result;
11999 PyObject * obj0 = 0 ;
12000 char *kwnames[] = {
12001 (char *) "self", NULL
12002 };
12003
12004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelBackgroundColour",kwnames,&obj0)) goto fail;
12005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12006 if (SWIG_arg_fail(1)) SWIG_fail;
12007 {
12008 PyThreadState* __tstate = wxPyBeginAllowThreads();
12009 result = (arg1)->GetLabelBackgroundColour();
12010
12011 wxPyEndAllowThreads(__tstate);
12012 if (PyErr_Occurred()) SWIG_fail;
12013 }
12014 {
12015 wxColour * resultptr;
12016 resultptr = new wxColour(static_cast<wxColour & >(result));
12017 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12018 }
12019 return resultobj;
12020 fail:
12021 return NULL;
12022 }
12023
12024
12025 static PyObject *_wrap_Grid_GetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
12026 PyObject *resultobj = NULL;
12027 wxGrid *arg1 = (wxGrid *) 0 ;
12028 wxColour result;
12029 PyObject * obj0 = 0 ;
12030 char *kwnames[] = {
12031 (char *) "self", NULL
12032 };
12033
12034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelTextColour",kwnames,&obj0)) goto fail;
12035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12036 if (SWIG_arg_fail(1)) SWIG_fail;
12037 {
12038 PyThreadState* __tstate = wxPyBeginAllowThreads();
12039 result = (arg1)->GetLabelTextColour();
12040
12041 wxPyEndAllowThreads(__tstate);
12042 if (PyErr_Occurred()) SWIG_fail;
12043 }
12044 {
12045 wxColour * resultptr;
12046 resultptr = new wxColour(static_cast<wxColour & >(result));
12047 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12048 }
12049 return resultobj;
12050 fail:
12051 return NULL;
12052 }
12053
12054
12055 static PyObject *_wrap_Grid_GetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
12056 PyObject *resultobj = NULL;
12057 wxGrid *arg1 = (wxGrid *) 0 ;
12058 wxFont result;
12059 PyObject * obj0 = 0 ;
12060 char *kwnames[] = {
12061 (char *) "self", NULL
12062 };
12063
12064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetLabelFont",kwnames,&obj0)) goto fail;
12065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12066 if (SWIG_arg_fail(1)) SWIG_fail;
12067 {
12068 PyThreadState* __tstate = wxPyBeginAllowThreads();
12069 result = (arg1)->GetLabelFont();
12070
12071 wxPyEndAllowThreads(__tstate);
12072 if (PyErr_Occurred()) SWIG_fail;
12073 }
12074 {
12075 wxFont * resultptr;
12076 resultptr = new wxFont(static_cast<wxFont & >(result));
12077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
12078 }
12079 return resultobj;
12080 fail:
12081 return NULL;
12082 }
12083
12084
12085 static PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12086 PyObject *resultobj = NULL;
12087 wxGrid *arg1 = (wxGrid *) 0 ;
12088 int *arg2 = (int *) 0 ;
12089 int *arg3 = (int *) 0 ;
12090 int temp2 ;
12091 int res2 = 0 ;
12092 int temp3 ;
12093 int res3 = 0 ;
12094 PyObject * obj0 = 0 ;
12095 char *kwnames[] = {
12096 (char *) "self", NULL
12097 };
12098
12099 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12100 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowLabelAlignment",kwnames,&obj0)) goto fail;
12102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12103 if (SWIG_arg_fail(1)) SWIG_fail;
12104 {
12105 PyThreadState* __tstate = wxPyBeginAllowThreads();
12106 (arg1)->GetRowLabelAlignment(arg2,arg3);
12107
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 Py_INCREF(Py_None); resultobj = Py_None;
12112 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12113 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
12114 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12115 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
12116 return resultobj;
12117 fail:
12118 return NULL;
12119 }
12120
12121
12122 static PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12123 PyObject *resultobj = NULL;
12124 wxGrid *arg1 = (wxGrid *) 0 ;
12125 int *arg2 = (int *) 0 ;
12126 int *arg3 = (int *) 0 ;
12127 int temp2 ;
12128 int res2 = 0 ;
12129 int temp3 ;
12130 int res3 = 0 ;
12131 PyObject * obj0 = 0 ;
12132 char *kwnames[] = {
12133 (char *) "self", NULL
12134 };
12135
12136 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12137 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelAlignment",kwnames,&obj0)) goto fail;
12139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12140 if (SWIG_arg_fail(1)) SWIG_fail;
12141 {
12142 PyThreadState* __tstate = wxPyBeginAllowThreads();
12143 (arg1)->GetColLabelAlignment(arg2,arg3);
12144
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 Py_INCREF(Py_None); resultobj = Py_None;
12149 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12150 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
12151 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12152 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
12153 return resultobj;
12154 fail:
12155 return NULL;
12156 }
12157
12158
12159 static PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
12160 PyObject *resultobj = NULL;
12161 wxGrid *arg1 = (wxGrid *) 0 ;
12162 int result;
12163 PyObject * obj0 = 0 ;
12164 char *kwnames[] = {
12165 (char *) "self", NULL
12166 };
12167
12168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColLabelTextOrientation",kwnames,&obj0)) goto fail;
12169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12170 if (SWIG_arg_fail(1)) SWIG_fail;
12171 {
12172 PyThreadState* __tstate = wxPyBeginAllowThreads();
12173 result = (int)(arg1)->GetColLabelTextOrientation();
12174
12175 wxPyEndAllowThreads(__tstate);
12176 if (PyErr_Occurred()) SWIG_fail;
12177 }
12178 {
12179 resultobj = SWIG_From_int(static_cast<int >(result));
12180 }
12181 return resultobj;
12182 fail:
12183 return NULL;
12184 }
12185
12186
12187 static PyObject *_wrap_Grid_GetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12188 PyObject *resultobj = NULL;
12189 wxGrid *arg1 = (wxGrid *) 0 ;
12190 int arg2 ;
12191 wxString result;
12192 PyObject * obj0 = 0 ;
12193 PyObject * obj1 = 0 ;
12194 char *kwnames[] = {
12195 (char *) "self",(char *) "row", NULL
12196 };
12197
12198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) goto fail;
12199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12200 if (SWIG_arg_fail(1)) SWIG_fail;
12201 {
12202 arg2 = static_cast<int >(SWIG_As_int(obj1));
12203 if (SWIG_arg_fail(2)) SWIG_fail;
12204 }
12205 {
12206 PyThreadState* __tstate = wxPyBeginAllowThreads();
12207 result = (arg1)->GetRowLabelValue(arg2);
12208
12209 wxPyEndAllowThreads(__tstate);
12210 if (PyErr_Occurred()) SWIG_fail;
12211 }
12212 {
12213 #if wxUSE_UNICODE
12214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12215 #else
12216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12217 #endif
12218 }
12219 return resultobj;
12220 fail:
12221 return NULL;
12222 }
12223
12224
12225 static PyObject *_wrap_Grid_GetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12226 PyObject *resultobj = NULL;
12227 wxGrid *arg1 = (wxGrid *) 0 ;
12228 int arg2 ;
12229 wxString result;
12230 PyObject * obj0 = 0 ;
12231 PyObject * obj1 = 0 ;
12232 char *kwnames[] = {
12233 (char *) "self",(char *) "col", NULL
12234 };
12235
12236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) goto fail;
12237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12238 if (SWIG_arg_fail(1)) SWIG_fail;
12239 {
12240 arg2 = static_cast<int >(SWIG_As_int(obj1));
12241 if (SWIG_arg_fail(2)) SWIG_fail;
12242 }
12243 {
12244 PyThreadState* __tstate = wxPyBeginAllowThreads();
12245 result = (arg1)->GetColLabelValue(arg2);
12246
12247 wxPyEndAllowThreads(__tstate);
12248 if (PyErr_Occurred()) SWIG_fail;
12249 }
12250 {
12251 #if wxUSE_UNICODE
12252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12253 #else
12254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12255 #endif
12256 }
12257 return resultobj;
12258 fail:
12259 return NULL;
12260 }
12261
12262
12263 static PyObject *_wrap_Grid_GetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12264 PyObject *resultobj = NULL;
12265 wxGrid *arg1 = (wxGrid *) 0 ;
12266 wxColour result;
12267 PyObject * obj0 = 0 ;
12268 char *kwnames[] = {
12269 (char *) "self", NULL
12270 };
12271
12272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridLineColour",kwnames,&obj0)) goto fail;
12273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12274 if (SWIG_arg_fail(1)) SWIG_fail;
12275 {
12276 PyThreadState* __tstate = wxPyBeginAllowThreads();
12277 result = (arg1)->GetGridLineColour();
12278
12279 wxPyEndAllowThreads(__tstate);
12280 if (PyErr_Occurred()) SWIG_fail;
12281 }
12282 {
12283 wxColour * resultptr;
12284 resultptr = new wxColour(static_cast<wxColour & >(result));
12285 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12286 }
12287 return resultobj;
12288 fail:
12289 return NULL;
12290 }
12291
12292
12293 static PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12294 PyObject *resultobj = NULL;
12295 wxGrid *arg1 = (wxGrid *) 0 ;
12296 wxColour result;
12297 PyObject * obj0 = 0 ;
12298 char *kwnames[] = {
12299 (char *) "self", NULL
12300 };
12301
12302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightColour",kwnames,&obj0)) goto fail;
12303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12304 if (SWIG_arg_fail(1)) SWIG_fail;
12305 {
12306 PyThreadState* __tstate = wxPyBeginAllowThreads();
12307 result = (arg1)->GetCellHighlightColour();
12308
12309 wxPyEndAllowThreads(__tstate);
12310 if (PyErr_Occurred()) SWIG_fail;
12311 }
12312 {
12313 wxColour * resultptr;
12314 resultptr = new wxColour(static_cast<wxColour & >(result));
12315 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12316 }
12317 return resultobj;
12318 fail:
12319 return NULL;
12320 }
12321
12322
12323 static PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12324 PyObject *resultobj = NULL;
12325 wxGrid *arg1 = (wxGrid *) 0 ;
12326 int result;
12327 PyObject * obj0 = 0 ;
12328 char *kwnames[] = {
12329 (char *) "self", NULL
12330 };
12331
12332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightPenWidth",kwnames,&obj0)) goto fail;
12333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12334 if (SWIG_arg_fail(1)) SWIG_fail;
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 result = (int)(arg1)->GetCellHighlightPenWidth();
12338
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 {
12343 resultobj = SWIG_From_int(static_cast<int >(result));
12344 }
12345 return resultobj;
12346 fail:
12347 return NULL;
12348 }
12349
12350
12351 static PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12352 PyObject *resultobj = NULL;
12353 wxGrid *arg1 = (wxGrid *) 0 ;
12354 int result;
12355 PyObject * obj0 = 0 ;
12356 char *kwnames[] = {
12357 (char *) "self", NULL
12358 };
12359
12360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetCellHighlightROPenWidth",kwnames,&obj0)) goto fail;
12361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12362 if (SWIG_arg_fail(1)) SWIG_fail;
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 result = (int)(arg1)->GetCellHighlightROPenWidth();
12366
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 {
12371 resultobj = SWIG_From_int(static_cast<int >(result));
12372 }
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_Grid_SetRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj = NULL;
12381 wxGrid *arg1 = (wxGrid *) 0 ;
12382 int arg2 ;
12383 PyObject * obj0 = 0 ;
12384 PyObject * obj1 = 0 ;
12385 char *kwnames[] = {
12386 (char *) "self",(char *) "width", NULL
12387 };
12388
12389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
12390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12391 if (SWIG_arg_fail(1)) SWIG_fail;
12392 {
12393 arg2 = static_cast<int >(SWIG_As_int(obj1));
12394 if (SWIG_arg_fail(2)) SWIG_fail;
12395 }
12396 {
12397 PyThreadState* __tstate = wxPyBeginAllowThreads();
12398 (arg1)->SetRowLabelSize(arg2);
12399
12400 wxPyEndAllowThreads(__tstate);
12401 if (PyErr_Occurred()) SWIG_fail;
12402 }
12403 Py_INCREF(Py_None); resultobj = Py_None;
12404 return resultobj;
12405 fail:
12406 return NULL;
12407 }
12408
12409
12410 static PyObject *_wrap_Grid_SetColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
12411 PyObject *resultobj = NULL;
12412 wxGrid *arg1 = (wxGrid *) 0 ;
12413 int arg2 ;
12414 PyObject * obj0 = 0 ;
12415 PyObject * obj1 = 0 ;
12416 char *kwnames[] = {
12417 (char *) "self",(char *) "height", NULL
12418 };
12419
12420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) goto fail;
12421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12422 if (SWIG_arg_fail(1)) SWIG_fail;
12423 {
12424 arg2 = static_cast<int >(SWIG_As_int(obj1));
12425 if (SWIG_arg_fail(2)) SWIG_fail;
12426 }
12427 {
12428 PyThreadState* __tstate = wxPyBeginAllowThreads();
12429 (arg1)->SetColLabelSize(arg2);
12430
12431 wxPyEndAllowThreads(__tstate);
12432 if (PyErr_Occurred()) SWIG_fail;
12433 }
12434 Py_INCREF(Py_None); resultobj = Py_None;
12435 return resultobj;
12436 fail:
12437 return NULL;
12438 }
12439
12440
12441 static PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
12442 PyObject *resultobj = NULL;
12443 wxGrid *arg1 = (wxGrid *) 0 ;
12444 wxColour *arg2 = 0 ;
12445 wxColour temp2 ;
12446 PyObject * obj0 = 0 ;
12447 PyObject * obj1 = 0 ;
12448 char *kwnames[] = {
12449 (char *) "self","arg2", NULL
12450 };
12451
12452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
12453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12454 if (SWIG_arg_fail(1)) SWIG_fail;
12455 {
12456 arg2 = &temp2;
12457 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12458 }
12459 {
12460 PyThreadState* __tstate = wxPyBeginAllowThreads();
12461 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
12462
12463 wxPyEndAllowThreads(__tstate);
12464 if (PyErr_Occurred()) SWIG_fail;
12465 }
12466 Py_INCREF(Py_None); resultobj = Py_None;
12467 return resultobj;
12468 fail:
12469 return NULL;
12470 }
12471
12472
12473 static PyObject *_wrap_Grid_SetLabelTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
12474 PyObject *resultobj = NULL;
12475 wxGrid *arg1 = (wxGrid *) 0 ;
12476 wxColour *arg2 = 0 ;
12477 wxColour temp2 ;
12478 PyObject * obj0 = 0 ;
12479 PyObject * obj1 = 0 ;
12480 char *kwnames[] = {
12481 (char *) "self","arg2", NULL
12482 };
12483
12484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) goto fail;
12485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12486 if (SWIG_arg_fail(1)) SWIG_fail;
12487 {
12488 arg2 = &temp2;
12489 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12490 }
12491 {
12492 PyThreadState* __tstate = wxPyBeginAllowThreads();
12493 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
12494
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 Py_INCREF(Py_None); resultobj = Py_None;
12499 return resultobj;
12500 fail:
12501 return NULL;
12502 }
12503
12504
12505 static PyObject *_wrap_Grid_SetLabelFont(PyObject *, PyObject *args, PyObject *kwargs) {
12506 PyObject *resultobj = NULL;
12507 wxGrid *arg1 = (wxGrid *) 0 ;
12508 wxFont *arg2 = 0 ;
12509 PyObject * obj0 = 0 ;
12510 PyObject * obj1 = 0 ;
12511 char *kwnames[] = {
12512 (char *) "self","arg2", NULL
12513 };
12514
12515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) goto fail;
12516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12517 if (SWIG_arg_fail(1)) SWIG_fail;
12518 {
12519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
12520 if (SWIG_arg_fail(2)) SWIG_fail;
12521 if (arg2 == NULL) {
12522 SWIG_null_ref("wxFont");
12523 }
12524 if (SWIG_arg_fail(2)) SWIG_fail;
12525 }
12526 {
12527 PyThreadState* __tstate = wxPyBeginAllowThreads();
12528 (arg1)->SetLabelFont((wxFont const &)*arg2);
12529
12530 wxPyEndAllowThreads(__tstate);
12531 if (PyErr_Occurred()) SWIG_fail;
12532 }
12533 Py_INCREF(Py_None); resultobj = Py_None;
12534 return resultobj;
12535 fail:
12536 return NULL;
12537 }
12538
12539
12540 static PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12541 PyObject *resultobj = NULL;
12542 wxGrid *arg1 = (wxGrid *) 0 ;
12543 int arg2 ;
12544 int arg3 ;
12545 PyObject * obj0 = 0 ;
12546 PyObject * obj1 = 0 ;
12547 PyObject * obj2 = 0 ;
12548 char *kwnames[] = {
12549 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12550 };
12551
12552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12554 if (SWIG_arg_fail(1)) SWIG_fail;
12555 {
12556 arg2 = static_cast<int >(SWIG_As_int(obj1));
12557 if (SWIG_arg_fail(2)) SWIG_fail;
12558 }
12559 {
12560 arg3 = static_cast<int >(SWIG_As_int(obj2));
12561 if (SWIG_arg_fail(3)) SWIG_fail;
12562 }
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 (arg1)->SetRowLabelAlignment(arg2,arg3);
12566
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 Py_INCREF(Py_None); resultobj = Py_None;
12571 return resultobj;
12572 fail:
12573 return NULL;
12574 }
12575
12576
12577 static PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
12578 PyObject *resultobj = NULL;
12579 wxGrid *arg1 = (wxGrid *) 0 ;
12580 int arg2 ;
12581 int arg3 ;
12582 PyObject * obj0 = 0 ;
12583 PyObject * obj1 = 0 ;
12584 PyObject * obj2 = 0 ;
12585 char *kwnames[] = {
12586 (char *) "self",(char *) "horiz",(char *) "vert", NULL
12587 };
12588
12589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
12590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12591 if (SWIG_arg_fail(1)) SWIG_fail;
12592 {
12593 arg2 = static_cast<int >(SWIG_As_int(obj1));
12594 if (SWIG_arg_fail(2)) SWIG_fail;
12595 }
12596 {
12597 arg3 = static_cast<int >(SWIG_As_int(obj2));
12598 if (SWIG_arg_fail(3)) SWIG_fail;
12599 }
12600 {
12601 PyThreadState* __tstate = wxPyBeginAllowThreads();
12602 (arg1)->SetColLabelAlignment(arg2,arg3);
12603
12604 wxPyEndAllowThreads(__tstate);
12605 if (PyErr_Occurred()) SWIG_fail;
12606 }
12607 Py_INCREF(Py_None); resultobj = Py_None;
12608 return resultobj;
12609 fail:
12610 return NULL;
12611 }
12612
12613
12614 static PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
12615 PyObject *resultobj = NULL;
12616 wxGrid *arg1 = (wxGrid *) 0 ;
12617 int arg2 ;
12618 PyObject * obj0 = 0 ;
12619 PyObject * obj1 = 0 ;
12620 char *kwnames[] = {
12621 (char *) "self",(char *) "textOrientation", NULL
12622 };
12623
12624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) goto fail;
12625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12626 if (SWIG_arg_fail(1)) SWIG_fail;
12627 {
12628 arg2 = static_cast<int >(SWIG_As_int(obj1));
12629 if (SWIG_arg_fail(2)) SWIG_fail;
12630 }
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 (arg1)->SetColLabelTextOrientation(arg2);
12634
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 Py_INCREF(Py_None); resultobj = Py_None;
12639 return resultobj;
12640 fail:
12641 return NULL;
12642 }
12643
12644
12645 static PyObject *_wrap_Grid_SetRowLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12646 PyObject *resultobj = NULL;
12647 wxGrid *arg1 = (wxGrid *) 0 ;
12648 int arg2 ;
12649 wxString *arg3 = 0 ;
12650 bool temp3 = false ;
12651 PyObject * obj0 = 0 ;
12652 PyObject * obj1 = 0 ;
12653 PyObject * obj2 = 0 ;
12654 char *kwnames[] = {
12655 (char *) "self",(char *) "row","arg3", NULL
12656 };
12657
12658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12660 if (SWIG_arg_fail(1)) SWIG_fail;
12661 {
12662 arg2 = static_cast<int >(SWIG_As_int(obj1));
12663 if (SWIG_arg_fail(2)) SWIG_fail;
12664 }
12665 {
12666 arg3 = wxString_in_helper(obj2);
12667 if (arg3 == NULL) SWIG_fail;
12668 temp3 = true;
12669 }
12670 {
12671 PyThreadState* __tstate = wxPyBeginAllowThreads();
12672 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
12673
12674 wxPyEndAllowThreads(__tstate);
12675 if (PyErr_Occurred()) SWIG_fail;
12676 }
12677 Py_INCREF(Py_None); resultobj = Py_None;
12678 {
12679 if (temp3)
12680 delete arg3;
12681 }
12682 return resultobj;
12683 fail:
12684 {
12685 if (temp3)
12686 delete arg3;
12687 }
12688 return NULL;
12689 }
12690
12691
12692 static PyObject *_wrap_Grid_SetColLabelValue(PyObject *, PyObject *args, PyObject *kwargs) {
12693 PyObject *resultobj = NULL;
12694 wxGrid *arg1 = (wxGrid *) 0 ;
12695 int arg2 ;
12696 wxString *arg3 = 0 ;
12697 bool temp3 = false ;
12698 PyObject * obj0 = 0 ;
12699 PyObject * obj1 = 0 ;
12700 PyObject * obj2 = 0 ;
12701 char *kwnames[] = {
12702 (char *) "self",(char *) "col","arg3", NULL
12703 };
12704
12705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12707 if (SWIG_arg_fail(1)) SWIG_fail;
12708 {
12709 arg2 = static_cast<int >(SWIG_As_int(obj1));
12710 if (SWIG_arg_fail(2)) SWIG_fail;
12711 }
12712 {
12713 arg3 = wxString_in_helper(obj2);
12714 if (arg3 == NULL) SWIG_fail;
12715 temp3 = true;
12716 }
12717 {
12718 PyThreadState* __tstate = wxPyBeginAllowThreads();
12719 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
12720
12721 wxPyEndAllowThreads(__tstate);
12722 if (PyErr_Occurred()) SWIG_fail;
12723 }
12724 Py_INCREF(Py_None); resultobj = Py_None;
12725 {
12726 if (temp3)
12727 delete arg3;
12728 }
12729 return resultobj;
12730 fail:
12731 {
12732 if (temp3)
12733 delete arg3;
12734 }
12735 return NULL;
12736 }
12737
12738
12739 static PyObject *_wrap_Grid_SetGridLineColour(PyObject *, PyObject *args, PyObject *kwargs) {
12740 PyObject *resultobj = NULL;
12741 wxGrid *arg1 = (wxGrid *) 0 ;
12742 wxColour *arg2 = 0 ;
12743 wxColour temp2 ;
12744 PyObject * obj0 = 0 ;
12745 PyObject * obj1 = 0 ;
12746 char *kwnames[] = {
12747 (char *) "self","arg2", NULL
12748 };
12749
12750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) goto fail;
12751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12752 if (SWIG_arg_fail(1)) SWIG_fail;
12753 {
12754 arg2 = &temp2;
12755 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12756 }
12757 {
12758 PyThreadState* __tstate = wxPyBeginAllowThreads();
12759 (arg1)->SetGridLineColour((wxColour const &)*arg2);
12760
12761 wxPyEndAllowThreads(__tstate);
12762 if (PyErr_Occurred()) SWIG_fail;
12763 }
12764 Py_INCREF(Py_None); resultobj = Py_None;
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 static PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
12772 PyObject *resultobj = NULL;
12773 wxGrid *arg1 = (wxGrid *) 0 ;
12774 wxColour *arg2 = 0 ;
12775 wxColour temp2 ;
12776 PyObject * obj0 = 0 ;
12777 PyObject * obj1 = 0 ;
12778 char *kwnames[] = {
12779 (char *) "self","arg2", NULL
12780 };
12781
12782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) goto fail;
12783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12784 if (SWIG_arg_fail(1)) SWIG_fail;
12785 {
12786 arg2 = &temp2;
12787 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12788 }
12789 {
12790 PyThreadState* __tstate = wxPyBeginAllowThreads();
12791 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
12792
12793 wxPyEndAllowThreads(__tstate);
12794 if (PyErr_Occurred()) SWIG_fail;
12795 }
12796 Py_INCREF(Py_None); resultobj = Py_None;
12797 return resultobj;
12798 fail:
12799 return NULL;
12800 }
12801
12802
12803 static PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12804 PyObject *resultobj = NULL;
12805 wxGrid *arg1 = (wxGrid *) 0 ;
12806 int arg2 ;
12807 PyObject * obj0 = 0 ;
12808 PyObject * obj1 = 0 ;
12809 char *kwnames[] = {
12810 (char *) "self",(char *) "width", NULL
12811 };
12812
12813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) goto fail;
12814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12815 if (SWIG_arg_fail(1)) SWIG_fail;
12816 {
12817 arg2 = static_cast<int >(SWIG_As_int(obj1));
12818 if (SWIG_arg_fail(2)) SWIG_fail;
12819 }
12820 {
12821 PyThreadState* __tstate = wxPyBeginAllowThreads();
12822 (arg1)->SetCellHighlightPenWidth(arg2);
12823
12824 wxPyEndAllowThreads(__tstate);
12825 if (PyErr_Occurred()) SWIG_fail;
12826 }
12827 Py_INCREF(Py_None); resultobj = Py_None;
12828 return resultobj;
12829 fail:
12830 return NULL;
12831 }
12832
12833
12834 static PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12835 PyObject *resultobj = NULL;
12836 wxGrid *arg1 = (wxGrid *) 0 ;
12837 int arg2 ;
12838 PyObject * obj0 = 0 ;
12839 PyObject * obj1 = 0 ;
12840 char *kwnames[] = {
12841 (char *) "self",(char *) "width", NULL
12842 };
12843
12844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) goto fail;
12845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12846 if (SWIG_arg_fail(1)) SWIG_fail;
12847 {
12848 arg2 = static_cast<int >(SWIG_As_int(obj1));
12849 if (SWIG_arg_fail(2)) SWIG_fail;
12850 }
12851 {
12852 PyThreadState* __tstate = wxPyBeginAllowThreads();
12853 (arg1)->SetCellHighlightROPenWidth(arg2);
12854
12855 wxPyEndAllowThreads(__tstate);
12856 if (PyErr_Occurred()) SWIG_fail;
12857 }
12858 Py_INCREF(Py_None); resultobj = Py_None;
12859 return resultobj;
12860 fail:
12861 return NULL;
12862 }
12863
12864
12865 static PyObject *_wrap_Grid_EnableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12866 PyObject *resultobj = NULL;
12867 wxGrid *arg1 = (wxGrid *) 0 ;
12868 bool arg2 = (bool) true ;
12869 PyObject * obj0 = 0 ;
12870 PyObject * obj1 = 0 ;
12871 char *kwnames[] = {
12872 (char *) "self",(char *) "enable", NULL
12873 };
12874
12875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) goto fail;
12876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12877 if (SWIG_arg_fail(1)) SWIG_fail;
12878 if (obj1) {
12879 {
12880 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
12881 if (SWIG_arg_fail(2)) SWIG_fail;
12882 }
12883 }
12884 {
12885 PyThreadState* __tstate = wxPyBeginAllowThreads();
12886 (arg1)->EnableDragRowSize(arg2);
12887
12888 wxPyEndAllowThreads(__tstate);
12889 if (PyErr_Occurred()) SWIG_fail;
12890 }
12891 Py_INCREF(Py_None); resultobj = Py_None;
12892 return resultobj;
12893 fail:
12894 return NULL;
12895 }
12896
12897
12898 static PyObject *_wrap_Grid_DisableDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12899 PyObject *resultobj = NULL;
12900 wxGrid *arg1 = (wxGrid *) 0 ;
12901 PyObject * obj0 = 0 ;
12902 char *kwnames[] = {
12903 (char *) "self", NULL
12904 };
12905
12906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragRowSize",kwnames,&obj0)) goto fail;
12907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12908 if (SWIG_arg_fail(1)) SWIG_fail;
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 (arg1)->DisableDragRowSize();
12912
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 Py_INCREF(Py_None); resultobj = Py_None;
12917 return resultobj;
12918 fail:
12919 return NULL;
12920 }
12921
12922
12923 static PyObject *_wrap_Grid_CanDragRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
12924 PyObject *resultobj = NULL;
12925 wxGrid *arg1 = (wxGrid *) 0 ;
12926 bool result;
12927 PyObject * obj0 = 0 ;
12928 char *kwnames[] = {
12929 (char *) "self", NULL
12930 };
12931
12932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragRowSize",kwnames,&obj0)) goto fail;
12933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12934 if (SWIG_arg_fail(1)) SWIG_fail;
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 result = (bool)(arg1)->CanDragRowSize();
12938
12939 wxPyEndAllowThreads(__tstate);
12940 if (PyErr_Occurred()) SWIG_fail;
12941 }
12942 {
12943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12944 }
12945 return resultobj;
12946 fail:
12947 return NULL;
12948 }
12949
12950
12951 static PyObject *_wrap_Grid_EnableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12952 PyObject *resultobj = NULL;
12953 wxGrid *arg1 = (wxGrid *) 0 ;
12954 bool arg2 = (bool) true ;
12955 PyObject * obj0 = 0 ;
12956 PyObject * obj1 = 0 ;
12957 char *kwnames[] = {
12958 (char *) "self",(char *) "enable", NULL
12959 };
12960
12961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) goto fail;
12962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12963 if (SWIG_arg_fail(1)) SWIG_fail;
12964 if (obj1) {
12965 {
12966 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
12967 if (SWIG_arg_fail(2)) SWIG_fail;
12968 }
12969 }
12970 {
12971 PyThreadState* __tstate = wxPyBeginAllowThreads();
12972 (arg1)->EnableDragColSize(arg2);
12973
12974 wxPyEndAllowThreads(__tstate);
12975 if (PyErr_Occurred()) SWIG_fail;
12976 }
12977 Py_INCREF(Py_None); resultobj = Py_None;
12978 return resultobj;
12979 fail:
12980 return NULL;
12981 }
12982
12983
12984 static PyObject *_wrap_Grid_DisableDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
12985 PyObject *resultobj = NULL;
12986 wxGrid *arg1 = (wxGrid *) 0 ;
12987 PyObject * obj0 = 0 ;
12988 char *kwnames[] = {
12989 (char *) "self", NULL
12990 };
12991
12992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragColSize",kwnames,&obj0)) goto fail;
12993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
12994 if (SWIG_arg_fail(1)) SWIG_fail;
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 (arg1)->DisableDragColSize();
12998
12999 wxPyEndAllowThreads(__tstate);
13000 if (PyErr_Occurred()) SWIG_fail;
13001 }
13002 Py_INCREF(Py_None); resultobj = Py_None;
13003 return resultobj;
13004 fail:
13005 return NULL;
13006 }
13007
13008
13009 static PyObject *_wrap_Grid_CanDragColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13010 PyObject *resultobj = NULL;
13011 wxGrid *arg1 = (wxGrid *) 0 ;
13012 bool result;
13013 PyObject * obj0 = 0 ;
13014 char *kwnames[] = {
13015 (char *) "self", NULL
13016 };
13017
13018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragColSize",kwnames,&obj0)) goto fail;
13019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13020 if (SWIG_arg_fail(1)) SWIG_fail;
13021 {
13022 PyThreadState* __tstate = wxPyBeginAllowThreads();
13023 result = (bool)(arg1)->CanDragColSize();
13024
13025 wxPyEndAllowThreads(__tstate);
13026 if (PyErr_Occurred()) SWIG_fail;
13027 }
13028 {
13029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13030 }
13031 return resultobj;
13032 fail:
13033 return NULL;
13034 }
13035
13036
13037 static PyObject *_wrap_Grid_EnableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
13038 PyObject *resultobj = NULL;
13039 wxGrid *arg1 = (wxGrid *) 0 ;
13040 bool arg2 = (bool) true ;
13041 PyObject * obj0 = 0 ;
13042 PyObject * obj1 = 0 ;
13043 char *kwnames[] = {
13044 (char *) "self",(char *) "enable", NULL
13045 };
13046
13047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) goto fail;
13048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13049 if (SWIG_arg_fail(1)) SWIG_fail;
13050 if (obj1) {
13051 {
13052 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13053 if (SWIG_arg_fail(2)) SWIG_fail;
13054 }
13055 }
13056 {
13057 PyThreadState* __tstate = wxPyBeginAllowThreads();
13058 (arg1)->EnableDragGridSize(arg2);
13059
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 Py_INCREF(Py_None); resultobj = Py_None;
13064 return resultobj;
13065 fail:
13066 return NULL;
13067 }
13068
13069
13070 static PyObject *_wrap_Grid_DisableDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
13071 PyObject *resultobj = NULL;
13072 wxGrid *arg1 = (wxGrid *) 0 ;
13073 PyObject * obj0 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragGridSize",kwnames,&obj0)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 {
13082 PyThreadState* __tstate = wxPyBeginAllowThreads();
13083 (arg1)->DisableDragGridSize();
13084
13085 wxPyEndAllowThreads(__tstate);
13086 if (PyErr_Occurred()) SWIG_fail;
13087 }
13088 Py_INCREF(Py_None); resultobj = Py_None;
13089 return resultobj;
13090 fail:
13091 return NULL;
13092 }
13093
13094
13095 static PyObject *_wrap_Grid_CanDragGridSize(PyObject *, PyObject *args, PyObject *kwargs) {
13096 PyObject *resultobj = NULL;
13097 wxGrid *arg1 = (wxGrid *) 0 ;
13098 bool result;
13099 PyObject * obj0 = 0 ;
13100 char *kwnames[] = {
13101 (char *) "self", NULL
13102 };
13103
13104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragGridSize",kwnames,&obj0)) goto fail;
13105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13106 if (SWIG_arg_fail(1)) SWIG_fail;
13107 {
13108 PyThreadState* __tstate = wxPyBeginAllowThreads();
13109 result = (bool)(arg1)->CanDragGridSize();
13110
13111 wxPyEndAllowThreads(__tstate);
13112 if (PyErr_Occurred()) SWIG_fail;
13113 }
13114 {
13115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13116 }
13117 return resultobj;
13118 fail:
13119 return NULL;
13120 }
13121
13122
13123 static PyObject *_wrap_Grid_EnableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
13124 PyObject *resultobj = NULL;
13125 wxGrid *arg1 = (wxGrid *) 0 ;
13126 bool arg2 = (bool) true ;
13127 PyObject * obj0 = 0 ;
13128 PyObject * obj1 = 0 ;
13129 char *kwnames[] = {
13130 (char *) "self",(char *) "enable", NULL
13131 };
13132
13133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) goto fail;
13134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13135 if (SWIG_arg_fail(1)) SWIG_fail;
13136 if (obj1) {
13137 {
13138 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13139 if (SWIG_arg_fail(2)) SWIG_fail;
13140 }
13141 }
13142 {
13143 PyThreadState* __tstate = wxPyBeginAllowThreads();
13144 (arg1)->EnableDragCell(arg2);
13145
13146 wxPyEndAllowThreads(__tstate);
13147 if (PyErr_Occurred()) SWIG_fail;
13148 }
13149 Py_INCREF(Py_None); resultobj = Py_None;
13150 return resultobj;
13151 fail:
13152 return NULL;
13153 }
13154
13155
13156 static PyObject *_wrap_Grid_DisableDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
13157 PyObject *resultobj = NULL;
13158 wxGrid *arg1 = (wxGrid *) 0 ;
13159 PyObject * obj0 = 0 ;
13160 char *kwnames[] = {
13161 (char *) "self", NULL
13162 };
13163
13164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_DisableDragCell",kwnames,&obj0)) goto fail;
13165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13166 if (SWIG_arg_fail(1)) SWIG_fail;
13167 {
13168 PyThreadState* __tstate = wxPyBeginAllowThreads();
13169 (arg1)->DisableDragCell();
13170
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 Py_INCREF(Py_None); resultobj = Py_None;
13175 return resultobj;
13176 fail:
13177 return NULL;
13178 }
13179
13180
13181 static PyObject *_wrap_Grid_CanDragCell(PyObject *, PyObject *args, PyObject *kwargs) {
13182 PyObject *resultobj = NULL;
13183 wxGrid *arg1 = (wxGrid *) 0 ;
13184 bool result;
13185 PyObject * obj0 = 0 ;
13186 char *kwnames[] = {
13187 (char *) "self", NULL
13188 };
13189
13190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_CanDragCell",kwnames,&obj0)) goto fail;
13191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13192 if (SWIG_arg_fail(1)) SWIG_fail;
13193 {
13194 PyThreadState* __tstate = wxPyBeginAllowThreads();
13195 result = (bool)(arg1)->CanDragCell();
13196
13197 wxPyEndAllowThreads(__tstate);
13198 if (PyErr_Occurred()) SWIG_fail;
13199 }
13200 {
13201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13202 }
13203 return resultobj;
13204 fail:
13205 return NULL;
13206 }
13207
13208
13209 static PyObject *_wrap_Grid_SetAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13210 PyObject *resultobj = NULL;
13211 wxGrid *arg1 = (wxGrid *) 0 ;
13212 int arg2 ;
13213 int arg3 ;
13214 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
13215 PyObject * obj0 = 0 ;
13216 PyObject * obj1 = 0 ;
13217 PyObject * obj2 = 0 ;
13218 PyObject * obj3 = 0 ;
13219 char *kwnames[] = {
13220 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
13221 };
13222
13223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13225 if (SWIG_arg_fail(1)) SWIG_fail;
13226 {
13227 arg2 = static_cast<int >(SWIG_As_int(obj1));
13228 if (SWIG_arg_fail(2)) SWIG_fail;
13229 }
13230 {
13231 arg3 = static_cast<int >(SWIG_As_int(obj2));
13232 if (SWIG_arg_fail(3)) SWIG_fail;
13233 }
13234 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13235 if (SWIG_arg_fail(4)) SWIG_fail;
13236 {
13237 PyThreadState* __tstate = wxPyBeginAllowThreads();
13238 (arg1)->SetAttr(arg2,arg3,arg4);
13239
13240 wxPyEndAllowThreads(__tstate);
13241 if (PyErr_Occurred()) SWIG_fail;
13242 }
13243 Py_INCREF(Py_None); resultobj = Py_None;
13244 return resultobj;
13245 fail:
13246 return NULL;
13247 }
13248
13249
13250 static PyObject *_wrap_Grid_SetRowAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13251 PyObject *resultobj = NULL;
13252 wxGrid *arg1 = (wxGrid *) 0 ;
13253 int arg2 ;
13254 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13255 PyObject * obj0 = 0 ;
13256 PyObject * obj1 = 0 ;
13257 PyObject * obj2 = 0 ;
13258 char *kwnames[] = {
13259 (char *) "self",(char *) "row",(char *) "attr", NULL
13260 };
13261
13262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13264 if (SWIG_arg_fail(1)) SWIG_fail;
13265 {
13266 arg2 = static_cast<int >(SWIG_As_int(obj1));
13267 if (SWIG_arg_fail(2)) SWIG_fail;
13268 }
13269 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13270 if (SWIG_arg_fail(3)) SWIG_fail;
13271 {
13272 PyThreadState* __tstate = wxPyBeginAllowThreads();
13273 (arg1)->SetRowAttr(arg2,arg3);
13274
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 Py_INCREF(Py_None); resultobj = Py_None;
13279 return resultobj;
13280 fail:
13281 return NULL;
13282 }
13283
13284
13285 static PyObject *_wrap_Grid_SetColAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13286 PyObject *resultobj = NULL;
13287 wxGrid *arg1 = (wxGrid *) 0 ;
13288 int arg2 ;
13289 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
13290 PyObject * obj0 = 0 ;
13291 PyObject * obj1 = 0 ;
13292 PyObject * obj2 = 0 ;
13293 char *kwnames[] = {
13294 (char *) "self",(char *) "col",(char *) "attr", NULL
13295 };
13296
13297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13299 if (SWIG_arg_fail(1)) SWIG_fail;
13300 {
13301 arg2 = static_cast<int >(SWIG_As_int(obj1));
13302 if (SWIG_arg_fail(2)) SWIG_fail;
13303 }
13304 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_EXCEPTION | 0);
13305 if (SWIG_arg_fail(3)) SWIG_fail;
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 (arg1)->SetColAttr(arg2,arg3);
13309
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 Py_INCREF(Py_None); resultobj = Py_None;
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 static PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *, PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj = NULL;
13322 wxGrid *arg1 = (wxGrid *) 0 ;
13323 int arg2 ;
13324 int arg3 ;
13325 wxGridCellAttr *result;
13326 PyObject * obj0 = 0 ;
13327 PyObject * obj1 = 0 ;
13328 PyObject * obj2 = 0 ;
13329 char *kwnames[] = {
13330 (char *) "self",(char *) "row",(char *) "col", NULL
13331 };
13332
13333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) goto fail;
13334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13335 if (SWIG_arg_fail(1)) SWIG_fail;
13336 {
13337 arg2 = static_cast<int >(SWIG_As_int(obj1));
13338 if (SWIG_arg_fail(2)) SWIG_fail;
13339 }
13340 {
13341 arg3 = static_cast<int >(SWIG_As_int(obj2));
13342 if (SWIG_arg_fail(3)) SWIG_fail;
13343 }
13344 {
13345 PyThreadState* __tstate = wxPyBeginAllowThreads();
13346 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
13347
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 {
13352 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
13353 }
13354 return resultobj;
13355 fail:
13356 return NULL;
13357 }
13358
13359
13360 static PyObject *_wrap_Grid_SetColFormatBool(PyObject *, PyObject *args, PyObject *kwargs) {
13361 PyObject *resultobj = NULL;
13362 wxGrid *arg1 = (wxGrid *) 0 ;
13363 int arg2 ;
13364 PyObject * obj0 = 0 ;
13365 PyObject * obj1 = 0 ;
13366 char *kwnames[] = {
13367 (char *) "self",(char *) "col", NULL
13368 };
13369
13370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) goto fail;
13371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13372 if (SWIG_arg_fail(1)) SWIG_fail;
13373 {
13374 arg2 = static_cast<int >(SWIG_As_int(obj1));
13375 if (SWIG_arg_fail(2)) SWIG_fail;
13376 }
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 (arg1)->SetColFormatBool(arg2);
13380
13381 wxPyEndAllowThreads(__tstate);
13382 if (PyErr_Occurred()) SWIG_fail;
13383 }
13384 Py_INCREF(Py_None); resultobj = Py_None;
13385 return resultobj;
13386 fail:
13387 return NULL;
13388 }
13389
13390
13391 static PyObject *_wrap_Grid_SetColFormatNumber(PyObject *, PyObject *args, PyObject *kwargs) {
13392 PyObject *resultobj = NULL;
13393 wxGrid *arg1 = (wxGrid *) 0 ;
13394 int arg2 ;
13395 PyObject * obj0 = 0 ;
13396 PyObject * obj1 = 0 ;
13397 char *kwnames[] = {
13398 (char *) "self",(char *) "col", NULL
13399 };
13400
13401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) goto fail;
13402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13403 if (SWIG_arg_fail(1)) SWIG_fail;
13404 {
13405 arg2 = static_cast<int >(SWIG_As_int(obj1));
13406 if (SWIG_arg_fail(2)) SWIG_fail;
13407 }
13408 {
13409 PyThreadState* __tstate = wxPyBeginAllowThreads();
13410 (arg1)->SetColFormatNumber(arg2);
13411
13412 wxPyEndAllowThreads(__tstate);
13413 if (PyErr_Occurred()) SWIG_fail;
13414 }
13415 Py_INCREF(Py_None); resultobj = Py_None;
13416 return resultobj;
13417 fail:
13418 return NULL;
13419 }
13420
13421
13422 static PyObject *_wrap_Grid_SetColFormatFloat(PyObject *, PyObject *args, PyObject *kwargs) {
13423 PyObject *resultobj = NULL;
13424 wxGrid *arg1 = (wxGrid *) 0 ;
13425 int arg2 ;
13426 int arg3 = (int) -1 ;
13427 int arg4 = (int) -1 ;
13428 PyObject * obj0 = 0 ;
13429 PyObject * obj1 = 0 ;
13430 PyObject * obj2 = 0 ;
13431 PyObject * obj3 = 0 ;
13432 char *kwnames[] = {
13433 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
13434 };
13435
13436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13438 if (SWIG_arg_fail(1)) SWIG_fail;
13439 {
13440 arg2 = static_cast<int >(SWIG_As_int(obj1));
13441 if (SWIG_arg_fail(2)) SWIG_fail;
13442 }
13443 if (obj2) {
13444 {
13445 arg3 = static_cast<int >(SWIG_As_int(obj2));
13446 if (SWIG_arg_fail(3)) SWIG_fail;
13447 }
13448 }
13449 if (obj3) {
13450 {
13451 arg4 = static_cast<int >(SWIG_As_int(obj3));
13452 if (SWIG_arg_fail(4)) SWIG_fail;
13453 }
13454 }
13455 {
13456 PyThreadState* __tstate = wxPyBeginAllowThreads();
13457 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
13458
13459 wxPyEndAllowThreads(__tstate);
13460 if (PyErr_Occurred()) SWIG_fail;
13461 }
13462 Py_INCREF(Py_None); resultobj = Py_None;
13463 return resultobj;
13464 fail:
13465 return NULL;
13466 }
13467
13468
13469 static PyObject *_wrap_Grid_SetColFormatCustom(PyObject *, PyObject *args, PyObject *kwargs) {
13470 PyObject *resultobj = NULL;
13471 wxGrid *arg1 = (wxGrid *) 0 ;
13472 int arg2 ;
13473 wxString *arg3 = 0 ;
13474 bool temp3 = false ;
13475 PyObject * obj0 = 0 ;
13476 PyObject * obj1 = 0 ;
13477 PyObject * obj2 = 0 ;
13478 char *kwnames[] = {
13479 (char *) "self",(char *) "col",(char *) "typeName", NULL
13480 };
13481
13482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) goto fail;
13483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13484 if (SWIG_arg_fail(1)) SWIG_fail;
13485 {
13486 arg2 = static_cast<int >(SWIG_As_int(obj1));
13487 if (SWIG_arg_fail(2)) SWIG_fail;
13488 }
13489 {
13490 arg3 = wxString_in_helper(obj2);
13491 if (arg3 == NULL) SWIG_fail;
13492 temp3 = true;
13493 }
13494 {
13495 PyThreadState* __tstate = wxPyBeginAllowThreads();
13496 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
13497
13498 wxPyEndAllowThreads(__tstate);
13499 if (PyErr_Occurred()) SWIG_fail;
13500 }
13501 Py_INCREF(Py_None); resultobj = Py_None;
13502 {
13503 if (temp3)
13504 delete arg3;
13505 }
13506 return resultobj;
13507 fail:
13508 {
13509 if (temp3)
13510 delete arg3;
13511 }
13512 return NULL;
13513 }
13514
13515
13516 static PyObject *_wrap_Grid_EnableGridLines(PyObject *, PyObject *args, PyObject *kwargs) {
13517 PyObject *resultobj = NULL;
13518 wxGrid *arg1 = (wxGrid *) 0 ;
13519 bool arg2 = (bool) true ;
13520 PyObject * obj0 = 0 ;
13521 PyObject * obj1 = 0 ;
13522 char *kwnames[] = {
13523 (char *) "self",(char *) "enable", NULL
13524 };
13525
13526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) goto fail;
13527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13528 if (SWIG_arg_fail(1)) SWIG_fail;
13529 if (obj1) {
13530 {
13531 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13532 if (SWIG_arg_fail(2)) SWIG_fail;
13533 }
13534 }
13535 {
13536 PyThreadState* __tstate = wxPyBeginAllowThreads();
13537 (arg1)->EnableGridLines(arg2);
13538
13539 wxPyEndAllowThreads(__tstate);
13540 if (PyErr_Occurred()) SWIG_fail;
13541 }
13542 Py_INCREF(Py_None); resultobj = Py_None;
13543 return resultobj;
13544 fail:
13545 return NULL;
13546 }
13547
13548
13549 static PyObject *_wrap_Grid_GridLinesEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13550 PyObject *resultobj = NULL;
13551 wxGrid *arg1 = (wxGrid *) 0 ;
13552 bool result;
13553 PyObject * obj0 = 0 ;
13554 char *kwnames[] = {
13555 (char *) "self", NULL
13556 };
13557
13558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GridLinesEnabled",kwnames,&obj0)) goto fail;
13559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13560 if (SWIG_arg_fail(1)) SWIG_fail;
13561 {
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 result = (bool)(arg1)->GridLinesEnabled();
13564
13565 wxPyEndAllowThreads(__tstate);
13566 if (PyErr_Occurred()) SWIG_fail;
13567 }
13568 {
13569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13570 }
13571 return resultobj;
13572 fail:
13573 return NULL;
13574 }
13575
13576
13577 static PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj = NULL;
13579 wxGrid *arg1 = (wxGrid *) 0 ;
13580 int result;
13581 PyObject * obj0 = 0 ;
13582 char *kwnames[] = {
13583 (char *) "self", NULL
13584 };
13585
13586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRowSize",kwnames,&obj0)) goto fail;
13587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13588 if (SWIG_arg_fail(1)) SWIG_fail;
13589 {
13590 PyThreadState* __tstate = wxPyBeginAllowThreads();
13591 result = (int)(arg1)->GetDefaultRowSize();
13592
13593 wxPyEndAllowThreads(__tstate);
13594 if (PyErr_Occurred()) SWIG_fail;
13595 }
13596 {
13597 resultobj = SWIG_From_int(static_cast<int >(result));
13598 }
13599 return resultobj;
13600 fail:
13601 return NULL;
13602 }
13603
13604
13605 static PyObject *_wrap_Grid_GetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
13606 PyObject *resultobj = NULL;
13607 wxGrid *arg1 = (wxGrid *) 0 ;
13608 int arg2 ;
13609 int result;
13610 PyObject * obj0 = 0 ;
13611 PyObject * obj1 = 0 ;
13612 char *kwnames[] = {
13613 (char *) "self",(char *) "row", NULL
13614 };
13615
13616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) goto fail;
13617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13618 if (SWIG_arg_fail(1)) SWIG_fail;
13619 {
13620 arg2 = static_cast<int >(SWIG_As_int(obj1));
13621 if (SWIG_arg_fail(2)) SWIG_fail;
13622 }
13623 {
13624 PyThreadState* __tstate = wxPyBeginAllowThreads();
13625 result = (int)(arg1)->GetRowSize(arg2);
13626
13627 wxPyEndAllowThreads(__tstate);
13628 if (PyErr_Occurred()) SWIG_fail;
13629 }
13630 {
13631 resultobj = SWIG_From_int(static_cast<int >(result));
13632 }
13633 return resultobj;
13634 fail:
13635 return NULL;
13636 }
13637
13638
13639 static PyObject *_wrap_Grid_GetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13640 PyObject *resultobj = NULL;
13641 wxGrid *arg1 = (wxGrid *) 0 ;
13642 int result;
13643 PyObject * obj0 = 0 ;
13644 char *kwnames[] = {
13645 (char *) "self", NULL
13646 };
13647
13648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultColSize",kwnames,&obj0)) goto fail;
13649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13650 if (SWIG_arg_fail(1)) SWIG_fail;
13651 {
13652 PyThreadState* __tstate = wxPyBeginAllowThreads();
13653 result = (int)(arg1)->GetDefaultColSize();
13654
13655 wxPyEndAllowThreads(__tstate);
13656 if (PyErr_Occurred()) SWIG_fail;
13657 }
13658 {
13659 resultobj = SWIG_From_int(static_cast<int >(result));
13660 }
13661 return resultobj;
13662 fail:
13663 return NULL;
13664 }
13665
13666
13667 static PyObject *_wrap_Grid_GetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
13668 PyObject *resultobj = NULL;
13669 wxGrid *arg1 = (wxGrid *) 0 ;
13670 int arg2 ;
13671 int result;
13672 PyObject * obj0 = 0 ;
13673 PyObject * obj1 = 0 ;
13674 char *kwnames[] = {
13675 (char *) "self",(char *) "col", NULL
13676 };
13677
13678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) goto fail;
13679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13680 if (SWIG_arg_fail(1)) SWIG_fail;
13681 {
13682 arg2 = static_cast<int >(SWIG_As_int(obj1));
13683 if (SWIG_arg_fail(2)) SWIG_fail;
13684 }
13685 {
13686 PyThreadState* __tstate = wxPyBeginAllowThreads();
13687 result = (int)(arg1)->GetColSize(arg2);
13688
13689 wxPyEndAllowThreads(__tstate);
13690 if (PyErr_Occurred()) SWIG_fail;
13691 }
13692 {
13693 resultobj = SWIG_From_int(static_cast<int >(result));
13694 }
13695 return resultobj;
13696 fail:
13697 return NULL;
13698 }
13699
13700
13701 static PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13702 PyObject *resultobj = NULL;
13703 wxGrid *arg1 = (wxGrid *) 0 ;
13704 wxColour result;
13705 PyObject * obj0 = 0 ;
13706 char *kwnames[] = {
13707 (char *) "self", NULL
13708 };
13709
13710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellBackgroundColour",kwnames,&obj0)) goto fail;
13711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13712 if (SWIG_arg_fail(1)) SWIG_fail;
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 result = (arg1)->GetDefaultCellBackgroundColour();
13716
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 {
13721 wxColour * resultptr;
13722 resultptr = new wxColour(static_cast<wxColour & >(result));
13723 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13724 }
13725 return resultobj;
13726 fail:
13727 return NULL;
13728 }
13729
13730
13731 static PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
13732 PyObject *resultobj = NULL;
13733 wxGrid *arg1 = (wxGrid *) 0 ;
13734 int arg2 ;
13735 int arg3 ;
13736 wxColour result;
13737 PyObject * obj0 = 0 ;
13738 PyObject * obj1 = 0 ;
13739 PyObject * obj2 = 0 ;
13740 char *kwnames[] = {
13741 (char *) "self",(char *) "row",(char *) "col", NULL
13742 };
13743
13744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13746 if (SWIG_arg_fail(1)) SWIG_fail;
13747 {
13748 arg2 = static_cast<int >(SWIG_As_int(obj1));
13749 if (SWIG_arg_fail(2)) SWIG_fail;
13750 }
13751 {
13752 arg3 = static_cast<int >(SWIG_As_int(obj2));
13753 if (SWIG_arg_fail(3)) SWIG_fail;
13754 }
13755 {
13756 PyThreadState* __tstate = wxPyBeginAllowThreads();
13757 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
13758
13759 wxPyEndAllowThreads(__tstate);
13760 if (PyErr_Occurred()) SWIG_fail;
13761 }
13762 {
13763 wxColour * resultptr;
13764 resultptr = new wxColour(static_cast<wxColour & >(result));
13765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13766 }
13767 return resultobj;
13768 fail:
13769 return NULL;
13770 }
13771
13772
13773 static PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13774 PyObject *resultobj = NULL;
13775 wxGrid *arg1 = (wxGrid *) 0 ;
13776 wxColour result;
13777 PyObject * obj0 = 0 ;
13778 char *kwnames[] = {
13779 (char *) "self", NULL
13780 };
13781
13782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellTextColour",kwnames,&obj0)) goto fail;
13783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13784 if (SWIG_arg_fail(1)) SWIG_fail;
13785 {
13786 PyThreadState* __tstate = wxPyBeginAllowThreads();
13787 result = (arg1)->GetDefaultCellTextColour();
13788
13789 wxPyEndAllowThreads(__tstate);
13790 if (PyErr_Occurred()) SWIG_fail;
13791 }
13792 {
13793 wxColour * resultptr;
13794 resultptr = new wxColour(static_cast<wxColour & >(result));
13795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13796 }
13797 return resultobj;
13798 fail:
13799 return NULL;
13800 }
13801
13802
13803 static PyObject *_wrap_Grid_GetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
13804 PyObject *resultobj = NULL;
13805 wxGrid *arg1 = (wxGrid *) 0 ;
13806 int arg2 ;
13807 int arg3 ;
13808 wxColour result;
13809 PyObject * obj0 = 0 ;
13810 PyObject * obj1 = 0 ;
13811 PyObject * obj2 = 0 ;
13812 char *kwnames[] = {
13813 (char *) "self",(char *) "row",(char *) "col", NULL
13814 };
13815
13816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
13817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13818 if (SWIG_arg_fail(1)) SWIG_fail;
13819 {
13820 arg2 = static_cast<int >(SWIG_As_int(obj1));
13821 if (SWIG_arg_fail(2)) SWIG_fail;
13822 }
13823 {
13824 arg3 = static_cast<int >(SWIG_As_int(obj2));
13825 if (SWIG_arg_fail(3)) SWIG_fail;
13826 }
13827 {
13828 PyThreadState* __tstate = wxPyBeginAllowThreads();
13829 result = (arg1)->GetCellTextColour(arg2,arg3);
13830
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 {
13835 wxColour * resultptr;
13836 resultptr = new wxColour(static_cast<wxColour & >(result));
13837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13838 }
13839 return resultobj;
13840 fail:
13841 return NULL;
13842 }
13843
13844
13845 static PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13846 PyObject *resultobj = NULL;
13847 wxGrid *arg1 = (wxGrid *) 0 ;
13848 wxFont result;
13849 PyObject * obj0 = 0 ;
13850 char *kwnames[] = {
13851 (char *) "self", NULL
13852 };
13853
13854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellFont",kwnames,&obj0)) goto fail;
13855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13856 if (SWIG_arg_fail(1)) SWIG_fail;
13857 {
13858 PyThreadState* __tstate = wxPyBeginAllowThreads();
13859 result = (arg1)->GetDefaultCellFont();
13860
13861 wxPyEndAllowThreads(__tstate);
13862 if (PyErr_Occurred()) SWIG_fail;
13863 }
13864 {
13865 wxFont * resultptr;
13866 resultptr = new wxFont(static_cast<wxFont & >(result));
13867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13868 }
13869 return resultobj;
13870 fail:
13871 return NULL;
13872 }
13873
13874
13875 static PyObject *_wrap_Grid_GetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
13876 PyObject *resultobj = NULL;
13877 wxGrid *arg1 = (wxGrid *) 0 ;
13878 int arg2 ;
13879 int arg3 ;
13880 wxFont result;
13881 PyObject * obj0 = 0 ;
13882 PyObject * obj1 = 0 ;
13883 PyObject * obj2 = 0 ;
13884 char *kwnames[] = {
13885 (char *) "self",(char *) "row",(char *) "col", NULL
13886 };
13887
13888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) goto fail;
13889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13890 if (SWIG_arg_fail(1)) SWIG_fail;
13891 {
13892 arg2 = static_cast<int >(SWIG_As_int(obj1));
13893 if (SWIG_arg_fail(2)) SWIG_fail;
13894 }
13895 {
13896 arg3 = static_cast<int >(SWIG_As_int(obj2));
13897 if (SWIG_arg_fail(3)) SWIG_fail;
13898 }
13899 {
13900 PyThreadState* __tstate = wxPyBeginAllowThreads();
13901 result = (arg1)->GetCellFont(arg2,arg3);
13902
13903 wxPyEndAllowThreads(__tstate);
13904 if (PyErr_Occurred()) SWIG_fail;
13905 }
13906 {
13907 wxFont * resultptr;
13908 resultptr = new wxFont(static_cast<wxFont & >(result));
13909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
13910 }
13911 return resultobj;
13912 fail:
13913 return NULL;
13914 }
13915
13916
13917 static PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13918 PyObject *resultobj = NULL;
13919 wxGrid *arg1 = (wxGrid *) 0 ;
13920 int *arg2 = (int *) 0 ;
13921 int *arg3 = (int *) 0 ;
13922 int temp2 ;
13923 int res2 = 0 ;
13924 int temp3 ;
13925 int res3 = 0 ;
13926 PyObject * obj0 = 0 ;
13927 char *kwnames[] = {
13928 (char *) "self", NULL
13929 };
13930
13931 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13932 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellAlignment",kwnames,&obj0)) goto fail;
13934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13935 if (SWIG_arg_fail(1)) SWIG_fail;
13936 {
13937 PyThreadState* __tstate = wxPyBeginAllowThreads();
13938 (arg1)->GetDefaultCellAlignment(arg2,arg3);
13939
13940 wxPyEndAllowThreads(__tstate);
13941 if (PyErr_Occurred()) SWIG_fail;
13942 }
13943 Py_INCREF(Py_None); resultobj = Py_None;
13944 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13945 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
13946 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13947 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
13948 return resultobj;
13949 fail:
13950 return NULL;
13951 }
13952
13953
13954 static PyObject *_wrap_Grid_GetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
13955 PyObject *resultobj = NULL;
13956 wxGrid *arg1 = (wxGrid *) 0 ;
13957 int arg2 ;
13958 int arg3 ;
13959 int *arg4 = (int *) 0 ;
13960 int *arg5 = (int *) 0 ;
13961 int temp4 ;
13962 int res4 = 0 ;
13963 int temp5 ;
13964 int res5 = 0 ;
13965 PyObject * obj0 = 0 ;
13966 PyObject * obj1 = 0 ;
13967 PyObject * obj2 = 0 ;
13968 char *kwnames[] = {
13969 (char *) "self",(char *) "row",(char *) "col", NULL
13970 };
13971
13972 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13973 arg5 = &temp5; res5 = SWIG_NEWOBJ;
13974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
13975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
13976 if (SWIG_arg_fail(1)) SWIG_fail;
13977 {
13978 arg2 = static_cast<int >(SWIG_As_int(obj1));
13979 if (SWIG_arg_fail(2)) SWIG_fail;
13980 }
13981 {
13982 arg3 = static_cast<int >(SWIG_As_int(obj2));
13983 if (SWIG_arg_fail(3)) SWIG_fail;
13984 }
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
13988
13989 wxPyEndAllowThreads(__tstate);
13990 if (PyErr_Occurred()) SWIG_fail;
13991 }
13992 Py_INCREF(Py_None); resultobj = Py_None;
13993 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13994 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
13995 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
13996 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
13997 return resultobj;
13998 fail:
13999 return NULL;
14000 }
14001
14002
14003 static PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14004 PyObject *resultobj = NULL;
14005 wxGrid *arg1 = (wxGrid *) 0 ;
14006 bool result;
14007 PyObject * obj0 = 0 ;
14008 char *kwnames[] = {
14009 (char *) "self", NULL
14010 };
14011
14012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultCellOverflow",kwnames,&obj0)) goto fail;
14013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14014 if (SWIG_arg_fail(1)) SWIG_fail;
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 result = (bool)(arg1)->GetDefaultCellOverflow();
14018
14019 wxPyEndAllowThreads(__tstate);
14020 if (PyErr_Occurred()) SWIG_fail;
14021 }
14022 {
14023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14024 }
14025 return resultobj;
14026 fail:
14027 return NULL;
14028 }
14029
14030
14031 static PyObject *_wrap_Grid_GetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
14032 PyObject *resultobj = NULL;
14033 wxGrid *arg1 = (wxGrid *) 0 ;
14034 int arg2 ;
14035 int arg3 ;
14036 bool result;
14037 PyObject * obj0 = 0 ;
14038 PyObject * obj1 = 0 ;
14039 PyObject * obj2 = 0 ;
14040 char *kwnames[] = {
14041 (char *) "self",(char *) "row",(char *) "col", NULL
14042 };
14043
14044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) goto fail;
14045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14046 if (SWIG_arg_fail(1)) SWIG_fail;
14047 {
14048 arg2 = static_cast<int >(SWIG_As_int(obj1));
14049 if (SWIG_arg_fail(2)) SWIG_fail;
14050 }
14051 {
14052 arg3 = static_cast<int >(SWIG_As_int(obj2));
14053 if (SWIG_arg_fail(3)) SWIG_fail;
14054 }
14055 {
14056 PyThreadState* __tstate = wxPyBeginAllowThreads();
14057 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
14058
14059 wxPyEndAllowThreads(__tstate);
14060 if (PyErr_Occurred()) SWIG_fail;
14061 }
14062 {
14063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14064 }
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 static PyObject *_wrap_Grid_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj = NULL;
14073 wxGrid *arg1 = (wxGrid *) 0 ;
14074 int arg2 ;
14075 int arg3 ;
14076 int *arg4 = (int *) 0 ;
14077 int *arg5 = (int *) 0 ;
14078 int temp4 ;
14079 int res4 = 0 ;
14080 int temp5 ;
14081 int res5 = 0 ;
14082 PyObject * obj0 = 0 ;
14083 PyObject * obj1 = 0 ;
14084 PyObject * obj2 = 0 ;
14085 char *kwnames[] = {
14086 (char *) "self",(char *) "row",(char *) "col", NULL
14087 };
14088
14089 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14090 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14093 if (SWIG_arg_fail(1)) SWIG_fail;
14094 {
14095 arg2 = static_cast<int >(SWIG_As_int(obj1));
14096 if (SWIG_arg_fail(2)) SWIG_fail;
14097 }
14098 {
14099 arg3 = static_cast<int >(SWIG_As_int(obj2));
14100 if (SWIG_arg_fail(3)) SWIG_fail;
14101 }
14102 {
14103 PyThreadState* __tstate = wxPyBeginAllowThreads();
14104 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
14105
14106 wxPyEndAllowThreads(__tstate);
14107 if (PyErr_Occurred()) SWIG_fail;
14108 }
14109 Py_INCREF(Py_None); resultobj = Py_None;
14110 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14111 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14112 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14113 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 static PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
14121 PyObject *resultobj = NULL;
14122 wxGrid *arg1 = (wxGrid *) 0 ;
14123 int arg2 ;
14124 bool arg3 = (bool) false ;
14125 PyObject * obj0 = 0 ;
14126 PyObject * obj1 = 0 ;
14127 PyObject * obj2 = 0 ;
14128 char *kwnames[] = {
14129 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
14130 };
14131
14132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14134 if (SWIG_arg_fail(1)) SWIG_fail;
14135 {
14136 arg2 = static_cast<int >(SWIG_As_int(obj1));
14137 if (SWIG_arg_fail(2)) SWIG_fail;
14138 }
14139 if (obj2) {
14140 {
14141 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
14142 if (SWIG_arg_fail(3)) SWIG_fail;
14143 }
14144 }
14145 {
14146 PyThreadState* __tstate = wxPyBeginAllowThreads();
14147 (arg1)->SetDefaultRowSize(arg2,arg3);
14148
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 Py_INCREF(Py_None); resultobj = Py_None;
14153 return resultobj;
14154 fail:
14155 return NULL;
14156 }
14157
14158
14159 static PyObject *_wrap_Grid_SetRowSize(PyObject *, PyObject *args, PyObject *kwargs) {
14160 PyObject *resultobj = NULL;
14161 wxGrid *arg1 = (wxGrid *) 0 ;
14162 int arg2 ;
14163 int arg3 ;
14164 PyObject * obj0 = 0 ;
14165 PyObject * obj1 = 0 ;
14166 PyObject * obj2 = 0 ;
14167 char *kwnames[] = {
14168 (char *) "self",(char *) "row",(char *) "height", NULL
14169 };
14170
14171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14173 if (SWIG_arg_fail(1)) SWIG_fail;
14174 {
14175 arg2 = static_cast<int >(SWIG_As_int(obj1));
14176 if (SWIG_arg_fail(2)) SWIG_fail;
14177 }
14178 {
14179 arg3 = static_cast<int >(SWIG_As_int(obj2));
14180 if (SWIG_arg_fail(3)) SWIG_fail;
14181 }
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 (arg1)->SetRowSize(arg2,arg3);
14185
14186 wxPyEndAllowThreads(__tstate);
14187 if (PyErr_Occurred()) SWIG_fail;
14188 }
14189 Py_INCREF(Py_None); resultobj = Py_None;
14190 return resultobj;
14191 fail:
14192 return NULL;
14193 }
14194
14195
14196 static PyObject *_wrap_Grid_SetDefaultColSize(PyObject *, PyObject *args, PyObject *kwargs) {
14197 PyObject *resultobj = NULL;
14198 wxGrid *arg1 = (wxGrid *) 0 ;
14199 int arg2 ;
14200 bool arg3 = (bool) false ;
14201 PyObject * obj0 = 0 ;
14202 PyObject * obj1 = 0 ;
14203 PyObject * obj2 = 0 ;
14204 char *kwnames[] = {
14205 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
14206 };
14207
14208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14210 if (SWIG_arg_fail(1)) SWIG_fail;
14211 {
14212 arg2 = static_cast<int >(SWIG_As_int(obj1));
14213 if (SWIG_arg_fail(2)) SWIG_fail;
14214 }
14215 if (obj2) {
14216 {
14217 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
14218 if (SWIG_arg_fail(3)) SWIG_fail;
14219 }
14220 }
14221 {
14222 PyThreadState* __tstate = wxPyBeginAllowThreads();
14223 (arg1)->SetDefaultColSize(arg2,arg3);
14224
14225 wxPyEndAllowThreads(__tstate);
14226 if (PyErr_Occurred()) SWIG_fail;
14227 }
14228 Py_INCREF(Py_None); resultobj = Py_None;
14229 return resultobj;
14230 fail:
14231 return NULL;
14232 }
14233
14234
14235 static PyObject *_wrap_Grid_SetColSize(PyObject *, PyObject *args, PyObject *kwargs) {
14236 PyObject *resultobj = NULL;
14237 wxGrid *arg1 = (wxGrid *) 0 ;
14238 int arg2 ;
14239 int arg3 ;
14240 PyObject * obj0 = 0 ;
14241 PyObject * obj1 = 0 ;
14242 PyObject * obj2 = 0 ;
14243 char *kwnames[] = {
14244 (char *) "self",(char *) "col",(char *) "width", NULL
14245 };
14246
14247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14249 if (SWIG_arg_fail(1)) SWIG_fail;
14250 {
14251 arg2 = static_cast<int >(SWIG_As_int(obj1));
14252 if (SWIG_arg_fail(2)) SWIG_fail;
14253 }
14254 {
14255 arg3 = static_cast<int >(SWIG_As_int(obj2));
14256 if (SWIG_arg_fail(3)) SWIG_fail;
14257 }
14258 {
14259 PyThreadState* __tstate = wxPyBeginAllowThreads();
14260 (arg1)->SetColSize(arg2,arg3);
14261
14262 wxPyEndAllowThreads(__tstate);
14263 if (PyErr_Occurred()) SWIG_fail;
14264 }
14265 Py_INCREF(Py_None); resultobj = Py_None;
14266 return resultobj;
14267 fail:
14268 return NULL;
14269 }
14270
14271
14272 static PyObject *_wrap_Grid_AutoSizeColumn(PyObject *, PyObject *args, PyObject *kwargs) {
14273 PyObject *resultobj = NULL;
14274 wxGrid *arg1 = (wxGrid *) 0 ;
14275 int arg2 ;
14276 bool arg3 = (bool) true ;
14277 PyObject * obj0 = 0 ;
14278 PyObject * obj1 = 0 ;
14279 PyObject * obj2 = 0 ;
14280 char *kwnames[] = {
14281 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
14282 };
14283
14284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) goto fail;
14285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14286 if (SWIG_arg_fail(1)) SWIG_fail;
14287 {
14288 arg2 = static_cast<int >(SWIG_As_int(obj1));
14289 if (SWIG_arg_fail(2)) SWIG_fail;
14290 }
14291 if (obj2) {
14292 {
14293 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
14294 if (SWIG_arg_fail(3)) SWIG_fail;
14295 }
14296 }
14297 {
14298 PyThreadState* __tstate = wxPyBeginAllowThreads();
14299 (arg1)->AutoSizeColumn(arg2,arg3);
14300
14301 wxPyEndAllowThreads(__tstate);
14302 if (PyErr_Occurred()) SWIG_fail;
14303 }
14304 Py_INCREF(Py_None); resultobj = Py_None;
14305 return resultobj;
14306 fail:
14307 return NULL;
14308 }
14309
14310
14311 static PyObject *_wrap_Grid_AutoSizeRow(PyObject *, PyObject *args, PyObject *kwargs) {
14312 PyObject *resultobj = NULL;
14313 wxGrid *arg1 = (wxGrid *) 0 ;
14314 int arg2 ;
14315 bool arg3 = (bool) true ;
14316 PyObject * obj0 = 0 ;
14317 PyObject * obj1 = 0 ;
14318 PyObject * obj2 = 0 ;
14319 char *kwnames[] = {
14320 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
14321 };
14322
14323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
14324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14325 if (SWIG_arg_fail(1)) SWIG_fail;
14326 {
14327 arg2 = static_cast<int >(SWIG_As_int(obj1));
14328 if (SWIG_arg_fail(2)) SWIG_fail;
14329 }
14330 if (obj2) {
14331 {
14332 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
14333 if (SWIG_arg_fail(3)) SWIG_fail;
14334 }
14335 }
14336 {
14337 PyThreadState* __tstate = wxPyBeginAllowThreads();
14338 (arg1)->AutoSizeRow(arg2,arg3);
14339
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 Py_INCREF(Py_None); resultobj = Py_None;
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 static PyObject *_wrap_Grid_AutoSizeColumns(PyObject *, PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj = NULL;
14352 wxGrid *arg1 = (wxGrid *) 0 ;
14353 bool arg2 = (bool) true ;
14354 PyObject * obj0 = 0 ;
14355 PyObject * obj1 = 0 ;
14356 char *kwnames[] = {
14357 (char *) "self",(char *) "setAsMin", NULL
14358 };
14359
14360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) goto fail;
14361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14362 if (SWIG_arg_fail(1)) SWIG_fail;
14363 if (obj1) {
14364 {
14365 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
14366 if (SWIG_arg_fail(2)) SWIG_fail;
14367 }
14368 }
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 (arg1)->AutoSizeColumns(arg2);
14372
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 Py_INCREF(Py_None); resultobj = Py_None;
14377 return resultobj;
14378 fail:
14379 return NULL;
14380 }
14381
14382
14383 static PyObject *_wrap_Grid_AutoSizeRows(PyObject *, PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj = NULL;
14385 wxGrid *arg1 = (wxGrid *) 0 ;
14386 bool arg2 = (bool) true ;
14387 PyObject * obj0 = 0 ;
14388 PyObject * obj1 = 0 ;
14389 char *kwnames[] = {
14390 (char *) "self",(char *) "setAsMin", NULL
14391 };
14392
14393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) goto fail;
14394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14395 if (SWIG_arg_fail(1)) SWIG_fail;
14396 if (obj1) {
14397 {
14398 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
14399 if (SWIG_arg_fail(2)) SWIG_fail;
14400 }
14401 }
14402 {
14403 PyThreadState* __tstate = wxPyBeginAllowThreads();
14404 (arg1)->AutoSizeRows(arg2);
14405
14406 wxPyEndAllowThreads(__tstate);
14407 if (PyErr_Occurred()) SWIG_fail;
14408 }
14409 Py_INCREF(Py_None); resultobj = Py_None;
14410 return resultobj;
14411 fail:
14412 return NULL;
14413 }
14414
14415
14416 static PyObject *_wrap_Grid_AutoSize(PyObject *, PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj = NULL;
14418 wxGrid *arg1 = (wxGrid *) 0 ;
14419 PyObject * obj0 = 0 ;
14420 char *kwnames[] = {
14421 (char *) "self", NULL
14422 };
14423
14424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_AutoSize",kwnames,&obj0)) goto fail;
14425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14426 if (SWIG_arg_fail(1)) SWIG_fail;
14427 {
14428 PyThreadState* __tstate = wxPyBeginAllowThreads();
14429 (arg1)->AutoSize();
14430
14431 wxPyEndAllowThreads(__tstate);
14432 if (PyErr_Occurred()) SWIG_fail;
14433 }
14434 Py_INCREF(Py_None); resultobj = Py_None;
14435 return resultobj;
14436 fail:
14437 return NULL;
14438 }
14439
14440
14441 static PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14442 PyObject *resultobj = NULL;
14443 wxGrid *arg1 = (wxGrid *) 0 ;
14444 int arg2 ;
14445 PyObject * obj0 = 0 ;
14446 PyObject * obj1 = 0 ;
14447 char *kwnames[] = {
14448 (char *) "self",(char *) "row", NULL
14449 };
14450
14451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) goto fail;
14452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14453 if (SWIG_arg_fail(1)) SWIG_fail;
14454 {
14455 arg2 = static_cast<int >(SWIG_As_int(obj1));
14456 if (SWIG_arg_fail(2)) SWIG_fail;
14457 }
14458 {
14459 PyThreadState* __tstate = wxPyBeginAllowThreads();
14460 (arg1)->AutoSizeRowLabelSize(arg2);
14461
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 Py_INCREF(Py_None); resultobj = Py_None;
14466 return resultobj;
14467 fail:
14468 return NULL;
14469 }
14470
14471
14472 static PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *, PyObject *args, PyObject *kwargs) {
14473 PyObject *resultobj = NULL;
14474 wxGrid *arg1 = (wxGrid *) 0 ;
14475 int arg2 ;
14476 PyObject * obj0 = 0 ;
14477 PyObject * obj1 = 0 ;
14478 char *kwnames[] = {
14479 (char *) "self",(char *) "col", NULL
14480 };
14481
14482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) goto fail;
14483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14484 if (SWIG_arg_fail(1)) SWIG_fail;
14485 {
14486 arg2 = static_cast<int >(SWIG_As_int(obj1));
14487 if (SWIG_arg_fail(2)) SWIG_fail;
14488 }
14489 {
14490 PyThreadState* __tstate = wxPyBeginAllowThreads();
14491 (arg1)->AutoSizeColLabelSize(arg2);
14492
14493 wxPyEndAllowThreads(__tstate);
14494 if (PyErr_Occurred()) SWIG_fail;
14495 }
14496 Py_INCREF(Py_None); resultobj = Py_None;
14497 return resultobj;
14498 fail:
14499 return NULL;
14500 }
14501
14502
14503 static PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14504 PyObject *resultobj = NULL;
14505 wxGrid *arg1 = (wxGrid *) 0 ;
14506 int arg2 ;
14507 int arg3 ;
14508 PyObject * obj0 = 0 ;
14509 PyObject * obj1 = 0 ;
14510 PyObject * obj2 = 0 ;
14511 char *kwnames[] = {
14512 (char *) "self",(char *) "col",(char *) "width", NULL
14513 };
14514
14515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) goto fail;
14516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14517 if (SWIG_arg_fail(1)) SWIG_fail;
14518 {
14519 arg2 = static_cast<int >(SWIG_As_int(obj1));
14520 if (SWIG_arg_fail(2)) SWIG_fail;
14521 }
14522 {
14523 arg3 = static_cast<int >(SWIG_As_int(obj2));
14524 if (SWIG_arg_fail(3)) SWIG_fail;
14525 }
14526 {
14527 PyThreadState* __tstate = wxPyBeginAllowThreads();
14528 (arg1)->SetColMinimalWidth(arg2,arg3);
14529
14530 wxPyEndAllowThreads(__tstate);
14531 if (PyErr_Occurred()) SWIG_fail;
14532 }
14533 Py_INCREF(Py_None); resultobj = Py_None;
14534 return resultobj;
14535 fail:
14536 return NULL;
14537 }
14538
14539
14540 static PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14541 PyObject *resultobj = NULL;
14542 wxGrid *arg1 = (wxGrid *) 0 ;
14543 int arg2 ;
14544 int arg3 ;
14545 PyObject * obj0 = 0 ;
14546 PyObject * obj1 = 0 ;
14547 PyObject * obj2 = 0 ;
14548 char *kwnames[] = {
14549 (char *) "self",(char *) "row",(char *) "width", NULL
14550 };
14551
14552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) goto fail;
14553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14554 if (SWIG_arg_fail(1)) SWIG_fail;
14555 {
14556 arg2 = static_cast<int >(SWIG_As_int(obj1));
14557 if (SWIG_arg_fail(2)) SWIG_fail;
14558 }
14559 {
14560 arg3 = static_cast<int >(SWIG_As_int(obj2));
14561 if (SWIG_arg_fail(3)) SWIG_fail;
14562 }
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 (arg1)->SetRowMinimalHeight(arg2,arg3);
14566
14567 wxPyEndAllowThreads(__tstate);
14568 if (PyErr_Occurred()) SWIG_fail;
14569 }
14570 Py_INCREF(Py_None); resultobj = Py_None;
14571 return resultobj;
14572 fail:
14573 return NULL;
14574 }
14575
14576
14577 static PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14578 PyObject *resultobj = NULL;
14579 wxGrid *arg1 = (wxGrid *) 0 ;
14580 int arg2 ;
14581 PyObject * obj0 = 0 ;
14582 PyObject * obj1 = 0 ;
14583 char *kwnames[] = {
14584 (char *) "self",(char *) "width", NULL
14585 };
14586
14587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) goto fail;
14588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14589 if (SWIG_arg_fail(1)) SWIG_fail;
14590 {
14591 arg2 = static_cast<int >(SWIG_As_int(obj1));
14592 if (SWIG_arg_fail(2)) SWIG_fail;
14593 }
14594 {
14595 PyThreadState* __tstate = wxPyBeginAllowThreads();
14596 (arg1)->SetColMinimalAcceptableWidth(arg2);
14597
14598 wxPyEndAllowThreads(__tstate);
14599 if (PyErr_Occurred()) SWIG_fail;
14600 }
14601 Py_INCREF(Py_None); resultobj = Py_None;
14602 return resultobj;
14603 fail:
14604 return NULL;
14605 }
14606
14607
14608 static PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14609 PyObject *resultobj = NULL;
14610 wxGrid *arg1 = (wxGrid *) 0 ;
14611 int arg2 ;
14612 PyObject * obj0 = 0 ;
14613 PyObject * obj1 = 0 ;
14614 char *kwnames[] = {
14615 (char *) "self",(char *) "width", NULL
14616 };
14617
14618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) goto fail;
14619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14620 if (SWIG_arg_fail(1)) SWIG_fail;
14621 {
14622 arg2 = static_cast<int >(SWIG_As_int(obj1));
14623 if (SWIG_arg_fail(2)) SWIG_fail;
14624 }
14625 {
14626 PyThreadState* __tstate = wxPyBeginAllowThreads();
14627 (arg1)->SetRowMinimalAcceptableHeight(arg2);
14628
14629 wxPyEndAllowThreads(__tstate);
14630 if (PyErr_Occurred()) SWIG_fail;
14631 }
14632 Py_INCREF(Py_None); resultobj = Py_None;
14633 return resultobj;
14634 fail:
14635 return NULL;
14636 }
14637
14638
14639 static PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14640 PyObject *resultobj = NULL;
14641 wxGrid *arg1 = (wxGrid *) 0 ;
14642 int result;
14643 PyObject * obj0 = 0 ;
14644 char *kwnames[] = {
14645 (char *) "self", NULL
14646 };
14647
14648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetColMinimalAcceptableWidth",kwnames,&obj0)) goto fail;
14649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14650 if (SWIG_arg_fail(1)) SWIG_fail;
14651 {
14652 PyThreadState* __tstate = wxPyBeginAllowThreads();
14653 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
14654
14655 wxPyEndAllowThreads(__tstate);
14656 if (PyErr_Occurred()) SWIG_fail;
14657 }
14658 {
14659 resultobj = SWIG_From_int(static_cast<int >(result));
14660 }
14661 return resultobj;
14662 fail:
14663 return NULL;
14664 }
14665
14666
14667 static PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14668 PyObject *resultobj = NULL;
14669 wxGrid *arg1 = (wxGrid *) 0 ;
14670 int result;
14671 PyObject * obj0 = 0 ;
14672 char *kwnames[] = {
14673 (char *) "self", NULL
14674 };
14675
14676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetRowMinimalAcceptableHeight",kwnames,&obj0)) goto fail;
14677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14678 if (SWIG_arg_fail(1)) SWIG_fail;
14679 {
14680 PyThreadState* __tstate = wxPyBeginAllowThreads();
14681 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
14682
14683 wxPyEndAllowThreads(__tstate);
14684 if (PyErr_Occurred()) SWIG_fail;
14685 }
14686 {
14687 resultobj = SWIG_From_int(static_cast<int >(result));
14688 }
14689 return resultobj;
14690 fail:
14691 return NULL;
14692 }
14693
14694
14695 static PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14696 PyObject *resultobj = NULL;
14697 wxGrid *arg1 = (wxGrid *) 0 ;
14698 wxColour *arg2 = 0 ;
14699 wxColour temp2 ;
14700 PyObject * obj0 = 0 ;
14701 PyObject * obj1 = 0 ;
14702 char *kwnames[] = {
14703 (char *) "self","arg2", NULL
14704 };
14705
14706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
14707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14708 if (SWIG_arg_fail(1)) SWIG_fail;
14709 {
14710 arg2 = &temp2;
14711 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14712 }
14713 {
14714 PyThreadState* __tstate = wxPyBeginAllowThreads();
14715 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
14716
14717 wxPyEndAllowThreads(__tstate);
14718 if (PyErr_Occurred()) SWIG_fail;
14719 }
14720 Py_INCREF(Py_None); resultobj = Py_None;
14721 return resultobj;
14722 fail:
14723 return NULL;
14724 }
14725
14726
14727 static PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
14728 PyObject *resultobj = NULL;
14729 wxGrid *arg1 = (wxGrid *) 0 ;
14730 int arg2 ;
14731 int arg3 ;
14732 wxColour *arg4 = 0 ;
14733 wxColour temp4 ;
14734 PyObject * obj0 = 0 ;
14735 PyObject * obj1 = 0 ;
14736 PyObject * obj2 = 0 ;
14737 PyObject * obj3 = 0 ;
14738 char *kwnames[] = {
14739 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14740 };
14741
14742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14744 if (SWIG_arg_fail(1)) SWIG_fail;
14745 {
14746 arg2 = static_cast<int >(SWIG_As_int(obj1));
14747 if (SWIG_arg_fail(2)) SWIG_fail;
14748 }
14749 {
14750 arg3 = static_cast<int >(SWIG_As_int(obj2));
14751 if (SWIG_arg_fail(3)) SWIG_fail;
14752 }
14753 {
14754 arg4 = &temp4;
14755 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14756 }
14757 {
14758 PyThreadState* __tstate = wxPyBeginAllowThreads();
14759 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
14760
14761 wxPyEndAllowThreads(__tstate);
14762 if (PyErr_Occurred()) SWIG_fail;
14763 }
14764 Py_INCREF(Py_None); resultobj = Py_None;
14765 return resultobj;
14766 fail:
14767 return NULL;
14768 }
14769
14770
14771 static PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14772 PyObject *resultobj = NULL;
14773 wxGrid *arg1 = (wxGrid *) 0 ;
14774 wxColour *arg2 = 0 ;
14775 wxColour temp2 ;
14776 PyObject * obj0 = 0 ;
14777 PyObject * obj1 = 0 ;
14778 char *kwnames[] = {
14779 (char *) "self","arg2", NULL
14780 };
14781
14782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) goto fail;
14783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14784 if (SWIG_arg_fail(1)) SWIG_fail;
14785 {
14786 arg2 = &temp2;
14787 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14788 }
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
14792
14793 wxPyEndAllowThreads(__tstate);
14794 if (PyErr_Occurred()) SWIG_fail;
14795 }
14796 Py_INCREF(Py_None); resultobj = Py_None;
14797 return resultobj;
14798 fail:
14799 return NULL;
14800 }
14801
14802
14803 static PyObject *_wrap_Grid_SetCellTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
14804 PyObject *resultobj = NULL;
14805 wxGrid *arg1 = (wxGrid *) 0 ;
14806 int arg2 ;
14807 int arg3 ;
14808 wxColour *arg4 = 0 ;
14809 wxColour temp4 ;
14810 PyObject * obj0 = 0 ;
14811 PyObject * obj1 = 0 ;
14812 PyObject * obj2 = 0 ;
14813 PyObject * obj3 = 0 ;
14814 char *kwnames[] = {
14815 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14816 };
14817
14818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14820 if (SWIG_arg_fail(1)) SWIG_fail;
14821 {
14822 arg2 = static_cast<int >(SWIG_As_int(obj1));
14823 if (SWIG_arg_fail(2)) SWIG_fail;
14824 }
14825 {
14826 arg3 = static_cast<int >(SWIG_As_int(obj2));
14827 if (SWIG_arg_fail(3)) SWIG_fail;
14828 }
14829 {
14830 arg4 = &temp4;
14831 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14832 }
14833 {
14834 PyThreadState* __tstate = wxPyBeginAllowThreads();
14835 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
14836
14837 wxPyEndAllowThreads(__tstate);
14838 if (PyErr_Occurred()) SWIG_fail;
14839 }
14840 Py_INCREF(Py_None); resultobj = Py_None;
14841 return resultobj;
14842 fail:
14843 return NULL;
14844 }
14845
14846
14847 static PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14848 PyObject *resultobj = NULL;
14849 wxGrid *arg1 = (wxGrid *) 0 ;
14850 wxFont *arg2 = 0 ;
14851 PyObject * obj0 = 0 ;
14852 PyObject * obj1 = 0 ;
14853 char *kwnames[] = {
14854 (char *) "self","arg2", NULL
14855 };
14856
14857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) goto fail;
14858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14859 if (SWIG_arg_fail(1)) SWIG_fail;
14860 {
14861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14862 if (SWIG_arg_fail(2)) SWIG_fail;
14863 if (arg2 == NULL) {
14864 SWIG_null_ref("wxFont");
14865 }
14866 if (SWIG_arg_fail(2)) SWIG_fail;
14867 }
14868 {
14869 PyThreadState* __tstate = wxPyBeginAllowThreads();
14870 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
14871
14872 wxPyEndAllowThreads(__tstate);
14873 if (PyErr_Occurred()) SWIG_fail;
14874 }
14875 Py_INCREF(Py_None); resultobj = Py_None;
14876 return resultobj;
14877 fail:
14878 return NULL;
14879 }
14880
14881
14882 static PyObject *_wrap_Grid_SetCellFont(PyObject *, PyObject *args, PyObject *kwargs) {
14883 PyObject *resultobj = NULL;
14884 wxGrid *arg1 = (wxGrid *) 0 ;
14885 int arg2 ;
14886 int arg3 ;
14887 wxFont *arg4 = 0 ;
14888 PyObject * obj0 = 0 ;
14889 PyObject * obj1 = 0 ;
14890 PyObject * obj2 = 0 ;
14891 PyObject * obj3 = 0 ;
14892 char *kwnames[] = {
14893 (char *) "self",(char *) "row",(char *) "col","arg4", NULL
14894 };
14895
14896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14898 if (SWIG_arg_fail(1)) SWIG_fail;
14899 {
14900 arg2 = static_cast<int >(SWIG_As_int(obj1));
14901 if (SWIG_arg_fail(2)) SWIG_fail;
14902 }
14903 {
14904 arg3 = static_cast<int >(SWIG_As_int(obj2));
14905 if (SWIG_arg_fail(3)) SWIG_fail;
14906 }
14907 {
14908 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14909 if (SWIG_arg_fail(4)) SWIG_fail;
14910 if (arg4 == NULL) {
14911 SWIG_null_ref("wxFont");
14912 }
14913 if (SWIG_arg_fail(4)) SWIG_fail;
14914 }
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
14918
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 Py_INCREF(Py_None); resultobj = Py_None;
14923 return resultobj;
14924 fail:
14925 return NULL;
14926 }
14927
14928
14929 static PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14930 PyObject *resultobj = NULL;
14931 wxGrid *arg1 = (wxGrid *) 0 ;
14932 int arg2 ;
14933 int arg3 ;
14934 PyObject * obj0 = 0 ;
14935 PyObject * obj1 = 0 ;
14936 PyObject * obj2 = 0 ;
14937 char *kwnames[] = {
14938 (char *) "self",(char *) "horiz",(char *) "vert", NULL
14939 };
14940
14941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) goto fail;
14942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14943 if (SWIG_arg_fail(1)) SWIG_fail;
14944 {
14945 arg2 = static_cast<int >(SWIG_As_int(obj1));
14946 if (SWIG_arg_fail(2)) SWIG_fail;
14947 }
14948 {
14949 arg3 = static_cast<int >(SWIG_As_int(obj2));
14950 if (SWIG_arg_fail(3)) SWIG_fail;
14951 }
14952 {
14953 PyThreadState* __tstate = wxPyBeginAllowThreads();
14954 (arg1)->SetDefaultCellAlignment(arg2,arg3);
14955
14956 wxPyEndAllowThreads(__tstate);
14957 if (PyErr_Occurred()) SWIG_fail;
14958 }
14959 Py_INCREF(Py_None); resultobj = Py_None;
14960 return resultobj;
14961 fail:
14962 return NULL;
14963 }
14964
14965
14966 static PyObject *_wrap_Grid_SetCellAlignment(PyObject *, PyObject *args, PyObject *kwargs) {
14967 PyObject *resultobj = NULL;
14968 wxGrid *arg1 = (wxGrid *) 0 ;
14969 int arg2 ;
14970 int arg3 ;
14971 int arg4 ;
14972 int arg5 ;
14973 PyObject * obj0 = 0 ;
14974 PyObject * obj1 = 0 ;
14975 PyObject * obj2 = 0 ;
14976 PyObject * obj3 = 0 ;
14977 PyObject * obj4 = 0 ;
14978 char *kwnames[] = {
14979 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
14980 };
14981
14982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
14984 if (SWIG_arg_fail(1)) SWIG_fail;
14985 {
14986 arg2 = static_cast<int >(SWIG_As_int(obj1));
14987 if (SWIG_arg_fail(2)) SWIG_fail;
14988 }
14989 {
14990 arg3 = static_cast<int >(SWIG_As_int(obj2));
14991 if (SWIG_arg_fail(3)) SWIG_fail;
14992 }
14993 {
14994 arg4 = static_cast<int >(SWIG_As_int(obj3));
14995 if (SWIG_arg_fail(4)) SWIG_fail;
14996 }
14997 {
14998 arg5 = static_cast<int >(SWIG_As_int(obj4));
14999 if (SWIG_arg_fail(5)) SWIG_fail;
15000 }
15001 {
15002 PyThreadState* __tstate = wxPyBeginAllowThreads();
15003 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
15004
15005 wxPyEndAllowThreads(__tstate);
15006 if (PyErr_Occurred()) SWIG_fail;
15007 }
15008 Py_INCREF(Py_None); resultobj = Py_None;
15009 return resultobj;
15010 fail:
15011 return NULL;
15012 }
15013
15014
15015 static PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
15016 PyObject *resultobj = NULL;
15017 wxGrid *arg1 = (wxGrid *) 0 ;
15018 bool arg2 ;
15019 PyObject * obj0 = 0 ;
15020 PyObject * obj1 = 0 ;
15021 char *kwnames[] = {
15022 (char *) "self",(char *) "allow", NULL
15023 };
15024
15025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) goto fail;
15026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15027 if (SWIG_arg_fail(1)) SWIG_fail;
15028 {
15029 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
15030 if (SWIG_arg_fail(2)) SWIG_fail;
15031 }
15032 {
15033 PyThreadState* __tstate = wxPyBeginAllowThreads();
15034 (arg1)->SetDefaultCellOverflow(arg2);
15035
15036 wxPyEndAllowThreads(__tstate);
15037 if (PyErr_Occurred()) SWIG_fail;
15038 }
15039 Py_INCREF(Py_None); resultobj = Py_None;
15040 return resultobj;
15041 fail:
15042 return NULL;
15043 }
15044
15045
15046 static PyObject *_wrap_Grid_SetCellOverflow(PyObject *, PyObject *args, PyObject *kwargs) {
15047 PyObject *resultobj = NULL;
15048 wxGrid *arg1 = (wxGrid *) 0 ;
15049 int arg2 ;
15050 int arg3 ;
15051 bool arg4 ;
15052 PyObject * obj0 = 0 ;
15053 PyObject * obj1 = 0 ;
15054 PyObject * obj2 = 0 ;
15055 PyObject * obj3 = 0 ;
15056 char *kwnames[] = {
15057 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
15058 };
15059
15060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15062 if (SWIG_arg_fail(1)) SWIG_fail;
15063 {
15064 arg2 = static_cast<int >(SWIG_As_int(obj1));
15065 if (SWIG_arg_fail(2)) SWIG_fail;
15066 }
15067 {
15068 arg3 = static_cast<int >(SWIG_As_int(obj2));
15069 if (SWIG_arg_fail(3)) SWIG_fail;
15070 }
15071 {
15072 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
15073 if (SWIG_arg_fail(4)) SWIG_fail;
15074 }
15075 {
15076 PyThreadState* __tstate = wxPyBeginAllowThreads();
15077 (arg1)->SetCellOverflow(arg2,arg3,arg4);
15078
15079 wxPyEndAllowThreads(__tstate);
15080 if (PyErr_Occurred()) SWIG_fail;
15081 }
15082 Py_INCREF(Py_None); resultobj = Py_None;
15083 return resultobj;
15084 fail:
15085 return NULL;
15086 }
15087
15088
15089 static PyObject *_wrap_Grid_SetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
15090 PyObject *resultobj = NULL;
15091 wxGrid *arg1 = (wxGrid *) 0 ;
15092 int arg2 ;
15093 int arg3 ;
15094 int arg4 ;
15095 int arg5 ;
15096 PyObject * obj0 = 0 ;
15097 PyObject * obj1 = 0 ;
15098 PyObject * obj2 = 0 ;
15099 PyObject * obj3 = 0 ;
15100 PyObject * obj4 = 0 ;
15101 char *kwnames[] = {
15102 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
15103 };
15104
15105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15107 if (SWIG_arg_fail(1)) SWIG_fail;
15108 {
15109 arg2 = static_cast<int >(SWIG_As_int(obj1));
15110 if (SWIG_arg_fail(2)) SWIG_fail;
15111 }
15112 {
15113 arg3 = static_cast<int >(SWIG_As_int(obj2));
15114 if (SWIG_arg_fail(3)) SWIG_fail;
15115 }
15116 {
15117 arg4 = static_cast<int >(SWIG_As_int(obj3));
15118 if (SWIG_arg_fail(4)) SWIG_fail;
15119 }
15120 {
15121 arg5 = static_cast<int >(SWIG_As_int(obj4));
15122 if (SWIG_arg_fail(5)) SWIG_fail;
15123 }
15124 {
15125 PyThreadState* __tstate = wxPyBeginAllowThreads();
15126 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
15127
15128 wxPyEndAllowThreads(__tstate);
15129 if (PyErr_Occurred()) SWIG_fail;
15130 }
15131 Py_INCREF(Py_None); resultobj = Py_None;
15132 return resultobj;
15133 fail:
15134 return NULL;
15135 }
15136
15137
15138 static PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15139 PyObject *resultobj = NULL;
15140 wxGrid *arg1 = (wxGrid *) 0 ;
15141 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
15142 PyObject * obj0 = 0 ;
15143 PyObject * obj1 = 0 ;
15144 char *kwnames[] = {
15145 (char *) "self",(char *) "renderer", NULL
15146 };
15147
15148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) goto fail;
15149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15150 if (SWIG_arg_fail(1)) SWIG_fail;
15151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
15152 if (SWIG_arg_fail(2)) SWIG_fail;
15153 {
15154 PyThreadState* __tstate = wxPyBeginAllowThreads();
15155 (arg1)->SetDefaultRenderer(arg2);
15156
15157 wxPyEndAllowThreads(__tstate);
15158 if (PyErr_Occurred()) SWIG_fail;
15159 }
15160 Py_INCREF(Py_None); resultobj = Py_None;
15161 return resultobj;
15162 fail:
15163 return NULL;
15164 }
15165
15166
15167 static PyObject *_wrap_Grid_SetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15168 PyObject *resultobj = NULL;
15169 wxGrid *arg1 = (wxGrid *) 0 ;
15170 int arg2 ;
15171 int arg3 ;
15172 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
15173 PyObject * obj0 = 0 ;
15174 PyObject * obj1 = 0 ;
15175 PyObject * obj2 = 0 ;
15176 PyObject * obj3 = 0 ;
15177 char *kwnames[] = {
15178 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
15179 };
15180
15181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15183 if (SWIG_arg_fail(1)) SWIG_fail;
15184 {
15185 arg2 = static_cast<int >(SWIG_As_int(obj1));
15186 if (SWIG_arg_fail(2)) SWIG_fail;
15187 }
15188 {
15189 arg3 = static_cast<int >(SWIG_As_int(obj2));
15190 if (SWIG_arg_fail(3)) SWIG_fail;
15191 }
15192 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
15193 if (SWIG_arg_fail(4)) SWIG_fail;
15194 {
15195 PyThreadState* __tstate = wxPyBeginAllowThreads();
15196 (arg1)->SetCellRenderer(arg2,arg3,arg4);
15197
15198 wxPyEndAllowThreads(__tstate);
15199 if (PyErr_Occurred()) SWIG_fail;
15200 }
15201 Py_INCREF(Py_None); resultobj = Py_None;
15202 return resultobj;
15203 fail:
15204 return NULL;
15205 }
15206
15207
15208 static PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15209 PyObject *resultobj = NULL;
15210 wxGrid *arg1 = (wxGrid *) 0 ;
15211 wxGridCellRenderer *result;
15212 PyObject * obj0 = 0 ;
15213 char *kwnames[] = {
15214 (char *) "self", NULL
15215 };
15216
15217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultRenderer",kwnames,&obj0)) goto fail;
15218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15219 if (SWIG_arg_fail(1)) SWIG_fail;
15220 {
15221 PyThreadState* __tstate = wxPyBeginAllowThreads();
15222 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
15223
15224 wxPyEndAllowThreads(__tstate);
15225 if (PyErr_Occurred()) SWIG_fail;
15226 }
15227 {
15228 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
15229 }
15230 return resultobj;
15231 fail:
15232 return NULL;
15233 }
15234
15235
15236 static PyObject *_wrap_Grid_GetCellRenderer(PyObject *, PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj = NULL;
15238 wxGrid *arg1 = (wxGrid *) 0 ;
15239 int arg2 ;
15240 int arg3 ;
15241 wxGridCellRenderer *result;
15242 PyObject * obj0 = 0 ;
15243 PyObject * obj1 = 0 ;
15244 PyObject * obj2 = 0 ;
15245 char *kwnames[] = {
15246 (char *) "self",(char *) "row",(char *) "col", NULL
15247 };
15248
15249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) goto fail;
15250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15251 if (SWIG_arg_fail(1)) SWIG_fail;
15252 {
15253 arg2 = static_cast<int >(SWIG_As_int(obj1));
15254 if (SWIG_arg_fail(2)) SWIG_fail;
15255 }
15256 {
15257 arg3 = static_cast<int >(SWIG_As_int(obj2));
15258 if (SWIG_arg_fail(3)) SWIG_fail;
15259 }
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
15263
15264 wxPyEndAllowThreads(__tstate);
15265 if (PyErr_Occurred()) SWIG_fail;
15266 }
15267 {
15268 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
15269 }
15270 return resultobj;
15271 fail:
15272 return NULL;
15273 }
15274
15275
15276 static PyObject *_wrap_Grid_SetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15277 PyObject *resultobj = NULL;
15278 wxGrid *arg1 = (wxGrid *) 0 ;
15279 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
15280 PyObject * obj0 = 0 ;
15281 PyObject * obj1 = 0 ;
15282 char *kwnames[] = {
15283 (char *) "self",(char *) "editor", NULL
15284 };
15285
15286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) goto fail;
15287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15288 if (SWIG_arg_fail(1)) SWIG_fail;
15289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15290 if (SWIG_arg_fail(2)) SWIG_fail;
15291 {
15292 PyThreadState* __tstate = wxPyBeginAllowThreads();
15293 (arg1)->SetDefaultEditor(arg2);
15294
15295 wxPyEndAllowThreads(__tstate);
15296 if (PyErr_Occurred()) SWIG_fail;
15297 }
15298 Py_INCREF(Py_None); resultobj = Py_None;
15299 return resultobj;
15300 fail:
15301 return NULL;
15302 }
15303
15304
15305 static PyObject *_wrap_Grid_SetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15306 PyObject *resultobj = NULL;
15307 wxGrid *arg1 = (wxGrid *) 0 ;
15308 int arg2 ;
15309 int arg3 ;
15310 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
15311 PyObject * obj0 = 0 ;
15312 PyObject * obj1 = 0 ;
15313 PyObject * obj2 = 0 ;
15314 PyObject * obj3 = 0 ;
15315 char *kwnames[] = {
15316 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
15317 };
15318
15319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15321 if (SWIG_arg_fail(1)) SWIG_fail;
15322 {
15323 arg2 = static_cast<int >(SWIG_As_int(obj1));
15324 if (SWIG_arg_fail(2)) SWIG_fail;
15325 }
15326 {
15327 arg3 = static_cast<int >(SWIG_As_int(obj2));
15328 if (SWIG_arg_fail(3)) SWIG_fail;
15329 }
15330 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
15331 if (SWIG_arg_fail(4)) SWIG_fail;
15332 {
15333 PyThreadState* __tstate = wxPyBeginAllowThreads();
15334 (arg1)->SetCellEditor(arg2,arg3,arg4);
15335
15336 wxPyEndAllowThreads(__tstate);
15337 if (PyErr_Occurred()) SWIG_fail;
15338 }
15339 Py_INCREF(Py_None); resultobj = Py_None;
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 static PyObject *_wrap_Grid_GetDefaultEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15347 PyObject *resultobj = NULL;
15348 wxGrid *arg1 = (wxGrid *) 0 ;
15349 wxGridCellEditor *result;
15350 PyObject * obj0 = 0 ;
15351 char *kwnames[] = {
15352 (char *) "self", NULL
15353 };
15354
15355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetDefaultEditor",kwnames,&obj0)) goto fail;
15356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15357 if (SWIG_arg_fail(1)) SWIG_fail;
15358 {
15359 PyThreadState* __tstate = wxPyBeginAllowThreads();
15360 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
15361
15362 wxPyEndAllowThreads(__tstate);
15363 if (PyErr_Occurred()) SWIG_fail;
15364 }
15365 {
15366 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
15367 }
15368 return resultobj;
15369 fail:
15370 return NULL;
15371 }
15372
15373
15374 static PyObject *_wrap_Grid_GetCellEditor(PyObject *, PyObject *args, PyObject *kwargs) {
15375 PyObject *resultobj = NULL;
15376 wxGrid *arg1 = (wxGrid *) 0 ;
15377 int arg2 ;
15378 int arg3 ;
15379 wxGridCellEditor *result;
15380 PyObject * obj0 = 0 ;
15381 PyObject * obj1 = 0 ;
15382 PyObject * obj2 = 0 ;
15383 char *kwnames[] = {
15384 (char *) "self",(char *) "row",(char *) "col", NULL
15385 };
15386
15387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) goto fail;
15388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15389 if (SWIG_arg_fail(1)) SWIG_fail;
15390 {
15391 arg2 = static_cast<int >(SWIG_As_int(obj1));
15392 if (SWIG_arg_fail(2)) SWIG_fail;
15393 }
15394 {
15395 arg3 = static_cast<int >(SWIG_As_int(obj2));
15396 if (SWIG_arg_fail(3)) SWIG_fail;
15397 }
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
15401
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 {
15406 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
15407 }
15408 return resultobj;
15409 fail:
15410 return NULL;
15411 }
15412
15413
15414 static PyObject *_wrap_Grid_GetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15415 PyObject *resultobj = NULL;
15416 wxGrid *arg1 = (wxGrid *) 0 ;
15417 int arg2 ;
15418 int arg3 ;
15419 wxString result;
15420 PyObject * obj0 = 0 ;
15421 PyObject * obj1 = 0 ;
15422 PyObject * obj2 = 0 ;
15423 char *kwnames[] = {
15424 (char *) "self",(char *) "row",(char *) "col", NULL
15425 };
15426
15427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
15428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15429 if (SWIG_arg_fail(1)) SWIG_fail;
15430 {
15431 arg2 = static_cast<int >(SWIG_As_int(obj1));
15432 if (SWIG_arg_fail(2)) SWIG_fail;
15433 }
15434 {
15435 arg3 = static_cast<int >(SWIG_As_int(obj2));
15436 if (SWIG_arg_fail(3)) SWIG_fail;
15437 }
15438 {
15439 PyThreadState* __tstate = wxPyBeginAllowThreads();
15440 result = (arg1)->GetCellValue(arg2,arg3);
15441
15442 wxPyEndAllowThreads(__tstate);
15443 if (PyErr_Occurred()) SWIG_fail;
15444 }
15445 {
15446 #if wxUSE_UNICODE
15447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15448 #else
15449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15450 #endif
15451 }
15452 return resultobj;
15453 fail:
15454 return NULL;
15455 }
15456
15457
15458 static PyObject *_wrap_Grid_SetCellValue(PyObject *, PyObject *args, PyObject *kwargs) {
15459 PyObject *resultobj = NULL;
15460 wxGrid *arg1 = (wxGrid *) 0 ;
15461 int arg2 ;
15462 int arg3 ;
15463 wxString *arg4 = 0 ;
15464 bool temp4 = false ;
15465 PyObject * obj0 = 0 ;
15466 PyObject * obj1 = 0 ;
15467 PyObject * obj2 = 0 ;
15468 PyObject * obj3 = 0 ;
15469 char *kwnames[] = {
15470 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
15471 };
15472
15473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15475 if (SWIG_arg_fail(1)) SWIG_fail;
15476 {
15477 arg2 = static_cast<int >(SWIG_As_int(obj1));
15478 if (SWIG_arg_fail(2)) SWIG_fail;
15479 }
15480 {
15481 arg3 = static_cast<int >(SWIG_As_int(obj2));
15482 if (SWIG_arg_fail(3)) SWIG_fail;
15483 }
15484 {
15485 arg4 = wxString_in_helper(obj3);
15486 if (arg4 == NULL) SWIG_fail;
15487 temp4 = true;
15488 }
15489 {
15490 PyThreadState* __tstate = wxPyBeginAllowThreads();
15491 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
15492
15493 wxPyEndAllowThreads(__tstate);
15494 if (PyErr_Occurred()) SWIG_fail;
15495 }
15496 Py_INCREF(Py_None); resultobj = Py_None;
15497 {
15498 if (temp4)
15499 delete arg4;
15500 }
15501 return resultobj;
15502 fail:
15503 {
15504 if (temp4)
15505 delete arg4;
15506 }
15507 return NULL;
15508 }
15509
15510
15511 static PyObject *_wrap_Grid_IsReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15512 PyObject *resultobj = NULL;
15513 wxGrid *arg1 = (wxGrid *) 0 ;
15514 int arg2 ;
15515 int arg3 ;
15516 bool result;
15517 PyObject * obj0 = 0 ;
15518 PyObject * obj1 = 0 ;
15519 PyObject * obj2 = 0 ;
15520 char *kwnames[] = {
15521 (char *) "self",(char *) "row",(char *) "col", NULL
15522 };
15523
15524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) goto fail;
15525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15526 if (SWIG_arg_fail(1)) SWIG_fail;
15527 {
15528 arg2 = static_cast<int >(SWIG_As_int(obj1));
15529 if (SWIG_arg_fail(2)) SWIG_fail;
15530 }
15531 {
15532 arg3 = static_cast<int >(SWIG_As_int(obj2));
15533 if (SWIG_arg_fail(3)) SWIG_fail;
15534 }
15535 {
15536 PyThreadState* __tstate = wxPyBeginAllowThreads();
15537 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
15538
15539 wxPyEndAllowThreads(__tstate);
15540 if (PyErr_Occurred()) SWIG_fail;
15541 }
15542 {
15543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15544 }
15545 return resultobj;
15546 fail:
15547 return NULL;
15548 }
15549
15550
15551 static PyObject *_wrap_Grid_SetReadOnly(PyObject *, PyObject *args, PyObject *kwargs) {
15552 PyObject *resultobj = NULL;
15553 wxGrid *arg1 = (wxGrid *) 0 ;
15554 int arg2 ;
15555 int arg3 ;
15556 bool arg4 = (bool) true ;
15557 PyObject * obj0 = 0 ;
15558 PyObject * obj1 = 0 ;
15559 PyObject * obj2 = 0 ;
15560 PyObject * obj3 = 0 ;
15561 char *kwnames[] = {
15562 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
15563 };
15564
15565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15567 if (SWIG_arg_fail(1)) SWIG_fail;
15568 {
15569 arg2 = static_cast<int >(SWIG_As_int(obj1));
15570 if (SWIG_arg_fail(2)) SWIG_fail;
15571 }
15572 {
15573 arg3 = static_cast<int >(SWIG_As_int(obj2));
15574 if (SWIG_arg_fail(3)) SWIG_fail;
15575 }
15576 if (obj3) {
15577 {
15578 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
15579 if (SWIG_arg_fail(4)) SWIG_fail;
15580 }
15581 }
15582 {
15583 PyThreadState* __tstate = wxPyBeginAllowThreads();
15584 (arg1)->SetReadOnly(arg2,arg3,arg4);
15585
15586 wxPyEndAllowThreads(__tstate);
15587 if (PyErr_Occurred()) SWIG_fail;
15588 }
15589 Py_INCREF(Py_None); resultobj = Py_None;
15590 return resultobj;
15591 fail:
15592 return NULL;
15593 }
15594
15595
15596 static PyObject *_wrap_Grid_SelectRow(PyObject *, PyObject *args, PyObject *kwargs) {
15597 PyObject *resultobj = NULL;
15598 wxGrid *arg1 = (wxGrid *) 0 ;
15599 int arg2 ;
15600 bool arg3 = (bool) false ;
15601 PyObject * obj0 = 0 ;
15602 PyObject * obj1 = 0 ;
15603 PyObject * obj2 = 0 ;
15604 char *kwnames[] = {
15605 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
15606 };
15607
15608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
15609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15610 if (SWIG_arg_fail(1)) SWIG_fail;
15611 {
15612 arg2 = static_cast<int >(SWIG_As_int(obj1));
15613 if (SWIG_arg_fail(2)) SWIG_fail;
15614 }
15615 if (obj2) {
15616 {
15617 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15618 if (SWIG_arg_fail(3)) SWIG_fail;
15619 }
15620 }
15621 {
15622 PyThreadState* __tstate = wxPyBeginAllowThreads();
15623 (arg1)->SelectRow(arg2,arg3);
15624
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 Py_INCREF(Py_None); resultobj = Py_None;
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 static PyObject *_wrap_Grid_SelectCol(PyObject *, PyObject *args, PyObject *kwargs) {
15636 PyObject *resultobj = NULL;
15637 wxGrid *arg1 = (wxGrid *) 0 ;
15638 int arg2 ;
15639 bool arg3 = (bool) false ;
15640 PyObject * obj0 = 0 ;
15641 PyObject * obj1 = 0 ;
15642 PyObject * obj2 = 0 ;
15643 char *kwnames[] = {
15644 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
15645 };
15646
15647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
15648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15649 if (SWIG_arg_fail(1)) SWIG_fail;
15650 {
15651 arg2 = static_cast<int >(SWIG_As_int(obj1));
15652 if (SWIG_arg_fail(2)) SWIG_fail;
15653 }
15654 if (obj2) {
15655 {
15656 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15657 if (SWIG_arg_fail(3)) SWIG_fail;
15658 }
15659 }
15660 {
15661 PyThreadState* __tstate = wxPyBeginAllowThreads();
15662 (arg1)->SelectCol(arg2,arg3);
15663
15664 wxPyEndAllowThreads(__tstate);
15665 if (PyErr_Occurred()) SWIG_fail;
15666 }
15667 Py_INCREF(Py_None); resultobj = Py_None;
15668 return resultobj;
15669 fail:
15670 return NULL;
15671 }
15672
15673
15674 static PyObject *_wrap_Grid_SelectBlock(PyObject *, PyObject *args, PyObject *kwargs) {
15675 PyObject *resultobj = NULL;
15676 wxGrid *arg1 = (wxGrid *) 0 ;
15677 int arg2 ;
15678 int arg3 ;
15679 int arg4 ;
15680 int arg5 ;
15681 bool arg6 = (bool) false ;
15682 PyObject * obj0 = 0 ;
15683 PyObject * obj1 = 0 ;
15684 PyObject * obj2 = 0 ;
15685 PyObject * obj3 = 0 ;
15686 PyObject * obj4 = 0 ;
15687 PyObject * obj5 = 0 ;
15688 char *kwnames[] = {
15689 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
15690 };
15691
15692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15694 if (SWIG_arg_fail(1)) SWIG_fail;
15695 {
15696 arg2 = static_cast<int >(SWIG_As_int(obj1));
15697 if (SWIG_arg_fail(2)) SWIG_fail;
15698 }
15699 {
15700 arg3 = static_cast<int >(SWIG_As_int(obj2));
15701 if (SWIG_arg_fail(3)) SWIG_fail;
15702 }
15703 {
15704 arg4 = static_cast<int >(SWIG_As_int(obj3));
15705 if (SWIG_arg_fail(4)) SWIG_fail;
15706 }
15707 {
15708 arg5 = static_cast<int >(SWIG_As_int(obj4));
15709 if (SWIG_arg_fail(5)) SWIG_fail;
15710 }
15711 if (obj5) {
15712 {
15713 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
15714 if (SWIG_arg_fail(6)) SWIG_fail;
15715 }
15716 }
15717 {
15718 PyThreadState* __tstate = wxPyBeginAllowThreads();
15719 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
15720
15721 wxPyEndAllowThreads(__tstate);
15722 if (PyErr_Occurred()) SWIG_fail;
15723 }
15724 Py_INCREF(Py_None); resultobj = Py_None;
15725 return resultobj;
15726 fail:
15727 return NULL;
15728 }
15729
15730
15731 static PyObject *_wrap_Grid_SelectAll(PyObject *, PyObject *args, PyObject *kwargs) {
15732 PyObject *resultobj = NULL;
15733 wxGrid *arg1 = (wxGrid *) 0 ;
15734 PyObject * obj0 = 0 ;
15735 char *kwnames[] = {
15736 (char *) "self", NULL
15737 };
15738
15739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_SelectAll",kwnames,&obj0)) goto fail;
15740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15741 if (SWIG_arg_fail(1)) SWIG_fail;
15742 {
15743 PyThreadState* __tstate = wxPyBeginAllowThreads();
15744 (arg1)->SelectAll();
15745
15746 wxPyEndAllowThreads(__tstate);
15747 if (PyErr_Occurred()) SWIG_fail;
15748 }
15749 Py_INCREF(Py_None); resultobj = Py_None;
15750 return resultobj;
15751 fail:
15752 return NULL;
15753 }
15754
15755
15756 static PyObject *_wrap_Grid_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15757 PyObject *resultobj = NULL;
15758 wxGrid *arg1 = (wxGrid *) 0 ;
15759 bool result;
15760 PyObject * obj0 = 0 ;
15761 char *kwnames[] = {
15762 (char *) "self", NULL
15763 };
15764
15765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_IsSelection",kwnames,&obj0)) goto fail;
15766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15767 if (SWIG_arg_fail(1)) SWIG_fail;
15768 {
15769 PyThreadState* __tstate = wxPyBeginAllowThreads();
15770 result = (bool)(arg1)->IsSelection();
15771
15772 wxPyEndAllowThreads(__tstate);
15773 if (PyErr_Occurred()) SWIG_fail;
15774 }
15775 {
15776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15777 }
15778 return resultobj;
15779 fail:
15780 return NULL;
15781 }
15782
15783
15784 static PyObject *_wrap_Grid_ClearSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15785 PyObject *resultobj = NULL;
15786 wxGrid *arg1 = (wxGrid *) 0 ;
15787 PyObject * obj0 = 0 ;
15788 char *kwnames[] = {
15789 (char *) "self", NULL
15790 };
15791
15792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_ClearSelection",kwnames,&obj0)) goto fail;
15793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15794 if (SWIG_arg_fail(1)) SWIG_fail;
15795 {
15796 PyThreadState* __tstate = wxPyBeginAllowThreads();
15797 (arg1)->ClearSelection();
15798
15799 wxPyEndAllowThreads(__tstate);
15800 if (PyErr_Occurred()) SWIG_fail;
15801 }
15802 Py_INCREF(Py_None); resultobj = Py_None;
15803 return resultobj;
15804 fail:
15805 return NULL;
15806 }
15807
15808
15809 static PyObject *_wrap_Grid_IsInSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15810 PyObject *resultobj = NULL;
15811 wxGrid *arg1 = (wxGrid *) 0 ;
15812 int arg2 ;
15813 int arg3 ;
15814 bool result;
15815 PyObject * obj0 = 0 ;
15816 PyObject * obj1 = 0 ;
15817 PyObject * obj2 = 0 ;
15818 char *kwnames[] = {
15819 (char *) "self",(char *) "row",(char *) "col", NULL
15820 };
15821
15822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) goto fail;
15823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15824 if (SWIG_arg_fail(1)) SWIG_fail;
15825 {
15826 arg2 = static_cast<int >(SWIG_As_int(obj1));
15827 if (SWIG_arg_fail(2)) SWIG_fail;
15828 }
15829 {
15830 arg3 = static_cast<int >(SWIG_As_int(obj2));
15831 if (SWIG_arg_fail(3)) SWIG_fail;
15832 }
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (bool)(arg1)->IsInSelection(arg2,arg3);
15836
15837 wxPyEndAllowThreads(__tstate);
15838 if (PyErr_Occurred()) SWIG_fail;
15839 }
15840 {
15841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15842 }
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 static PyObject *_wrap_Grid_GetSelectedCells(PyObject *, PyObject *args, PyObject *kwargs) {
15850 PyObject *resultobj = NULL;
15851 wxGrid *arg1 = (wxGrid *) 0 ;
15852 wxGridCellCoordsArray result;
15853 PyObject * obj0 = 0 ;
15854 char *kwnames[] = {
15855 (char *) "self", NULL
15856 };
15857
15858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCells",kwnames,&obj0)) goto fail;
15859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15860 if (SWIG_arg_fail(1)) SWIG_fail;
15861 {
15862 PyThreadState* __tstate = wxPyBeginAllowThreads();
15863 result = ((wxGrid const *)arg1)->GetSelectedCells();
15864
15865 wxPyEndAllowThreads(__tstate);
15866 if (PyErr_Occurred()) SWIG_fail;
15867 }
15868 {
15869 resultobj = wxGridCellCoordsArray_helper(result);
15870 }
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 static PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
15878 PyObject *resultobj = NULL;
15879 wxGrid *arg1 = (wxGrid *) 0 ;
15880 wxGridCellCoordsArray result;
15881 PyObject * obj0 = 0 ;
15882 char *kwnames[] = {
15883 (char *) "self", NULL
15884 };
15885
15886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockTopLeft",kwnames,&obj0)) goto fail;
15887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15888 if (SWIG_arg_fail(1)) SWIG_fail;
15889 {
15890 PyThreadState* __tstate = wxPyBeginAllowThreads();
15891 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
15892
15893 wxPyEndAllowThreads(__tstate);
15894 if (PyErr_Occurred()) SWIG_fail;
15895 }
15896 {
15897 resultobj = wxGridCellCoordsArray_helper(result);
15898 }
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 static PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
15906 PyObject *resultobj = NULL;
15907 wxGrid *arg1 = (wxGrid *) 0 ;
15908 wxGridCellCoordsArray result;
15909 PyObject * obj0 = 0 ;
15910 char *kwnames[] = {
15911 (char *) "self", NULL
15912 };
15913
15914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBlockBottomRight",kwnames,&obj0)) goto fail;
15915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15916 if (SWIG_arg_fail(1)) SWIG_fail;
15917 {
15918 PyThreadState* __tstate = wxPyBeginAllowThreads();
15919 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
15920
15921 wxPyEndAllowThreads(__tstate);
15922 if (PyErr_Occurred()) SWIG_fail;
15923 }
15924 {
15925 resultobj = wxGridCellCoordsArray_helper(result);
15926 }
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 static PyObject *_wrap_Grid_GetSelectedRows(PyObject *, PyObject *args, PyObject *kwargs) {
15934 PyObject *resultobj = NULL;
15935 wxGrid *arg1 = (wxGrid *) 0 ;
15936 wxArrayInt result;
15937 PyObject * obj0 = 0 ;
15938 char *kwnames[] = {
15939 (char *) "self", NULL
15940 };
15941
15942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedRows",kwnames,&obj0)) goto fail;
15943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15944 if (SWIG_arg_fail(1)) SWIG_fail;
15945 {
15946 PyThreadState* __tstate = wxPyBeginAllowThreads();
15947 result = ((wxGrid const *)arg1)->GetSelectedRows();
15948
15949 wxPyEndAllowThreads(__tstate);
15950 if (PyErr_Occurred()) SWIG_fail;
15951 }
15952 {
15953 resultobj = PyList_New(0);
15954 size_t idx;
15955 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15956 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15957 PyList_Append(resultobj, val);
15958 Py_DECREF(val);
15959 }
15960 }
15961 return resultobj;
15962 fail:
15963 return NULL;
15964 }
15965
15966
15967 static PyObject *_wrap_Grid_GetSelectedCols(PyObject *, PyObject *args, PyObject *kwargs) {
15968 PyObject *resultobj = NULL;
15969 wxGrid *arg1 = (wxGrid *) 0 ;
15970 wxArrayInt result;
15971 PyObject * obj0 = 0 ;
15972 char *kwnames[] = {
15973 (char *) "self", NULL
15974 };
15975
15976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectedCols",kwnames,&obj0)) goto fail;
15977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
15978 if (SWIG_arg_fail(1)) SWIG_fail;
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 result = ((wxGrid const *)arg1)->GetSelectedCols();
15982
15983 wxPyEndAllowThreads(__tstate);
15984 if (PyErr_Occurred()) SWIG_fail;
15985 }
15986 {
15987 resultobj = PyList_New(0);
15988 size_t idx;
15989 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15990 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15991 PyList_Append(resultobj, val);
15992 Py_DECREF(val);
15993 }
15994 }
15995 return resultobj;
15996 fail:
15997 return NULL;
15998 }
15999
16000
16001 static PyObject *_wrap_Grid_DeselectRow(PyObject *, PyObject *args, PyObject *kwargs) {
16002 PyObject *resultobj = NULL;
16003 wxGrid *arg1 = (wxGrid *) 0 ;
16004 int arg2 ;
16005 PyObject * obj0 = 0 ;
16006 PyObject * obj1 = 0 ;
16007 char *kwnames[] = {
16008 (char *) "self",(char *) "row", NULL
16009 };
16010
16011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) goto fail;
16012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16013 if (SWIG_arg_fail(1)) SWIG_fail;
16014 {
16015 arg2 = static_cast<int >(SWIG_As_int(obj1));
16016 if (SWIG_arg_fail(2)) SWIG_fail;
16017 }
16018 {
16019 PyThreadState* __tstate = wxPyBeginAllowThreads();
16020 (arg1)->DeselectRow(arg2);
16021
16022 wxPyEndAllowThreads(__tstate);
16023 if (PyErr_Occurred()) SWIG_fail;
16024 }
16025 Py_INCREF(Py_None); resultobj = Py_None;
16026 return resultobj;
16027 fail:
16028 return NULL;
16029 }
16030
16031
16032 static PyObject *_wrap_Grid_DeselectCol(PyObject *, PyObject *args, PyObject *kwargs) {
16033 PyObject *resultobj = NULL;
16034 wxGrid *arg1 = (wxGrid *) 0 ;
16035 int arg2 ;
16036 PyObject * obj0 = 0 ;
16037 PyObject * obj1 = 0 ;
16038 char *kwnames[] = {
16039 (char *) "self",(char *) "col", NULL
16040 };
16041
16042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) goto fail;
16043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16044 if (SWIG_arg_fail(1)) SWIG_fail;
16045 {
16046 arg2 = static_cast<int >(SWIG_As_int(obj1));
16047 if (SWIG_arg_fail(2)) SWIG_fail;
16048 }
16049 {
16050 PyThreadState* __tstate = wxPyBeginAllowThreads();
16051 (arg1)->DeselectCol(arg2);
16052
16053 wxPyEndAllowThreads(__tstate);
16054 if (PyErr_Occurred()) SWIG_fail;
16055 }
16056 Py_INCREF(Py_None); resultobj = Py_None;
16057 return resultobj;
16058 fail:
16059 return NULL;
16060 }
16061
16062
16063 static PyObject *_wrap_Grid_DeselectCell(PyObject *, PyObject *args, PyObject *kwargs) {
16064 PyObject *resultobj = NULL;
16065 wxGrid *arg1 = (wxGrid *) 0 ;
16066 int arg2 ;
16067 int arg3 ;
16068 PyObject * obj0 = 0 ;
16069 PyObject * obj1 = 0 ;
16070 PyObject * obj2 = 0 ;
16071 char *kwnames[] = {
16072 (char *) "self",(char *) "row",(char *) "col", NULL
16073 };
16074
16075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16077 if (SWIG_arg_fail(1)) SWIG_fail;
16078 {
16079 arg2 = static_cast<int >(SWIG_As_int(obj1));
16080 if (SWIG_arg_fail(2)) SWIG_fail;
16081 }
16082 {
16083 arg3 = static_cast<int >(SWIG_As_int(obj2));
16084 if (SWIG_arg_fail(3)) SWIG_fail;
16085 }
16086 {
16087 PyThreadState* __tstate = wxPyBeginAllowThreads();
16088 (arg1)->DeselectCell(arg2,arg3);
16089
16090 wxPyEndAllowThreads(__tstate);
16091 if (PyErr_Occurred()) SWIG_fail;
16092 }
16093 Py_INCREF(Py_None); resultobj = Py_None;
16094 return resultobj;
16095 fail:
16096 return NULL;
16097 }
16098
16099
16100 static PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *, PyObject *args, PyObject *kwargs) {
16101 PyObject *resultobj = NULL;
16102 wxGrid *arg1 = (wxGrid *) 0 ;
16103 wxGridCellCoords *arg2 = 0 ;
16104 wxGridCellCoords *arg3 = 0 ;
16105 wxRect result;
16106 wxGridCellCoords temp2 ;
16107 wxGridCellCoords temp3 ;
16108 PyObject * obj0 = 0 ;
16109 PyObject * obj1 = 0 ;
16110 PyObject * obj2 = 0 ;
16111 char *kwnames[] = {
16112 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
16113 };
16114
16115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
16116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16117 if (SWIG_arg_fail(1)) SWIG_fail;
16118 {
16119 arg2 = &temp2;
16120 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
16121 }
16122 {
16123 arg3 = &temp3;
16124 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
16125 }
16126 {
16127 PyThreadState* __tstate = wxPyBeginAllowThreads();
16128 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
16129
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 {
16134 wxRect * resultptr;
16135 resultptr = new wxRect(static_cast<wxRect & >(result));
16136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
16137 }
16138 return resultobj;
16139 fail:
16140 return NULL;
16141 }
16142
16143
16144 static PyObject *_wrap_Grid_GetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16145 PyObject *resultobj = NULL;
16146 wxGrid *arg1 = (wxGrid *) 0 ;
16147 wxColour result;
16148 PyObject * obj0 = 0 ;
16149 char *kwnames[] = {
16150 (char *) "self", NULL
16151 };
16152
16153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionBackground",kwnames,&obj0)) goto fail;
16154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16155 if (SWIG_arg_fail(1)) SWIG_fail;
16156 {
16157 PyThreadState* __tstate = wxPyBeginAllowThreads();
16158 result = ((wxGrid const *)arg1)->GetSelectionBackground();
16159
16160 wxPyEndAllowThreads(__tstate);
16161 if (PyErr_Occurred()) SWIG_fail;
16162 }
16163 {
16164 wxColour * resultptr;
16165 resultptr = new wxColour(static_cast<wxColour & >(result));
16166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
16167 }
16168 return resultobj;
16169 fail:
16170 return NULL;
16171 }
16172
16173
16174 static PyObject *_wrap_Grid_GetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16175 PyObject *resultobj = NULL;
16176 wxGrid *arg1 = (wxGrid *) 0 ;
16177 wxColour result;
16178 PyObject * obj0 = 0 ;
16179 char *kwnames[] = {
16180 (char *) "self", NULL
16181 };
16182
16183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetSelectionForeground",kwnames,&obj0)) goto fail;
16184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16185 if (SWIG_arg_fail(1)) SWIG_fail;
16186 {
16187 PyThreadState* __tstate = wxPyBeginAllowThreads();
16188 result = ((wxGrid const *)arg1)->GetSelectionForeground();
16189
16190 wxPyEndAllowThreads(__tstate);
16191 if (PyErr_Occurred()) SWIG_fail;
16192 }
16193 {
16194 wxColour * resultptr;
16195 resultptr = new wxColour(static_cast<wxColour & >(result));
16196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
16197 }
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 static PyObject *_wrap_Grid_SetSelectionBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj = NULL;
16206 wxGrid *arg1 = (wxGrid *) 0 ;
16207 wxColour *arg2 = 0 ;
16208 wxColour temp2 ;
16209 PyObject * obj0 = 0 ;
16210 PyObject * obj1 = 0 ;
16211 char *kwnames[] = {
16212 (char *) "self",(char *) "c", NULL
16213 };
16214
16215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) goto fail;
16216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16217 if (SWIG_arg_fail(1)) SWIG_fail;
16218 {
16219 arg2 = &temp2;
16220 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16221 }
16222 {
16223 PyThreadState* __tstate = wxPyBeginAllowThreads();
16224 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
16225
16226 wxPyEndAllowThreads(__tstate);
16227 if (PyErr_Occurred()) SWIG_fail;
16228 }
16229 Py_INCREF(Py_None); resultobj = Py_None;
16230 return resultobj;
16231 fail:
16232 return NULL;
16233 }
16234
16235
16236 static PyObject *_wrap_Grid_SetSelectionForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16237 PyObject *resultobj = NULL;
16238 wxGrid *arg1 = (wxGrid *) 0 ;
16239 wxColour *arg2 = 0 ;
16240 wxColour temp2 ;
16241 PyObject * obj0 = 0 ;
16242 PyObject * obj1 = 0 ;
16243 char *kwnames[] = {
16244 (char *) "self",(char *) "c", NULL
16245 };
16246
16247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) goto fail;
16248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16249 if (SWIG_arg_fail(1)) SWIG_fail;
16250 {
16251 arg2 = &temp2;
16252 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16253 }
16254 {
16255 PyThreadState* __tstate = wxPyBeginAllowThreads();
16256 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
16257
16258 wxPyEndAllowThreads(__tstate);
16259 if (PyErr_Occurred()) SWIG_fail;
16260 }
16261 Py_INCREF(Py_None); resultobj = Py_None;
16262 return resultobj;
16263 fail:
16264 return NULL;
16265 }
16266
16267
16268 static PyObject *_wrap_Grid_RegisterDataType(PyObject *, PyObject *args, PyObject *kwargs) {
16269 PyObject *resultobj = NULL;
16270 wxGrid *arg1 = (wxGrid *) 0 ;
16271 wxString *arg2 = 0 ;
16272 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
16273 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16274 bool temp2 = false ;
16275 PyObject * obj0 = 0 ;
16276 PyObject * obj1 = 0 ;
16277 PyObject * obj2 = 0 ;
16278 PyObject * obj3 = 0 ;
16279 char *kwnames[] = {
16280 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
16281 };
16282
16283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16285 if (SWIG_arg_fail(1)) SWIG_fail;
16286 {
16287 arg2 = wxString_in_helper(obj1);
16288 if (arg2 == NULL) SWIG_fail;
16289 temp2 = true;
16290 }
16291 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGridCellRenderer, SWIG_POINTER_EXCEPTION | 0);
16292 if (SWIG_arg_fail(3)) SWIG_fail;
16293 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGridCellEditor, SWIG_POINTER_EXCEPTION | 0);
16294 if (SWIG_arg_fail(4)) SWIG_fail;
16295 {
16296 PyThreadState* __tstate = wxPyBeginAllowThreads();
16297 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
16298
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 Py_INCREF(Py_None); resultobj = Py_None;
16303 {
16304 if (temp2)
16305 delete arg2;
16306 }
16307 return resultobj;
16308 fail:
16309 {
16310 if (temp2)
16311 delete arg2;
16312 }
16313 return NULL;
16314 }
16315
16316
16317 static PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj = NULL;
16319 wxGrid *arg1 = (wxGrid *) 0 ;
16320 int arg2 ;
16321 int arg3 ;
16322 wxGridCellEditor *result;
16323 PyObject * obj0 = 0 ;
16324 PyObject * obj1 = 0 ;
16325 PyObject * obj2 = 0 ;
16326 char *kwnames[] = {
16327 (char *) "self",(char *) "row",(char *) "col", NULL
16328 };
16329
16330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16332 if (SWIG_arg_fail(1)) SWIG_fail;
16333 {
16334 arg2 = static_cast<int >(SWIG_As_int(obj1));
16335 if (SWIG_arg_fail(2)) SWIG_fail;
16336 }
16337 {
16338 arg3 = static_cast<int >(SWIG_As_int(obj2));
16339 if (SWIG_arg_fail(3)) SWIG_fail;
16340 }
16341 {
16342 PyThreadState* __tstate = wxPyBeginAllowThreads();
16343 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
16344
16345 wxPyEndAllowThreads(__tstate);
16346 if (PyErr_Occurred()) SWIG_fail;
16347 }
16348 {
16349 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
16350 }
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 static PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *, PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj = NULL;
16359 wxGrid *arg1 = (wxGrid *) 0 ;
16360 int arg2 ;
16361 int arg3 ;
16362 wxGridCellRenderer *result;
16363 PyObject * obj0 = 0 ;
16364 PyObject * obj1 = 0 ;
16365 PyObject * obj2 = 0 ;
16366 char *kwnames[] = {
16367 (char *) "self",(char *) "row",(char *) "col", NULL
16368 };
16369
16370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) goto fail;
16371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16372 if (SWIG_arg_fail(1)) SWIG_fail;
16373 {
16374 arg2 = static_cast<int >(SWIG_As_int(obj1));
16375 if (SWIG_arg_fail(2)) SWIG_fail;
16376 }
16377 {
16378 arg3 = static_cast<int >(SWIG_As_int(obj2));
16379 if (SWIG_arg_fail(3)) SWIG_fail;
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 {
16389 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16390 }
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 static PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj = NULL;
16399 wxGrid *arg1 = (wxGrid *) 0 ;
16400 wxString *arg2 = 0 ;
16401 wxGridCellEditor *result;
16402 bool temp2 = false ;
16403 PyObject * obj0 = 0 ;
16404 PyObject * obj1 = 0 ;
16405 char *kwnames[] = {
16406 (char *) "self",(char *) "typeName", NULL
16407 };
16408
16409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) goto fail;
16410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16411 if (SWIG_arg_fail(1)) SWIG_fail;
16412 {
16413 arg2 = wxString_in_helper(obj1);
16414 if (arg2 == NULL) SWIG_fail;
16415 temp2 = true;
16416 }
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
16420
16421 wxPyEndAllowThreads(__tstate);
16422 if (PyErr_Occurred()) SWIG_fail;
16423 }
16424 {
16425 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
16426 }
16427 {
16428 if (temp2)
16429 delete arg2;
16430 }
16431 return resultobj;
16432 fail:
16433 {
16434 if (temp2)
16435 delete arg2;
16436 }
16437 return NULL;
16438 }
16439
16440
16441 static PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *, PyObject *args, PyObject *kwargs) {
16442 PyObject *resultobj = NULL;
16443 wxGrid *arg1 = (wxGrid *) 0 ;
16444 wxString *arg2 = 0 ;
16445 wxGridCellRenderer *result;
16446 bool temp2 = false ;
16447 PyObject * obj0 = 0 ;
16448 PyObject * obj1 = 0 ;
16449 char *kwnames[] = {
16450 (char *) "self",(char *) "typeName", NULL
16451 };
16452
16453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) goto fail;
16454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16455 if (SWIG_arg_fail(1)) SWIG_fail;
16456 {
16457 arg2 = wxString_in_helper(obj1);
16458 if (arg2 == NULL) SWIG_fail;
16459 temp2 = true;
16460 }
16461 {
16462 PyThreadState* __tstate = wxPyBeginAllowThreads();
16463 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
16464
16465 wxPyEndAllowThreads(__tstate);
16466 if (PyErr_Occurred()) SWIG_fail;
16467 }
16468 {
16469 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16470 }
16471 {
16472 if (temp2)
16473 delete arg2;
16474 }
16475 return resultobj;
16476 fail:
16477 {
16478 if (temp2)
16479 delete arg2;
16480 }
16481 return NULL;
16482 }
16483
16484
16485 static PyObject *_wrap_Grid_SetMargins(PyObject *, PyObject *args, PyObject *kwargs) {
16486 PyObject *resultobj = NULL;
16487 wxGrid *arg1 = (wxGrid *) 0 ;
16488 int arg2 ;
16489 int arg3 ;
16490 PyObject * obj0 = 0 ;
16491 PyObject * obj1 = 0 ;
16492 PyObject * obj2 = 0 ;
16493 char *kwnames[] = {
16494 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
16495 };
16496
16497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) goto fail;
16498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16499 if (SWIG_arg_fail(1)) SWIG_fail;
16500 {
16501 arg2 = static_cast<int >(SWIG_As_int(obj1));
16502 if (SWIG_arg_fail(2)) SWIG_fail;
16503 }
16504 {
16505 arg3 = static_cast<int >(SWIG_As_int(obj2));
16506 if (SWIG_arg_fail(3)) SWIG_fail;
16507 }
16508 {
16509 PyThreadState* __tstate = wxPyBeginAllowThreads();
16510 (arg1)->SetMargins(arg2,arg3);
16511
16512 wxPyEndAllowThreads(__tstate);
16513 if (PyErr_Occurred()) SWIG_fail;
16514 }
16515 Py_INCREF(Py_None); resultobj = Py_None;
16516 return resultobj;
16517 fail:
16518 return NULL;
16519 }
16520
16521
16522 static PyObject *_wrap_Grid_GetGridWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16523 PyObject *resultobj = NULL;
16524 wxGrid *arg1 = (wxGrid *) 0 ;
16525 wxWindow *result;
16526 PyObject * obj0 = 0 ;
16527 char *kwnames[] = {
16528 (char *) "self", NULL
16529 };
16530
16531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridWindow",kwnames,&obj0)) goto fail;
16532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16533 if (SWIG_arg_fail(1)) SWIG_fail;
16534 {
16535 PyThreadState* __tstate = wxPyBeginAllowThreads();
16536 result = (wxWindow *)(arg1)->GetGridWindow();
16537
16538 wxPyEndAllowThreads(__tstate);
16539 if (PyErr_Occurred()) SWIG_fail;
16540 }
16541 {
16542 resultobj = wxPyMake_wxObject(result, 0);
16543 }
16544 return resultobj;
16545 fail:
16546 return NULL;
16547 }
16548
16549
16550 static PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16551 PyObject *resultobj = NULL;
16552 wxGrid *arg1 = (wxGrid *) 0 ;
16553 wxWindow *result;
16554 PyObject * obj0 = 0 ;
16555 char *kwnames[] = {
16556 (char *) "self", NULL
16557 };
16558
16559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridRowLabelWindow",kwnames,&obj0)) goto fail;
16560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16561 if (SWIG_arg_fail(1)) SWIG_fail;
16562 {
16563 PyThreadState* __tstate = wxPyBeginAllowThreads();
16564 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
16565
16566 wxPyEndAllowThreads(__tstate);
16567 if (PyErr_Occurred()) SWIG_fail;
16568 }
16569 {
16570 resultobj = wxPyMake_wxObject(result, 0);
16571 }
16572 return resultobj;
16573 fail:
16574 return NULL;
16575 }
16576
16577
16578 static PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16579 PyObject *resultobj = NULL;
16580 wxGrid *arg1 = (wxGrid *) 0 ;
16581 wxWindow *result;
16582 PyObject * obj0 = 0 ;
16583 char *kwnames[] = {
16584 (char *) "self", NULL
16585 };
16586
16587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridColLabelWindow",kwnames,&obj0)) goto fail;
16588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16589 if (SWIG_arg_fail(1)) SWIG_fail;
16590 {
16591 PyThreadState* __tstate = wxPyBeginAllowThreads();
16592 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
16593
16594 wxPyEndAllowThreads(__tstate);
16595 if (PyErr_Occurred()) SWIG_fail;
16596 }
16597 {
16598 resultobj = wxPyMake_wxObject(result, 0);
16599 }
16600 return resultobj;
16601 fail:
16602 return NULL;
16603 }
16604
16605
16606 static PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *, PyObject *args, PyObject *kwargs) {
16607 PyObject *resultobj = NULL;
16608 wxGrid *arg1 = (wxGrid *) 0 ;
16609 wxWindow *result;
16610 PyObject * obj0 = 0 ;
16611 char *kwnames[] = {
16612 (char *) "self", NULL
16613 };
16614
16615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetGridCornerLabelWindow",kwnames,&obj0)) goto fail;
16616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16617 if (SWIG_arg_fail(1)) SWIG_fail;
16618 {
16619 PyThreadState* __tstate = wxPyBeginAllowThreads();
16620 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
16621
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 {
16626 resultobj = wxPyMake_wxObject(result, 0);
16627 }
16628 return resultobj;
16629 fail:
16630 return NULL;
16631 }
16632
16633
16634 static PyObject *_wrap_Grid_SetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16635 PyObject *resultobj = NULL;
16636 wxGrid *arg1 = (wxGrid *) 0 ;
16637 int arg2 ;
16638 PyObject * obj0 = 0 ;
16639 PyObject * obj1 = 0 ;
16640 char *kwnames[] = {
16641 (char *) "self",(char *) "x", NULL
16642 };
16643
16644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) goto fail;
16645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16646 if (SWIG_arg_fail(1)) SWIG_fail;
16647 {
16648 arg2 = static_cast<int >(SWIG_As_int(obj1));
16649 if (SWIG_arg_fail(2)) SWIG_fail;
16650 }
16651 {
16652 PyThreadState* __tstate = wxPyBeginAllowThreads();
16653 (arg1)->SetScrollLineX(arg2);
16654
16655 wxPyEndAllowThreads(__tstate);
16656 if (PyErr_Occurred()) SWIG_fail;
16657 }
16658 Py_INCREF(Py_None); resultobj = Py_None;
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 static PyObject *_wrap_Grid_SetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16666 PyObject *resultobj = NULL;
16667 wxGrid *arg1 = (wxGrid *) 0 ;
16668 int arg2 ;
16669 PyObject * obj0 = 0 ;
16670 PyObject * obj1 = 0 ;
16671 char *kwnames[] = {
16672 (char *) "self",(char *) "y", NULL
16673 };
16674
16675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) goto fail;
16676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16677 if (SWIG_arg_fail(1)) SWIG_fail;
16678 {
16679 arg2 = static_cast<int >(SWIG_As_int(obj1));
16680 if (SWIG_arg_fail(2)) SWIG_fail;
16681 }
16682 {
16683 PyThreadState* __tstate = wxPyBeginAllowThreads();
16684 (arg1)->SetScrollLineY(arg2);
16685
16686 wxPyEndAllowThreads(__tstate);
16687 if (PyErr_Occurred()) SWIG_fail;
16688 }
16689 Py_INCREF(Py_None); resultobj = Py_None;
16690 return resultobj;
16691 fail:
16692 return NULL;
16693 }
16694
16695
16696 static PyObject *_wrap_Grid_GetScrollLineX(PyObject *, PyObject *args, PyObject *kwargs) {
16697 PyObject *resultobj = NULL;
16698 wxGrid *arg1 = (wxGrid *) 0 ;
16699 int result;
16700 PyObject * obj0 = 0 ;
16701 char *kwnames[] = {
16702 (char *) "self", NULL
16703 };
16704
16705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineX",kwnames,&obj0)) goto fail;
16706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16707 if (SWIG_arg_fail(1)) SWIG_fail;
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
16711
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 {
16716 resultobj = SWIG_From_int(static_cast<int >(result));
16717 }
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 static PyObject *_wrap_Grid_GetScrollLineY(PyObject *, PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj = NULL;
16726 wxGrid *arg1 = (wxGrid *) 0 ;
16727 int result;
16728 PyObject * obj0 = 0 ;
16729 char *kwnames[] = {
16730 (char *) "self", NULL
16731 };
16732
16733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Grid_GetScrollLineY",kwnames,&obj0)) goto fail;
16734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16735 if (SWIG_arg_fail(1)) SWIG_fail;
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
16739
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 {
16744 resultobj = SWIG_From_int(static_cast<int >(result));
16745 }
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 static PyObject *_wrap_Grid_GetScrollX(PyObject *, PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj = NULL;
16754 wxGrid *arg1 = (wxGrid *) 0 ;
16755 int arg2 ;
16756 int result;
16757 PyObject * obj0 = 0 ;
16758 PyObject * obj1 = 0 ;
16759 char *kwnames[] = {
16760 (char *) "self",(char *) "x", NULL
16761 };
16762
16763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) goto fail;
16764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16765 if (SWIG_arg_fail(1)) SWIG_fail;
16766 {
16767 arg2 = static_cast<int >(SWIG_As_int(obj1));
16768 if (SWIG_arg_fail(2)) SWIG_fail;
16769 }
16770 {
16771 PyThreadState* __tstate = wxPyBeginAllowThreads();
16772 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
16773
16774 wxPyEndAllowThreads(__tstate);
16775 if (PyErr_Occurred()) SWIG_fail;
16776 }
16777 {
16778 resultobj = SWIG_From_int(static_cast<int >(result));
16779 }
16780 return resultobj;
16781 fail:
16782 return NULL;
16783 }
16784
16785
16786 static PyObject *_wrap_Grid_GetScrollY(PyObject *, PyObject *args, PyObject *kwargs) {
16787 PyObject *resultobj = NULL;
16788 wxGrid *arg1 = (wxGrid *) 0 ;
16789 int arg2 ;
16790 int result;
16791 PyObject * obj0 = 0 ;
16792 PyObject * obj1 = 0 ;
16793 char *kwnames[] = {
16794 (char *) "self",(char *) "y", NULL
16795 };
16796
16797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) goto fail;
16798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16799 if (SWIG_arg_fail(1)) SWIG_fail;
16800 {
16801 arg2 = static_cast<int >(SWIG_As_int(obj1));
16802 if (SWIG_arg_fail(2)) SWIG_fail;
16803 }
16804 {
16805 PyThreadState* __tstate = wxPyBeginAllowThreads();
16806 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
16807
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 {
16812 resultobj = SWIG_From_int(static_cast<int >(result));
16813 }
16814 return resultobj;
16815 fail:
16816 return NULL;
16817 }
16818
16819
16820 static PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
16821 PyObject *resultobj = NULL;
16822 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
16823 wxVisualAttributes result;
16824 PyObject * obj0 = 0 ;
16825 char *kwnames[] = {
16826 (char *) "variant", NULL
16827 };
16828
16829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
16830 if (obj0) {
16831 {
16832 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
16833 if (SWIG_arg_fail(1)) SWIG_fail;
16834 }
16835 }
16836 {
16837 if (!wxPyCheckForApp()) SWIG_fail;
16838 PyThreadState* __tstate = wxPyBeginAllowThreads();
16839 result = wxGrid::GetClassDefaultAttributes(arg1);
16840
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 {
16845 wxVisualAttributes * resultptr;
16846 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
16847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
16848 }
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 static PyObject * Grid_swigregister(PyObject *, PyObject *args) {
16856 PyObject *obj;
16857 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16858 SWIG_TypeClientData(SWIGTYPE_p_wxGrid, obj);
16859 Py_INCREF(obj);
16860 return Py_BuildValue((char *)"");
16861 }
16862 static PyObject *_wrap_new_GridEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16863 PyObject *resultobj = NULL;
16864 int arg1 ;
16865 wxEventType arg2 ;
16866 wxGrid *arg3 = (wxGrid *) 0 ;
16867 int arg4 = (int) -1 ;
16868 int arg5 = (int) -1 ;
16869 int arg6 = (int) -1 ;
16870 int arg7 = (int) -1 ;
16871 bool arg8 = (bool) true ;
16872 bool arg9 = (bool) false ;
16873 bool arg10 = (bool) false ;
16874 bool arg11 = (bool) false ;
16875 bool arg12 = (bool) false ;
16876 wxGridEvent *result;
16877 PyObject * obj0 = 0 ;
16878 PyObject * obj1 = 0 ;
16879 PyObject * obj2 = 0 ;
16880 PyObject * obj3 = 0 ;
16881 PyObject * obj4 = 0 ;
16882 PyObject * obj5 = 0 ;
16883 PyObject * obj6 = 0 ;
16884 PyObject * obj7 = 0 ;
16885 PyObject * obj8 = 0 ;
16886 PyObject * obj9 = 0 ;
16887 PyObject * obj10 = 0 ;
16888 PyObject * obj11 = 0 ;
16889 char *kwnames[] = {
16890 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "x",(char *) "y",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
16891 };
16892
16893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOOOO:new_GridEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) goto fail;
16894 {
16895 arg1 = static_cast<int >(SWIG_As_int(obj0));
16896 if (SWIG_arg_fail(1)) SWIG_fail;
16897 }
16898 {
16899 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
16900 if (SWIG_arg_fail(2)) SWIG_fail;
16901 }
16902 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
16903 if (SWIG_arg_fail(3)) SWIG_fail;
16904 if (obj3) {
16905 {
16906 arg4 = static_cast<int >(SWIG_As_int(obj3));
16907 if (SWIG_arg_fail(4)) SWIG_fail;
16908 }
16909 }
16910 if (obj4) {
16911 {
16912 arg5 = static_cast<int >(SWIG_As_int(obj4));
16913 if (SWIG_arg_fail(5)) SWIG_fail;
16914 }
16915 }
16916 if (obj5) {
16917 {
16918 arg6 = static_cast<int >(SWIG_As_int(obj5));
16919 if (SWIG_arg_fail(6)) SWIG_fail;
16920 }
16921 }
16922 if (obj6) {
16923 {
16924 arg7 = static_cast<int >(SWIG_As_int(obj6));
16925 if (SWIG_arg_fail(7)) SWIG_fail;
16926 }
16927 }
16928 if (obj7) {
16929 {
16930 arg8 = static_cast<bool >(SWIG_As_bool(obj7));
16931 if (SWIG_arg_fail(8)) SWIG_fail;
16932 }
16933 }
16934 if (obj8) {
16935 {
16936 arg9 = static_cast<bool >(SWIG_As_bool(obj8));
16937 if (SWIG_arg_fail(9)) SWIG_fail;
16938 }
16939 }
16940 if (obj9) {
16941 {
16942 arg10 = static_cast<bool >(SWIG_As_bool(obj9));
16943 if (SWIG_arg_fail(10)) SWIG_fail;
16944 }
16945 }
16946 if (obj10) {
16947 {
16948 arg11 = static_cast<bool >(SWIG_As_bool(obj10));
16949 if (SWIG_arg_fail(11)) SWIG_fail;
16950 }
16951 }
16952 if (obj11) {
16953 {
16954 arg12 = static_cast<bool >(SWIG_As_bool(obj11));
16955 if (SWIG_arg_fail(12)) SWIG_fail;
16956 }
16957 }
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16961
16962 wxPyEndAllowThreads(__tstate);
16963 if (PyErr_Occurred()) SWIG_fail;
16964 }
16965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEvent, 1);
16966 return resultobj;
16967 fail:
16968 return NULL;
16969 }
16970
16971
16972 static PyObject *_wrap_GridEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
16973 PyObject *resultobj = NULL;
16974 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
16975 int result;
16976 PyObject * obj0 = 0 ;
16977 char *kwnames[] = {
16978 (char *) "self", NULL
16979 };
16980
16981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetRow",kwnames,&obj0)) goto fail;
16982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
16983 if (SWIG_arg_fail(1)) SWIG_fail;
16984 {
16985 PyThreadState* __tstate = wxPyBeginAllowThreads();
16986 result = (int)(arg1)->GetRow();
16987
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 {
16992 resultobj = SWIG_From_int(static_cast<int >(result));
16993 }
16994 return resultobj;
16995 fail:
16996 return NULL;
16997 }
16998
16999
17000 static PyObject *_wrap_GridEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17001 PyObject *resultobj = NULL;
17002 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17003 int result;
17004 PyObject * obj0 = 0 ;
17005 char *kwnames[] = {
17006 (char *) "self", NULL
17007 };
17008
17009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetCol",kwnames,&obj0)) goto fail;
17010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17011 if (SWIG_arg_fail(1)) SWIG_fail;
17012 {
17013 PyThreadState* __tstate = wxPyBeginAllowThreads();
17014 result = (int)(arg1)->GetCol();
17015
17016 wxPyEndAllowThreads(__tstate);
17017 if (PyErr_Occurred()) SWIG_fail;
17018 }
17019 {
17020 resultobj = SWIG_From_int(static_cast<int >(result));
17021 }
17022 return resultobj;
17023 fail:
17024 return NULL;
17025 }
17026
17027
17028 static PyObject *_wrap_GridEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17029 PyObject *resultobj = NULL;
17030 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17031 wxPoint result;
17032 PyObject * obj0 = 0 ;
17033 char *kwnames[] = {
17034 (char *) "self", NULL
17035 };
17036
17037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_GetPosition",kwnames,&obj0)) goto fail;
17038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17039 if (SWIG_arg_fail(1)) SWIG_fail;
17040 {
17041 PyThreadState* __tstate = wxPyBeginAllowThreads();
17042 result = (arg1)->GetPosition();
17043
17044 wxPyEndAllowThreads(__tstate);
17045 if (PyErr_Occurred()) SWIG_fail;
17046 }
17047 {
17048 wxPoint * resultptr;
17049 resultptr = new wxPoint(static_cast<wxPoint & >(result));
17050 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17051 }
17052 return resultobj;
17053 fail:
17054 return NULL;
17055 }
17056
17057
17058 static PyObject *_wrap_GridEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
17059 PyObject *resultobj = NULL;
17060 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17061 bool result;
17062 PyObject * obj0 = 0 ;
17063 char *kwnames[] = {
17064 (char *) "self", NULL
17065 };
17066
17067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_Selecting",kwnames,&obj0)) goto fail;
17068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17069 if (SWIG_arg_fail(1)) SWIG_fail;
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 result = (bool)(arg1)->Selecting();
17073
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 {
17078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17079 }
17080 return resultobj;
17081 fail:
17082 return NULL;
17083 }
17084
17085
17086 static PyObject *_wrap_GridEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17087 PyObject *resultobj = NULL;
17088 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17089 bool result;
17090 PyObject * obj0 = 0 ;
17091 char *kwnames[] = {
17092 (char *) "self", NULL
17093 };
17094
17095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ControlDown",kwnames,&obj0)) goto fail;
17096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17097 if (SWIG_arg_fail(1)) SWIG_fail;
17098 {
17099 PyThreadState* __tstate = wxPyBeginAllowThreads();
17100 result = (bool)(arg1)->ControlDown();
17101
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 {
17106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17107 }
17108 return resultobj;
17109 fail:
17110 return NULL;
17111 }
17112
17113
17114 static PyObject *_wrap_GridEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17115 PyObject *resultobj = NULL;
17116 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17117 bool result;
17118 PyObject * obj0 = 0 ;
17119 char *kwnames[] = {
17120 (char *) "self", NULL
17121 };
17122
17123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_MetaDown",kwnames,&obj0)) goto fail;
17124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17125 if (SWIG_arg_fail(1)) SWIG_fail;
17126 {
17127 PyThreadState* __tstate = wxPyBeginAllowThreads();
17128 result = (bool)(arg1)->MetaDown();
17129
17130 wxPyEndAllowThreads(__tstate);
17131 if (PyErr_Occurred()) SWIG_fail;
17132 }
17133 {
17134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17135 }
17136 return resultobj;
17137 fail:
17138 return NULL;
17139 }
17140
17141
17142 static PyObject *_wrap_GridEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17143 PyObject *resultobj = NULL;
17144 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17145 bool result;
17146 PyObject * obj0 = 0 ;
17147 char *kwnames[] = {
17148 (char *) "self", NULL
17149 };
17150
17151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_ShiftDown",kwnames,&obj0)) goto fail;
17152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17153 if (SWIG_arg_fail(1)) SWIG_fail;
17154 {
17155 PyThreadState* __tstate = wxPyBeginAllowThreads();
17156 result = (bool)(arg1)->ShiftDown();
17157
17158 wxPyEndAllowThreads(__tstate);
17159 if (PyErr_Occurred()) SWIG_fail;
17160 }
17161 {
17162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17163 }
17164 return resultobj;
17165 fail:
17166 return NULL;
17167 }
17168
17169
17170 static PyObject *_wrap_GridEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17171 PyObject *resultobj = NULL;
17172 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
17173 bool result;
17174 PyObject * obj0 = 0 ;
17175 char *kwnames[] = {
17176 (char *) "self", NULL
17177 };
17178
17179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEvent_AltDown",kwnames,&obj0)) goto fail;
17180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEvent, SWIG_POINTER_EXCEPTION | 0);
17181 if (SWIG_arg_fail(1)) SWIG_fail;
17182 {
17183 PyThreadState* __tstate = wxPyBeginAllowThreads();
17184 result = (bool)(arg1)->AltDown();
17185
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 {
17190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17191 }
17192 return resultobj;
17193 fail:
17194 return NULL;
17195 }
17196
17197
17198 static PyObject * GridEvent_swigregister(PyObject *, PyObject *args) {
17199 PyObject *obj;
17200 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17201 SWIG_TypeClientData(SWIGTYPE_p_wxGridEvent, obj);
17202 Py_INCREF(obj);
17203 return Py_BuildValue((char *)"");
17204 }
17205 static PyObject *_wrap_new_GridSizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17206 PyObject *resultobj = NULL;
17207 int arg1 ;
17208 wxEventType arg2 ;
17209 wxGrid *arg3 = (wxGrid *) 0 ;
17210 int arg4 = (int) -1 ;
17211 int arg5 = (int) -1 ;
17212 int arg6 = (int) -1 ;
17213 bool arg7 = (bool) false ;
17214 bool arg8 = (bool) false ;
17215 bool arg9 = (bool) false ;
17216 bool arg10 = (bool) false ;
17217 wxGridSizeEvent *result;
17218 PyObject * obj0 = 0 ;
17219 PyObject * obj1 = 0 ;
17220 PyObject * obj2 = 0 ;
17221 PyObject * obj3 = 0 ;
17222 PyObject * obj4 = 0 ;
17223 PyObject * obj5 = 0 ;
17224 PyObject * obj6 = 0 ;
17225 PyObject * obj7 = 0 ;
17226 PyObject * obj8 = 0 ;
17227 PyObject * obj9 = 0 ;
17228 char *kwnames[] = {
17229 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17230 };
17231
17232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17233 {
17234 arg1 = static_cast<int >(SWIG_As_int(obj0));
17235 if (SWIG_arg_fail(1)) SWIG_fail;
17236 }
17237 {
17238 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
17239 if (SWIG_arg_fail(2)) SWIG_fail;
17240 }
17241 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17242 if (SWIG_arg_fail(3)) SWIG_fail;
17243 if (obj3) {
17244 {
17245 arg4 = static_cast<int >(SWIG_As_int(obj3));
17246 if (SWIG_arg_fail(4)) SWIG_fail;
17247 }
17248 }
17249 if (obj4) {
17250 {
17251 arg5 = static_cast<int >(SWIG_As_int(obj4));
17252 if (SWIG_arg_fail(5)) SWIG_fail;
17253 }
17254 }
17255 if (obj5) {
17256 {
17257 arg6 = static_cast<int >(SWIG_As_int(obj5));
17258 if (SWIG_arg_fail(6)) SWIG_fail;
17259 }
17260 }
17261 if (obj6) {
17262 {
17263 arg7 = static_cast<bool >(SWIG_As_bool(obj6));
17264 if (SWIG_arg_fail(7)) SWIG_fail;
17265 }
17266 }
17267 if (obj7) {
17268 {
17269 arg8 = static_cast<bool >(SWIG_As_bool(obj7));
17270 if (SWIG_arg_fail(8)) SWIG_fail;
17271 }
17272 }
17273 if (obj8) {
17274 {
17275 arg9 = static_cast<bool >(SWIG_As_bool(obj8));
17276 if (SWIG_arg_fail(9)) SWIG_fail;
17277 }
17278 }
17279 if (obj9) {
17280 {
17281 arg10 = static_cast<bool >(SWIG_As_bool(obj9));
17282 if (SWIG_arg_fail(10)) SWIG_fail;
17283 }
17284 }
17285 {
17286 PyThreadState* __tstate = wxPyBeginAllowThreads();
17287 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
17288
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizeEvent, 1);
17293 return resultobj;
17294 fail:
17295 return NULL;
17296 }
17297
17298
17299 static PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *, PyObject *args, PyObject *kwargs) {
17300 PyObject *resultobj = NULL;
17301 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17302 int result;
17303 PyObject * obj0 = 0 ;
17304 char *kwnames[] = {
17305 (char *) "self", NULL
17306 };
17307
17308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetRowOrCol",kwnames,&obj0)) goto fail;
17309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17310 if (SWIG_arg_fail(1)) SWIG_fail;
17311 {
17312 PyThreadState* __tstate = wxPyBeginAllowThreads();
17313 result = (int)(arg1)->GetRowOrCol();
17314
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 {
17319 resultobj = SWIG_From_int(static_cast<int >(result));
17320 }
17321 return resultobj;
17322 fail:
17323 return NULL;
17324 }
17325
17326
17327 static PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17328 PyObject *resultobj = NULL;
17329 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17330 wxPoint result;
17331 PyObject * obj0 = 0 ;
17332 char *kwnames[] = {
17333 (char *) "self", NULL
17334 };
17335
17336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_GetPosition",kwnames,&obj0)) goto fail;
17337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17338 if (SWIG_arg_fail(1)) SWIG_fail;
17339 {
17340 PyThreadState* __tstate = wxPyBeginAllowThreads();
17341 result = (arg1)->GetPosition();
17342
17343 wxPyEndAllowThreads(__tstate);
17344 if (PyErr_Occurred()) SWIG_fail;
17345 }
17346 {
17347 wxPoint * resultptr;
17348 resultptr = new wxPoint(static_cast<wxPoint & >(result));
17349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17350 }
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 static PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj = NULL;
17359 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17360 bool result;
17361 PyObject * obj0 = 0 ;
17362 char *kwnames[] = {
17363 (char *) "self", NULL
17364 };
17365
17366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ControlDown",kwnames,&obj0)) goto fail;
17367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17368 if (SWIG_arg_fail(1)) SWIG_fail;
17369 {
17370 PyThreadState* __tstate = wxPyBeginAllowThreads();
17371 result = (bool)(arg1)->ControlDown();
17372
17373 wxPyEndAllowThreads(__tstate);
17374 if (PyErr_Occurred()) SWIG_fail;
17375 }
17376 {
17377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17378 }
17379 return resultobj;
17380 fail:
17381 return NULL;
17382 }
17383
17384
17385 static PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17386 PyObject *resultobj = NULL;
17387 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17388 bool result;
17389 PyObject * obj0 = 0 ;
17390 char *kwnames[] = {
17391 (char *) "self", NULL
17392 };
17393
17394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_MetaDown",kwnames,&obj0)) goto fail;
17395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17396 if (SWIG_arg_fail(1)) SWIG_fail;
17397 {
17398 PyThreadState* __tstate = wxPyBeginAllowThreads();
17399 result = (bool)(arg1)->MetaDown();
17400
17401 wxPyEndAllowThreads(__tstate);
17402 if (PyErr_Occurred()) SWIG_fail;
17403 }
17404 {
17405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17406 }
17407 return resultobj;
17408 fail:
17409 return NULL;
17410 }
17411
17412
17413 static PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17414 PyObject *resultobj = NULL;
17415 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17416 bool result;
17417 PyObject * obj0 = 0 ;
17418 char *kwnames[] = {
17419 (char *) "self", NULL
17420 };
17421
17422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_ShiftDown",kwnames,&obj0)) goto fail;
17423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17424 if (SWIG_arg_fail(1)) SWIG_fail;
17425 {
17426 PyThreadState* __tstate = wxPyBeginAllowThreads();
17427 result = (bool)(arg1)->ShiftDown();
17428
17429 wxPyEndAllowThreads(__tstate);
17430 if (PyErr_Occurred()) SWIG_fail;
17431 }
17432 {
17433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17434 }
17435 return resultobj;
17436 fail:
17437 return NULL;
17438 }
17439
17440
17441 static PyObject *_wrap_GridSizeEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17442 PyObject *resultobj = NULL;
17443 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
17444 bool result;
17445 PyObject * obj0 = 0 ;
17446 char *kwnames[] = {
17447 (char *) "self", NULL
17448 };
17449
17450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizeEvent_AltDown",kwnames,&obj0)) goto fail;
17451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_EXCEPTION | 0);
17452 if (SWIG_arg_fail(1)) SWIG_fail;
17453 {
17454 PyThreadState* __tstate = wxPyBeginAllowThreads();
17455 result = (bool)(arg1)->AltDown();
17456
17457 wxPyEndAllowThreads(__tstate);
17458 if (PyErr_Occurred()) SWIG_fail;
17459 }
17460 {
17461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17462 }
17463 return resultobj;
17464 fail:
17465 return NULL;
17466 }
17467
17468
17469 static PyObject * GridSizeEvent_swigregister(PyObject *, PyObject *args) {
17470 PyObject *obj;
17471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17472 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizeEvent, obj);
17473 Py_INCREF(obj);
17474 return Py_BuildValue((char *)"");
17475 }
17476 static PyObject *_wrap_new_GridRangeSelectEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17477 PyObject *resultobj = NULL;
17478 int arg1 ;
17479 wxEventType arg2 ;
17480 wxGrid *arg3 = (wxGrid *) 0 ;
17481 wxGridCellCoords *arg4 = 0 ;
17482 wxGridCellCoords *arg5 = 0 ;
17483 bool arg6 = (bool) true ;
17484 bool arg7 = (bool) false ;
17485 bool arg8 = (bool) false ;
17486 bool arg9 = (bool) false ;
17487 bool arg10 = (bool) false ;
17488 wxGridRangeSelectEvent *result;
17489 wxGridCellCoords temp4 ;
17490 wxGridCellCoords temp5 ;
17491 PyObject * obj0 = 0 ;
17492 PyObject * obj1 = 0 ;
17493 PyObject * obj2 = 0 ;
17494 PyObject * obj3 = 0 ;
17495 PyObject * obj4 = 0 ;
17496 PyObject * obj5 = 0 ;
17497 PyObject * obj6 = 0 ;
17498 PyObject * obj7 = 0 ;
17499 PyObject * obj8 = 0 ;
17500 PyObject * obj9 = 0 ;
17501 char *kwnames[] = {
17502 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
17503 };
17504
17505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
17506 {
17507 arg1 = static_cast<int >(SWIG_As_int(obj0));
17508 if (SWIG_arg_fail(1)) SWIG_fail;
17509 }
17510 {
17511 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
17512 if (SWIG_arg_fail(2)) SWIG_fail;
17513 }
17514 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGrid, SWIG_POINTER_EXCEPTION | 0);
17515 if (SWIG_arg_fail(3)) SWIG_fail;
17516 {
17517 arg4 = &temp4;
17518 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
17519 }
17520 {
17521 arg5 = &temp5;
17522 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
17523 }
17524 if (obj5) {
17525 {
17526 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
17527 if (SWIG_arg_fail(6)) SWIG_fail;
17528 }
17529 }
17530 if (obj6) {
17531 {
17532 arg7 = static_cast<bool >(SWIG_As_bool(obj6));
17533 if (SWIG_arg_fail(7)) SWIG_fail;
17534 }
17535 }
17536 if (obj7) {
17537 {
17538 arg8 = static_cast<bool >(SWIG_As_bool(obj7));
17539 if (SWIG_arg_fail(8)) SWIG_fail;
17540 }
17541 }
17542 if (obj8) {
17543 {
17544 arg9 = static_cast<bool >(SWIG_As_bool(obj8));
17545 if (SWIG_arg_fail(9)) SWIG_fail;
17546 }
17547 }
17548 if (obj9) {
17549 {
17550 arg10 = static_cast<bool >(SWIG_As_bool(obj9));
17551 if (SWIG_arg_fail(10)) SWIG_fail;
17552 }
17553 }
17554 {
17555 PyThreadState* __tstate = wxPyBeginAllowThreads();
17556 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
17557
17558 wxPyEndAllowThreads(__tstate);
17559 if (PyErr_Occurred()) SWIG_fail;
17560 }
17561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridRangeSelectEvent, 1);
17562 return resultobj;
17563 fail:
17564 return NULL;
17565 }
17566
17567
17568 static PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17569 PyObject *resultobj = NULL;
17570 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17571 wxGridCellCoords result;
17572 PyObject * obj0 = 0 ;
17573 char *kwnames[] = {
17574 (char *) "self", NULL
17575 };
17576
17577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopLeftCoords",kwnames,&obj0)) goto fail;
17578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17579 if (SWIG_arg_fail(1)) SWIG_fail;
17580 {
17581 PyThreadState* __tstate = wxPyBeginAllowThreads();
17582 result = (arg1)->GetTopLeftCoords();
17583
17584 wxPyEndAllowThreads(__tstate);
17585 if (PyErr_Occurred()) SWIG_fail;
17586 }
17587 {
17588 wxGridCellCoords * resultptr;
17589 resultptr = new wxGridCellCoords(static_cast<wxGridCellCoords & >(result));
17590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17591 }
17592 return resultobj;
17593 fail:
17594 return NULL;
17595 }
17596
17597
17598 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *, PyObject *args, PyObject *kwargs) {
17599 PyObject *resultobj = NULL;
17600 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17601 wxGridCellCoords result;
17602 PyObject * obj0 = 0 ;
17603 char *kwnames[] = {
17604 (char *) "self", NULL
17605 };
17606
17607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRightCoords",kwnames,&obj0)) goto fail;
17608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17609 if (SWIG_arg_fail(1)) SWIG_fail;
17610 {
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 result = (arg1)->GetBottomRightCoords();
17613
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 {
17618 wxGridCellCoords * resultptr;
17619 resultptr = new wxGridCellCoords(static_cast<wxGridCellCoords & >(result));
17620 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGridCellCoords, 1);
17621 }
17622 return resultobj;
17623 fail:
17624 return NULL;
17625 }
17626
17627
17628 static PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *, PyObject *args, PyObject *kwargs) {
17629 PyObject *resultobj = NULL;
17630 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17631 int result;
17632 PyObject * obj0 = 0 ;
17633 char *kwnames[] = {
17634 (char *) "self", NULL
17635 };
17636
17637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetTopRow",kwnames,&obj0)) goto fail;
17638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17639 if (SWIG_arg_fail(1)) SWIG_fail;
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (int)(arg1)->GetTopRow();
17643
17644 wxPyEndAllowThreads(__tstate);
17645 if (PyErr_Occurred()) SWIG_fail;
17646 }
17647 {
17648 resultobj = SWIG_From_int(static_cast<int >(result));
17649 }
17650 return resultobj;
17651 fail:
17652 return NULL;
17653 }
17654
17655
17656 static PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *, PyObject *args, PyObject *kwargs) {
17657 PyObject *resultobj = NULL;
17658 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17659 int result;
17660 PyObject * obj0 = 0 ;
17661 char *kwnames[] = {
17662 (char *) "self", NULL
17663 };
17664
17665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetBottomRow",kwnames,&obj0)) goto fail;
17666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17667 if (SWIG_arg_fail(1)) SWIG_fail;
17668 {
17669 PyThreadState* __tstate = wxPyBeginAllowThreads();
17670 result = (int)(arg1)->GetBottomRow();
17671
17672 wxPyEndAllowThreads(__tstate);
17673 if (PyErr_Occurred()) SWIG_fail;
17674 }
17675 {
17676 resultobj = SWIG_From_int(static_cast<int >(result));
17677 }
17678 return resultobj;
17679 fail:
17680 return NULL;
17681 }
17682
17683
17684 static PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *, PyObject *args, PyObject *kwargs) {
17685 PyObject *resultobj = NULL;
17686 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17687 int result;
17688 PyObject * obj0 = 0 ;
17689 char *kwnames[] = {
17690 (char *) "self", NULL
17691 };
17692
17693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetLeftCol",kwnames,&obj0)) goto fail;
17694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17695 if (SWIG_arg_fail(1)) SWIG_fail;
17696 {
17697 PyThreadState* __tstate = wxPyBeginAllowThreads();
17698 result = (int)(arg1)->GetLeftCol();
17699
17700 wxPyEndAllowThreads(__tstate);
17701 if (PyErr_Occurred()) SWIG_fail;
17702 }
17703 {
17704 resultobj = SWIG_From_int(static_cast<int >(result));
17705 }
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 static PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *, PyObject *args, PyObject *kwargs) {
17713 PyObject *resultobj = NULL;
17714 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17715 int result;
17716 PyObject * obj0 = 0 ;
17717 char *kwnames[] = {
17718 (char *) "self", NULL
17719 };
17720
17721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_GetRightCol",kwnames,&obj0)) goto fail;
17722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17723 if (SWIG_arg_fail(1)) SWIG_fail;
17724 {
17725 PyThreadState* __tstate = wxPyBeginAllowThreads();
17726 result = (int)(arg1)->GetRightCol();
17727
17728 wxPyEndAllowThreads(__tstate);
17729 if (PyErr_Occurred()) SWIG_fail;
17730 }
17731 {
17732 resultobj = SWIG_From_int(static_cast<int >(result));
17733 }
17734 return resultobj;
17735 fail:
17736 return NULL;
17737 }
17738
17739
17740 static PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *, PyObject *args, PyObject *kwargs) {
17741 PyObject *resultobj = NULL;
17742 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17743 bool result;
17744 PyObject * obj0 = 0 ;
17745 char *kwnames[] = {
17746 (char *) "self", NULL
17747 };
17748
17749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_Selecting",kwnames,&obj0)) goto fail;
17750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17751 if (SWIG_arg_fail(1)) SWIG_fail;
17752 {
17753 PyThreadState* __tstate = wxPyBeginAllowThreads();
17754 result = (bool)(arg1)->Selecting();
17755
17756 wxPyEndAllowThreads(__tstate);
17757 if (PyErr_Occurred()) SWIG_fail;
17758 }
17759 {
17760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17761 }
17762 return resultobj;
17763 fail:
17764 return NULL;
17765 }
17766
17767
17768 static PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17769 PyObject *resultobj = NULL;
17770 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17771 bool result;
17772 PyObject * obj0 = 0 ;
17773 char *kwnames[] = {
17774 (char *) "self", NULL
17775 };
17776
17777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ControlDown",kwnames,&obj0)) goto fail;
17778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17779 if (SWIG_arg_fail(1)) SWIG_fail;
17780 {
17781 PyThreadState* __tstate = wxPyBeginAllowThreads();
17782 result = (bool)(arg1)->ControlDown();
17783
17784 wxPyEndAllowThreads(__tstate);
17785 if (PyErr_Occurred()) SWIG_fail;
17786 }
17787 {
17788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17789 }
17790 return resultobj;
17791 fail:
17792 return NULL;
17793 }
17794
17795
17796 static PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17797 PyObject *resultobj = NULL;
17798 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17799 bool result;
17800 PyObject * obj0 = 0 ;
17801 char *kwnames[] = {
17802 (char *) "self", NULL
17803 };
17804
17805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_MetaDown",kwnames,&obj0)) goto fail;
17806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17807 if (SWIG_arg_fail(1)) SWIG_fail;
17808 {
17809 PyThreadState* __tstate = wxPyBeginAllowThreads();
17810 result = (bool)(arg1)->MetaDown();
17811
17812 wxPyEndAllowThreads(__tstate);
17813 if (PyErr_Occurred()) SWIG_fail;
17814 }
17815 {
17816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17817 }
17818 return resultobj;
17819 fail:
17820 return NULL;
17821 }
17822
17823
17824 static PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17825 PyObject *resultobj = NULL;
17826 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17827 bool result;
17828 PyObject * obj0 = 0 ;
17829 char *kwnames[] = {
17830 (char *) "self", NULL
17831 };
17832
17833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_ShiftDown",kwnames,&obj0)) goto fail;
17834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17835 if (SWIG_arg_fail(1)) SWIG_fail;
17836 {
17837 PyThreadState* __tstate = wxPyBeginAllowThreads();
17838 result = (bool)(arg1)->ShiftDown();
17839
17840 wxPyEndAllowThreads(__tstate);
17841 if (PyErr_Occurred()) SWIG_fail;
17842 }
17843 {
17844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17845 }
17846 return resultobj;
17847 fail:
17848 return NULL;
17849 }
17850
17851
17852 static PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17853 PyObject *resultobj = NULL;
17854 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
17855 bool result;
17856 PyObject * obj0 = 0 ;
17857 char *kwnames[] = {
17858 (char *) "self", NULL
17859 };
17860
17861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridRangeSelectEvent_AltDown",kwnames,&obj0)) goto fail;
17862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_EXCEPTION | 0);
17863 if (SWIG_arg_fail(1)) SWIG_fail;
17864 {
17865 PyThreadState* __tstate = wxPyBeginAllowThreads();
17866 result = (bool)(arg1)->AltDown();
17867
17868 wxPyEndAllowThreads(__tstate);
17869 if (PyErr_Occurred()) SWIG_fail;
17870 }
17871 {
17872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17873 }
17874 return resultobj;
17875 fail:
17876 return NULL;
17877 }
17878
17879
17880 static PyObject * GridRangeSelectEvent_swigregister(PyObject *, PyObject *args) {
17881 PyObject *obj;
17882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17883 SWIG_TypeClientData(SWIGTYPE_p_wxGridRangeSelectEvent, obj);
17884 Py_INCREF(obj);
17885 return Py_BuildValue((char *)"");
17886 }
17887 static PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17888 PyObject *resultobj = NULL;
17889 int arg1 ;
17890 wxEventType arg2 ;
17891 wxObject *arg3 = (wxObject *) 0 ;
17892 int arg4 ;
17893 int arg5 ;
17894 wxControl *arg6 = (wxControl *) 0 ;
17895 wxGridEditorCreatedEvent *result;
17896 PyObject * obj0 = 0 ;
17897 PyObject * obj1 = 0 ;
17898 PyObject * obj2 = 0 ;
17899 PyObject * obj3 = 0 ;
17900 PyObject * obj4 = 0 ;
17901 PyObject * obj5 = 0 ;
17902 char *kwnames[] = {
17903 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
17904 };
17905
17906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
17907 {
17908 arg1 = static_cast<int >(SWIG_As_int(obj0));
17909 if (SWIG_arg_fail(1)) SWIG_fail;
17910 }
17911 {
17912 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
17913 if (SWIG_arg_fail(2)) SWIG_fail;
17914 }
17915 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
17916 if (SWIG_arg_fail(3)) SWIG_fail;
17917 {
17918 arg4 = static_cast<int >(SWIG_As_int(obj3));
17919 if (SWIG_arg_fail(4)) SWIG_fail;
17920 }
17921 {
17922 arg5 = static_cast<int >(SWIG_As_int(obj4));
17923 if (SWIG_arg_fail(5)) SWIG_fail;
17924 }
17925 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
17926 if (SWIG_arg_fail(6)) SWIG_fail;
17927 {
17928 PyThreadState* __tstate = wxPyBeginAllowThreads();
17929 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
17930
17931 wxPyEndAllowThreads(__tstate);
17932 if (PyErr_Occurred()) SWIG_fail;
17933 }
17934 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridEditorCreatedEvent, 1);
17935 return resultobj;
17936 fail:
17937 return NULL;
17938 }
17939
17940
17941 static PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
17942 PyObject *resultobj = NULL;
17943 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17944 int result;
17945 PyObject * obj0 = 0 ;
17946 char *kwnames[] = {
17947 (char *) "self", NULL
17948 };
17949
17950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetRow",kwnames,&obj0)) goto fail;
17951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17952 if (SWIG_arg_fail(1)) SWIG_fail;
17953 {
17954 PyThreadState* __tstate = wxPyBeginAllowThreads();
17955 result = (int)(arg1)->GetRow();
17956
17957 wxPyEndAllowThreads(__tstate);
17958 if (PyErr_Occurred()) SWIG_fail;
17959 }
17960 {
17961 resultobj = SWIG_From_int(static_cast<int >(result));
17962 }
17963 return resultobj;
17964 fail:
17965 return NULL;
17966 }
17967
17968
17969 static PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
17970 PyObject *resultobj = NULL;
17971 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
17972 int result;
17973 PyObject * obj0 = 0 ;
17974 char *kwnames[] = {
17975 (char *) "self", NULL
17976 };
17977
17978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetCol",kwnames,&obj0)) goto fail;
17979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
17980 if (SWIG_arg_fail(1)) SWIG_fail;
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 result = (int)(arg1)->GetCol();
17984
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 {
17989 resultobj = SWIG_From_int(static_cast<int >(result));
17990 }
17991 return resultobj;
17992 fail:
17993 return NULL;
17994 }
17995
17996
17997 static PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *, PyObject *args, PyObject *kwargs) {
17998 PyObject *resultobj = NULL;
17999 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
18000 wxControl *result;
18001 PyObject * obj0 = 0 ;
18002 char *kwnames[] = {
18003 (char *) "self", NULL
18004 };
18005
18006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridEditorCreatedEvent_GetControl",kwnames,&obj0)) goto fail;
18007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
18008 if (SWIG_arg_fail(1)) SWIG_fail;
18009 {
18010 PyThreadState* __tstate = wxPyBeginAllowThreads();
18011 result = (wxControl *)(arg1)->GetControl();
18012
18013 wxPyEndAllowThreads(__tstate);
18014 if (PyErr_Occurred()) SWIG_fail;
18015 }
18016 {
18017 resultobj = wxPyMake_wxObject(result, 0);
18018 }
18019 return resultobj;
18020 fail:
18021 return NULL;
18022 }
18023
18024
18025 static PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
18026 PyObject *resultobj = NULL;
18027 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
18028 int arg2 ;
18029 PyObject * obj0 = 0 ;
18030 PyObject * obj1 = 0 ;
18031 char *kwnames[] = {
18032 (char *) "self",(char *) "row", NULL
18033 };
18034
18035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) goto fail;
18036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
18037 if (SWIG_arg_fail(1)) SWIG_fail;
18038 {
18039 arg2 = static_cast<int >(SWIG_As_int(obj1));
18040 if (SWIG_arg_fail(2)) SWIG_fail;
18041 }
18042 {
18043 PyThreadState* __tstate = wxPyBeginAllowThreads();
18044 (arg1)->SetRow(arg2);
18045
18046 wxPyEndAllowThreads(__tstate);
18047 if (PyErr_Occurred()) SWIG_fail;
18048 }
18049 Py_INCREF(Py_None); resultobj = Py_None;
18050 return resultobj;
18051 fail:
18052 return NULL;
18053 }
18054
18055
18056 static PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
18057 PyObject *resultobj = NULL;
18058 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
18059 int arg2 ;
18060 PyObject * obj0 = 0 ;
18061 PyObject * obj1 = 0 ;
18062 char *kwnames[] = {
18063 (char *) "self",(char *) "col", NULL
18064 };
18065
18066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) goto fail;
18067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
18068 if (SWIG_arg_fail(1)) SWIG_fail;
18069 {
18070 arg2 = static_cast<int >(SWIG_As_int(obj1));
18071 if (SWIG_arg_fail(2)) SWIG_fail;
18072 }
18073 {
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 (arg1)->SetCol(arg2);
18076
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 Py_INCREF(Py_None); resultobj = Py_None;
18081 return resultobj;
18082 fail:
18083 return NULL;
18084 }
18085
18086
18087 static PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *, PyObject *args, PyObject *kwargs) {
18088 PyObject *resultobj = NULL;
18089 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
18090 wxControl *arg2 = (wxControl *) 0 ;
18091 PyObject * obj0 = 0 ;
18092 PyObject * obj1 = 0 ;
18093 char *kwnames[] = {
18094 (char *) "self",(char *) "ctrl", NULL
18095 };
18096
18097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) goto fail;
18098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_EXCEPTION | 0);
18099 if (SWIG_arg_fail(1)) SWIG_fail;
18100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
18101 if (SWIG_arg_fail(2)) SWIG_fail;
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 (arg1)->SetControl(arg2);
18105
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 Py_INCREF(Py_None); resultobj = Py_None;
18110 return resultobj;
18111 fail:
18112 return NULL;
18113 }
18114
18115
18116 static PyObject * GridEditorCreatedEvent_swigregister(PyObject *, PyObject *args) {
18117 PyObject *obj;
18118 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18119 SWIG_TypeClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, obj);
18120 Py_INCREF(obj);
18121 return Py_BuildValue((char *)"");
18122 }
18123 static PyMethodDef SwigMethods[] = {
18124 { (char *)"GridCellRenderer__setOORInfo", (PyCFunction) _wrap_GridCellRenderer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18125 { (char *)"GridCellRenderer_SetParameters", (PyCFunction) _wrap_GridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
18126 { (char *)"GridCellRenderer_IncRef", (PyCFunction) _wrap_GridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
18127 { (char *)"GridCellRenderer_DecRef", (PyCFunction) _wrap_GridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
18128 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
18129 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
18130 { (char *)"GridCellRenderer_Clone", (PyCFunction) _wrap_GridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
18131 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
18132 { (char *)"new_PyGridCellRenderer", (PyCFunction) _wrap_new_PyGridCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18133 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18134 { (char *)"PyGridCellRenderer_base_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_base_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
18135 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
18136 { (char *)"new_GridCellStringRenderer", (PyCFunction) _wrap_new_GridCellStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18137 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
18138 { (char *)"new_GridCellNumberRenderer", (PyCFunction) _wrap_new_GridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18139 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
18140 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18141 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18142 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18143 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_GetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
18144 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
18145 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
18146 { (char *)"new_GridCellBoolRenderer", (PyCFunction) _wrap_new_GridCellBoolRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18147 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
18148 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18149 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
18150 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18151 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
18152 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_GridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18153 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
18154 { (char *)"GridCellEditor__setOORInfo", (PyCFunction) _wrap_GridCellEditor__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18155 { (char *)"GridCellEditor_IsCreated", (PyCFunction) _wrap_GridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS, NULL},
18156 { (char *)"GridCellEditor_GetControl", (PyCFunction) _wrap_GridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18157 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18158 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction) _wrap_GridCellEditor_GetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18159 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18160 { (char *)"GridCellEditor_SetParameters", (PyCFunction) _wrap_GridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
18161 { (char *)"GridCellEditor_IncRef", (PyCFunction) _wrap_GridCellEditor_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
18162 { (char *)"GridCellEditor_DecRef", (PyCFunction) _wrap_GridCellEditor_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
18163 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
18164 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
18165 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
18166 { (char *)"GridCellEditor_Reset", (PyCFunction) _wrap_GridCellEditor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
18167 { (char *)"GridCellEditor_Clone", (PyCFunction) _wrap_GridCellEditor_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
18168 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18169 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
18170 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18171 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
18172 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
18173 { (char *)"GridCellEditor_StartingClick", (PyCFunction) _wrap_GridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
18174 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
18175 { (char *)"GridCellEditor_Destroy", (PyCFunction) _wrap_GridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
18176 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
18177 { (char *)"new_PyGridCellEditor", (PyCFunction) _wrap_new_PyGridCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18178 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18179 { (char *)"PyGridCellEditor_base_SetSize", (PyCFunction) _wrap_PyGridCellEditor_base_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18180 { (char *)"PyGridCellEditor_base_Show", (PyCFunction) _wrap_PyGridCellEditor_base_Show, METH_VARARGS | METH_KEYWORDS, NULL},
18181 { (char *)"PyGridCellEditor_base_PaintBackground", (PyCFunction) _wrap_PyGridCellEditor_base_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18182 { (char *)"PyGridCellEditor_base_IsAcceptedKey", (PyCFunction) _wrap_PyGridCellEditor_base_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
18183 { (char *)"PyGridCellEditor_base_StartingKey", (PyCFunction) _wrap_PyGridCellEditor_base_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
18184 { (char *)"PyGridCellEditor_base_StartingClick", (PyCFunction) _wrap_PyGridCellEditor_base_StartingClick, METH_VARARGS | METH_KEYWORDS, NULL},
18185 { (char *)"PyGridCellEditor_base_HandleReturn", (PyCFunction) _wrap_PyGridCellEditor_base_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
18186 { (char *)"PyGridCellEditor_base_Destroy", (PyCFunction) _wrap_PyGridCellEditor_base_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
18187 { (char *)"PyGridCellEditor_base_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_base_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
18188 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
18189 { (char *)"new_GridCellTextEditor", (PyCFunction) _wrap_new_GridCellTextEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18190 { (char *)"GridCellTextEditor_GetValue", (PyCFunction) _wrap_GridCellTextEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18191 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
18192 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18193 { (char *)"GridCellNumberEditor_GetValue", (PyCFunction) _wrap_GridCellNumberEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18194 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
18195 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18196 { (char *)"GridCellFloatEditor_GetValue", (PyCFunction) _wrap_GridCellFloatEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18197 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
18198 { (char *)"new_GridCellBoolEditor", (PyCFunction) _wrap_new_GridCellBoolEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18199 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction) _wrap_GridCellBoolEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18200 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
18201 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18202 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction) _wrap_GridCellChoiceEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18203 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
18204 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18205 { (char *)"GridCellEnumEditor_GetValue", (PyCFunction) _wrap_GridCellEnumEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18206 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
18207 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_GridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18208 { (char *)"GridCellAutoWrapStringEditor_GetValue", (PyCFunction) _wrap_GridCellAutoWrapStringEditor_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18209 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
18210 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18211 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18212 { (char *)"GridCellAttr_Clone", (PyCFunction) _wrap_GridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
18213 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
18214 { (char *)"GridCellAttr_IncRef", (PyCFunction) _wrap_GridCellAttr_IncRef, METH_VARARGS | METH_KEYWORDS, NULL},
18215 { (char *)"GridCellAttr_DecRef", (PyCFunction) _wrap_GridCellAttr_DecRef, METH_VARARGS | METH_KEYWORDS, NULL},
18216 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18217 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18218 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18219 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18220 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18221 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18222 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18223 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18224 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18225 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18226 { (char *)"GridCellAttr_HasTextColour", (PyCFunction) _wrap_GridCellAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18227 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction) _wrap_GridCellAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18228 { (char *)"GridCellAttr_HasFont", (PyCFunction) _wrap_GridCellAttr_HasFont, METH_VARARGS | METH_KEYWORDS, NULL},
18229 { (char *)"GridCellAttr_HasAlignment", (PyCFunction) _wrap_GridCellAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18230 { (char *)"GridCellAttr_HasRenderer", (PyCFunction) _wrap_GridCellAttr_HasRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18231 { (char *)"GridCellAttr_HasEditor", (PyCFunction) _wrap_GridCellAttr_HasEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18232 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction) _wrap_GridCellAttr_HasReadWriteMode, METH_VARARGS | METH_KEYWORDS, NULL},
18233 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction) _wrap_GridCellAttr_HasOverflowMode, METH_VARARGS | METH_KEYWORDS, NULL},
18234 { (char *)"GridCellAttr_GetTextColour", (PyCFunction) _wrap_GridCellAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18235 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18236 { (char *)"GridCellAttr_GetFont", (PyCFunction) _wrap_GridCellAttr_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
18237 { (char *)"GridCellAttr_GetAlignment", (PyCFunction) _wrap_GridCellAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18238 { (char *)"GridCellAttr_GetSize", (PyCFunction) _wrap_GridCellAttr_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
18239 { (char *)"GridCellAttr_GetOverflow", (PyCFunction) _wrap_GridCellAttr_GetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18240 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18241 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18242 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction) _wrap_GridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18243 { (char *)"GridCellAttr_GetKind", (PyCFunction) _wrap_GridCellAttr_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
18244 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18245 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
18246 { (char *)"new_GridCellAttrProvider", (PyCFunction) _wrap_new_GridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18247 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18248 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18249 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18250 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18251 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18252 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
18253 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
18254 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18255 { (char *)"new_PyGridCellAttrProvider", (PyCFunction) _wrap_new_PyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18256 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18257 { (char *)"PyGridCellAttrProvider_base_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18258 { (char *)"PyGridCellAttrProvider_base_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18259 { (char *)"PyGridCellAttrProvider_base_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18260 { (char *)"PyGridCellAttrProvider_base_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_base_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18261 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
18262 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18263 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18264 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction) _wrap_GridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
18265 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
18266 { (char *)"GridTableBase_GetView", (PyCFunction) _wrap_GridTableBase_GetView, METH_VARARGS | METH_KEYWORDS, NULL},
18267 { (char *)"GridTableBase_GetNumberRows", (PyCFunction) _wrap_GridTableBase_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18268 { (char *)"GridTableBase_GetNumberCols", (PyCFunction) _wrap_GridTableBase_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18269 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
18270 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18271 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
18272 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18273 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18274 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18275 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18276 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18277 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18278 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
18279 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
18280 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
18281 { (char *)"GridTableBase_Clear", (PyCFunction) _wrap_GridTableBase_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18282 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18283 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18284 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18285 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18286 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18287 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18288 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18289 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18290 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18291 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18292 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction) _wrap_GridTableBase_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18293 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18294 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18295 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18296 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18297 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
18298 { (char *)"new_PyGridTableBase", (PyCFunction) _wrap_new_PyGridTableBase, METH_VARARGS | METH_KEYWORDS, NULL},
18299 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
18300 { (char *)"PyGridTableBase_Destroy", (PyCFunction) _wrap_PyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
18301 { (char *)"PyGridTableBase_base_GetTypeName", (PyCFunction) _wrap_PyGridTableBase_base_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
18302 { (char *)"PyGridTableBase_base_CanGetValueAs", (PyCFunction) _wrap_PyGridTableBase_base_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18303 { (char *)"PyGridTableBase_base_CanSetValueAs", (PyCFunction) _wrap_PyGridTableBase_base_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
18304 { (char *)"PyGridTableBase_base_Clear", (PyCFunction) _wrap_PyGridTableBase_base_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
18305 { (char *)"PyGridTableBase_base_InsertRows", (PyCFunction) _wrap_PyGridTableBase_base_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18306 { (char *)"PyGridTableBase_base_AppendRows", (PyCFunction) _wrap_PyGridTableBase_base_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18307 { (char *)"PyGridTableBase_base_DeleteRows", (PyCFunction) _wrap_PyGridTableBase_base_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18308 { (char *)"PyGridTableBase_base_InsertCols", (PyCFunction) _wrap_PyGridTableBase_base_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18309 { (char *)"PyGridTableBase_base_AppendCols", (PyCFunction) _wrap_PyGridTableBase_base_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18310 { (char *)"PyGridTableBase_base_DeleteCols", (PyCFunction) _wrap_PyGridTableBase_base_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18311 { (char *)"PyGridTableBase_base_GetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18312 { (char *)"PyGridTableBase_base_GetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18313 { (char *)"PyGridTableBase_base_SetRowLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18314 { (char *)"PyGridTableBase_base_SetColLabelValue", (PyCFunction) _wrap_PyGridTableBase_base_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18315 { (char *)"PyGridTableBase_base_CanHaveAttributes", (PyCFunction) _wrap_PyGridTableBase_base_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18316 { (char *)"PyGridTableBase_base_GetAttr", (PyCFunction) _wrap_PyGridTableBase_base_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18317 { (char *)"PyGridTableBase_base_SetAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18318 { (char *)"PyGridTableBase_base_SetRowAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18319 { (char *)"PyGridTableBase_base_SetColAttr", (PyCFunction) _wrap_PyGridTableBase_base_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18320 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
18321 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
18322 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
18323 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18324 { (char *)"delete_GridTableMessage", (PyCFunction) _wrap_delete_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18325 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18326 { (char *)"GridTableMessage_GetTableObject", (PyCFunction) _wrap_GridTableMessage_GetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
18327 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
18328 { (char *)"GridTableMessage_GetId", (PyCFunction) _wrap_GridTableMessage_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
18329 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18330 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction) _wrap_GridTableMessage_GetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
18331 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18332 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction) _wrap_GridTableMessage_GetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
18333 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
18334 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18335 { (char *)"delete_GridCellCoords", (PyCFunction) _wrap_delete_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18336 { (char *)"GridCellCoords_GetRow", (PyCFunction) _wrap_GridCellCoords_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18337 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18338 { (char *)"GridCellCoords_GetCol", (PyCFunction) _wrap_GridCellCoords_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18339 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18340 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
18341 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
18342 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
18343 { (char *)"GridCellCoords_Get", (PyCFunction) _wrap_GridCellCoords_Get, METH_VARARGS | METH_KEYWORDS, NULL},
18344 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
18345 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
18346 { (char *)"new_PreGrid", (PyCFunction) _wrap_new_PreGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18347 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
18348 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18349 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18350 { (char *)"Grid_GetSelectionMode", (PyCFunction) _wrap_Grid_GetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
18351 { (char *)"Grid_GetNumberRows", (PyCFunction) _wrap_Grid_GetNumberRows, METH_VARARGS | METH_KEYWORDS, NULL},
18352 { (char *)"Grid_GetNumberCols", (PyCFunction) _wrap_Grid_GetNumberCols, METH_VARARGS | METH_KEYWORDS, NULL},
18353 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
18354 { (char *)"Grid_GetTable", (PyCFunction) _wrap_Grid_GetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18355 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
18356 { (char *)"Grid_ClearGrid", (PyCFunction) _wrap_Grid_ClearGrid, METH_VARARGS | METH_KEYWORDS, NULL},
18357 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
18358 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
18359 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
18360 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
18361 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
18362 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
18363 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
18364 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
18365 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
18366 { (char *)"Grid_BeginBatch", (PyCFunction) _wrap_Grid_BeginBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18367 { (char *)"Grid_EndBatch", (PyCFunction) _wrap_Grid_EndBatch, METH_VARARGS | METH_KEYWORDS, NULL},
18368 { (char *)"Grid_GetBatchCount", (PyCFunction) _wrap_Grid_GetBatchCount, METH_VARARGS | METH_KEYWORDS, NULL},
18369 { (char *)"Grid_ForceRefresh", (PyCFunction) _wrap_Grid_ForceRefresh, METH_VARARGS | METH_KEYWORDS, NULL},
18370 { (char *)"Grid_IsEditable", (PyCFunction) _wrap_Grid_IsEditable, METH_VARARGS | METH_KEYWORDS, NULL},
18371 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
18372 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18373 { (char *)"Grid_DisableCellEditControl", (PyCFunction) _wrap_Grid_DisableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18374 { (char *)"Grid_CanEnableCellControl", (PyCFunction) _wrap_Grid_CanEnableCellControl, METH_VARARGS | METH_KEYWORDS, NULL},
18375 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction) _wrap_Grid_IsCellEditControlEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18376 { (char *)"Grid_IsCellEditControlShown", (PyCFunction) _wrap_Grid_IsCellEditControlShown, METH_VARARGS | METH_KEYWORDS, NULL},
18377 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction) _wrap_Grid_IsCurrentCellReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18378 { (char *)"Grid_ShowCellEditControl", (PyCFunction) _wrap_Grid_ShowCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18379 { (char *)"Grid_HideCellEditControl", (PyCFunction) _wrap_Grid_HideCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
18380 { (char *)"Grid_SaveEditControlValue", (PyCFunction) _wrap_Grid_SaveEditControlValue, METH_VARARGS | METH_KEYWORDS, NULL},
18381 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
18382 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
18383 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
18384 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
18385 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
18386 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
18387 { (char *)"Grid_GetGridCursorRow", (PyCFunction) _wrap_Grid_GetGridCursorRow, METH_VARARGS | METH_KEYWORDS, NULL},
18388 { (char *)"Grid_GetGridCursorCol", (PyCFunction) _wrap_Grid_GetGridCursorCol, METH_VARARGS | METH_KEYWORDS, NULL},
18389 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18390 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
18391 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
18392 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
18393 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
18394 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18395 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
18396 { (char *)"Grid_MovePageDown", (PyCFunction) _wrap_Grid_MovePageDown, METH_VARARGS | METH_KEYWORDS, NULL},
18397 { (char *)"Grid_MovePageUp", (PyCFunction) _wrap_Grid_MovePageUp, METH_VARARGS | METH_KEYWORDS, NULL},
18398 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18399 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18400 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18401 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18402 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction) _wrap_Grid_GetDefaultRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18403 { (char *)"Grid_GetRowLabelSize", (PyCFunction) _wrap_Grid_GetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18404 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction) _wrap_Grid_GetDefaultColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18405 { (char *)"Grid_GetColLabelSize", (PyCFunction) _wrap_Grid_GetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18406 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction) _wrap_Grid_GetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18407 { (char *)"Grid_GetLabelTextColour", (PyCFunction) _wrap_Grid_GetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18408 { (char *)"Grid_GetLabelFont", (PyCFunction) _wrap_Grid_GetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18409 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction) _wrap_Grid_GetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18410 { (char *)"Grid_GetColLabelAlignment", (PyCFunction) _wrap_Grid_GetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18411 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction) _wrap_Grid_GetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18412 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18413 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18414 { (char *)"Grid_GetGridLineColour", (PyCFunction) _wrap_Grid_GetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18415 { (char *)"Grid_GetCellHighlightColour", (PyCFunction) _wrap_Grid_GetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18416 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18417 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_GetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18418 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18419 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18420 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18421 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18422 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
18423 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18424 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18425 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
18426 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18427 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
18428 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
18429 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
18430 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18431 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18432 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18433 { (char *)"Grid_DisableDragRowSize", (PyCFunction) _wrap_Grid_DisableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18434 { (char *)"Grid_CanDragRowSize", (PyCFunction) _wrap_Grid_CanDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18435 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18436 { (char *)"Grid_DisableDragColSize", (PyCFunction) _wrap_Grid_DisableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18437 { (char *)"Grid_CanDragColSize", (PyCFunction) _wrap_Grid_CanDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18438 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18439 { (char *)"Grid_DisableDragGridSize", (PyCFunction) _wrap_Grid_DisableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18440 { (char *)"Grid_CanDragGridSize", (PyCFunction) _wrap_Grid_CanDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
18441 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18442 { (char *)"Grid_DisableDragCell", (PyCFunction) _wrap_Grid_DisableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18443 { (char *)"Grid_CanDragCell", (PyCFunction) _wrap_Grid_CanDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
18444 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18445 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18446 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18447 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
18448 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
18449 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
18450 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
18451 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
18452 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
18453 { (char *)"Grid_GridLinesEnabled", (PyCFunction) _wrap_Grid_GridLinesEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
18454 { (char *)"Grid_GetDefaultRowSize", (PyCFunction) _wrap_Grid_GetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18455 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18456 { (char *)"Grid_GetDefaultColSize", (PyCFunction) _wrap_Grid_GetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18457 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18458 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_GetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18459 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18460 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction) _wrap_Grid_GetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18461 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18462 { (char *)"Grid_GetDefaultCellFont", (PyCFunction) _wrap_Grid_GetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18463 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18464 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction) _wrap_Grid_GetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18465 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18466 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction) _wrap_Grid_GetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18467 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18468 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18469 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18470 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
18471 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18472 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
18473 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
18474 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
18475 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
18476 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
18477 { (char *)"Grid_AutoSize", (PyCFunction) _wrap_Grid_AutoSize, METH_VARARGS | METH_KEYWORDS, NULL},
18478 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18479 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
18480 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18481 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18482 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18483 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18484 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_GetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
18485 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_GetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
18486 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18487 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
18488 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18489 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
18490 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18491 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
18492 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18493 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
18494 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18495 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
18496 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
18497 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18498 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18499 { (char *)"Grid_GetDefaultRenderer", (PyCFunction) _wrap_Grid_GetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18500 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
18501 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18502 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18503 { (char *)"Grid_GetDefaultEditor", (PyCFunction) _wrap_Grid_GetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18504 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
18505 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18506 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
18507 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18508 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
18509 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18510 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18511 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
18512 { (char *)"Grid_SelectAll", (PyCFunction) _wrap_Grid_SelectAll, METH_VARARGS | METH_KEYWORDS, NULL},
18513 { (char *)"Grid_IsSelection", (PyCFunction) _wrap_Grid_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18514 { (char *)"Grid_ClearSelection", (PyCFunction) _wrap_Grid_ClearSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18515 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
18516 { (char *)"Grid_GetSelectedCells", (PyCFunction) _wrap_Grid_GetSelectedCells, METH_VARARGS | METH_KEYWORDS, NULL},
18517 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction) _wrap_Grid_GetSelectionBlockTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
18518 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction) _wrap_Grid_GetSelectionBlockBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
18519 { (char *)"Grid_GetSelectedRows", (PyCFunction) _wrap_Grid_GetSelectedRows, METH_VARARGS | METH_KEYWORDS, NULL},
18520 { (char *)"Grid_GetSelectedCols", (PyCFunction) _wrap_Grid_GetSelectedCols, METH_VARARGS | METH_KEYWORDS, NULL},
18521 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
18522 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
18523 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
18524 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
18525 { (char *)"Grid_GetSelectionBackground", (PyCFunction) _wrap_Grid_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18526 { (char *)"Grid_GetSelectionForeground", (PyCFunction) _wrap_Grid_GetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18527 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
18528 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
18529 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
18530 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18531 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
18532 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
18533 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
18534 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
18535 { (char *)"Grid_GetGridWindow", (PyCFunction) _wrap_Grid_GetGridWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18536 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction) _wrap_Grid_GetGridRowLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18537 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction) _wrap_Grid_GetGridColLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18538 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction) _wrap_Grid_GetGridCornerLabelWindow, METH_VARARGS | METH_KEYWORDS, NULL},
18539 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18540 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18541 { (char *)"Grid_GetScrollLineX", (PyCFunction) _wrap_Grid_GetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
18542 { (char *)"Grid_GetScrollLineY", (PyCFunction) _wrap_Grid_GetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
18543 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
18544 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
18545 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
18546 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
18547 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18548 { (char *)"GridEvent_GetRow", (PyCFunction) _wrap_GridEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18549 { (char *)"GridEvent_GetCol", (PyCFunction) _wrap_GridEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18550 { (char *)"GridEvent_GetPosition", (PyCFunction) _wrap_GridEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18551 { (char *)"GridEvent_Selecting", (PyCFunction) _wrap_GridEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18552 { (char *)"GridEvent_ControlDown", (PyCFunction) _wrap_GridEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18553 { (char *)"GridEvent_MetaDown", (PyCFunction) _wrap_GridEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18554 { (char *)"GridEvent_ShiftDown", (PyCFunction) _wrap_GridEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18555 { (char *)"GridEvent_AltDown", (PyCFunction) _wrap_GridEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18556 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
18557 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18558 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction) _wrap_GridSizeEvent_GetRowOrCol, METH_VARARGS | METH_KEYWORDS, NULL},
18559 { (char *)"GridSizeEvent_GetPosition", (PyCFunction) _wrap_GridSizeEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
18560 { (char *)"GridSizeEvent_ControlDown", (PyCFunction) _wrap_GridSizeEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18561 { (char *)"GridSizeEvent_MetaDown", (PyCFunction) _wrap_GridSizeEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18562 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction) _wrap_GridSizeEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18563 { (char *)"GridSizeEvent_AltDown", (PyCFunction) _wrap_GridSizeEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18564 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
18565 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18566 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18567 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_VARARGS | METH_KEYWORDS, NULL},
18568 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetTopRow, METH_VARARGS | METH_KEYWORDS, NULL},
18569 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction) _wrap_GridRangeSelectEvent_GetBottomRow, METH_VARARGS | METH_KEYWORDS, NULL},
18570 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetLeftCol, METH_VARARGS | METH_KEYWORDS, NULL},
18571 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction) _wrap_GridRangeSelectEvent_GetRightCol, METH_VARARGS | METH_KEYWORDS, NULL},
18572 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction) _wrap_GridRangeSelectEvent_Selecting, METH_VARARGS | METH_KEYWORDS, NULL},
18573 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction) _wrap_GridRangeSelectEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
18574 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction) _wrap_GridRangeSelectEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
18575 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction) _wrap_GridRangeSelectEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
18576 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction) _wrap_GridRangeSelectEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
18577 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
18578 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
18579 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18580 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18581 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_GetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18582 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
18583 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
18584 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
18585 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
18586 { NULL, NULL, 0, NULL }
18587 };
18588
18589
18590 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
18591
18592 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
18593 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
18594 }
18595 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
18596 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
18597 }
18598 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
18599 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18600 }
18601 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
18602 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18603 }
18604 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
18605 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
18606 }
18607 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
18608 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18609 }
18610 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
18611 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18612 }
18613 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
18614 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18615 }
18616 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
18617 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
18618 }
18619 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
18620 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
18621 }
18622 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
18623 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
18624 }
18625 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
18626 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
18627 }
18628 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
18629 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
18630 }
18631 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
18632 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
18633 }
18634 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
18635 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
18636 }
18637 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
18638 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18639 }
18640 static void *_p_wxGridTo_p_wxPanel(void *x) {
18641 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
18642 }
18643 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
18644 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18645 }
18646 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
18647 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18648 }
18649 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
18650 return (void *)((wxPanel *) ((wxPyPanel *) x));
18651 }
18652 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
18653 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
18654 }
18655 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
18656 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
18657 }
18658 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
18659 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18660 }
18661 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
18662 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
18663 }
18664 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
18665 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18666 }
18667 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
18668 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
18669 }
18670 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
18671 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
18672 }
18673 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
18674 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18675 }
18676 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
18677 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
18678 }
18679 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
18680 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
18681 }
18682 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
18683 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
18684 }
18685 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
18686 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
18687 }
18688 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
18689 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
18690 }
18691 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
18692 return (void *)((wxWindow *) ((wxMenuBar *) x));
18693 }
18694 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
18695 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
18696 }
18697 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
18698 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
18699 }
18700 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
18701 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
18702 }
18703 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
18704 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
18705 }
18706 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
18707 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
18708 }
18709 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
18710 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
18711 }
18712 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
18713 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
18714 }
18715 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
18716 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
18717 }
18718 static void *_p_wxPanelTo_p_wxWindow(void *x) {
18719 return (void *)((wxWindow *) ((wxPanel *) x));
18720 }
18721 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
18722 return (void *)((wxWindow *) ((wxStatusBar *) x));
18723 }
18724 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
18725 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
18726 }
18727 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
18728 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
18729 }
18730 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
18731 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
18732 }
18733 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
18734 return (void *)((wxWindow *) ((wxPopupWindow *) x));
18735 }
18736 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
18737 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
18738 }
18739 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
18740 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
18741 }
18742 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
18743 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
18744 }
18745 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
18746 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
18747 }
18748 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
18749 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
18750 }
18751 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
18752 return (void *)((wxWindow *) ((wxSashWindow *) x));
18753 }
18754 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
18755 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
18756 }
18757 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
18758 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
18759 }
18760 static void *_p_wxControlTo_p_wxWindow(void *x) {
18761 return (void *)((wxWindow *) ((wxControl *) x));
18762 }
18763 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
18764 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18765 }
18766 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
18767 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18768 }
18769 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
18770 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
18771 }
18772 static void *_p_wxGridTo_p_wxWindow(void *x) {
18773 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
18774 }
18775 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
18776 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
18777 }
18778 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
18779 return (void *)((wxWindow *) ((wxPyWindow *) x));
18780 }
18781 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
18782 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
18783 }
18784 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
18785 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
18786 }
18787 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
18788 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
18789 }
18790 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
18791 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
18792 }
18793 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
18794 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
18795 }
18796 static void *_p_wxFrameTo_p_wxWindow(void *x) {
18797 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
18798 }
18799 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
18800 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
18801 }
18802 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
18803 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
18804 }
18805 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
18806 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
18807 }
18808 static void *_p_wxDialogTo_p_wxWindow(void *x) {
18809 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
18810 }
18811 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
18812 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
18813 }
18814 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
18815 return (void *)((wxControl *) ((wxControlWithItems *) x));
18816 }
18817 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
18818 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
18819 }
18820 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
18821 return (void *)((wxEvent *) ((wxMenuEvent *) x));
18822 }
18823 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
18824 return (void *)((wxEvent *) ((wxCloseEvent *) x));
18825 }
18826 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
18827 return (void *)((wxEvent *) ((wxMouseEvent *) x));
18828 }
18829 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
18830 return (void *)((wxEvent *) ((wxEraseEvent *) x));
18831 }
18832 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
18833 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
18834 }
18835 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
18836 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
18837 }
18838 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
18839 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
18840 }
18841 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
18842 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
18843 }
18844 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
18845 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
18846 }
18847 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
18848 return (void *)((wxEvent *) ((wxPyEvent *) x));
18849 }
18850 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
18851 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
18852 }
18853 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
18854 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
18855 }
18856 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
18857 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
18858 }
18859 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
18860 return (void *)((wxEvent *) ((wxIdleEvent *) x));
18861 }
18862 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
18863 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
18864 }
18865 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
18866 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
18867 }
18868 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
18869 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
18870 }
18871 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
18872 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
18873 }
18874 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
18875 return (void *)((wxEvent *) ((wxActivateEvent *) x));
18876 }
18877 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
18878 return (void *)((wxEvent *) ((wxSizeEvent *) x));
18879 }
18880 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
18881 return (void *)((wxEvent *) ((wxMoveEvent *) x));
18882 }
18883 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
18884 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
18885 }
18886 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
18887 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
18888 }
18889 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
18890 return (void *)((wxEvent *) ((wxPaintEvent *) x));
18891 }
18892 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
18893 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
18894 }
18895 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
18896 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
18897 }
18898 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
18899 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
18900 }
18901 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
18902 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
18903 }
18904 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
18905 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
18906 }
18907 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
18908 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
18909 }
18910 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
18911 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
18912 }
18913 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
18914 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
18915 }
18916 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
18917 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
18918 }
18919 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
18920 return (void *)((wxEvent *) ((wxFocusEvent *) x));
18921 }
18922 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
18923 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
18924 }
18925 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
18926 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
18927 }
18928 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
18929 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
18930 }
18931 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
18932 return (void *)((wxEvent *) ((wxShowEvent *) x));
18933 }
18934 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
18935 return (void *)((wxEvent *) ((wxCommandEvent *) x));
18936 }
18937 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
18938 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
18939 }
18940 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
18941 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
18942 }
18943 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
18944 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
18945 }
18946 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
18947 return (void *)((wxEvent *) ((wxKeyEvent *) x));
18948 }
18949 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
18950 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
18951 }
18952 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
18953 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
18954 }
18955 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
18956 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
18957 }
18958 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
18959 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
18960 }
18961 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
18962 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
18963 }
18964 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
18965 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
18966 }
18967 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
18968 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
18969 }
18970 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
18971 return (void *)((wxObject *) ((wxSizerItem *) x));
18972 }
18973 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
18974 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
18975 }
18976 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
18977 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
18978 }
18979 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
18980 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
18981 }
18982 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
18983 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
18984 }
18985 static void *_p_wxSizerTo_p_wxObject(void *x) {
18986 return (void *)((wxObject *) ((wxSizer *) x));
18987 }
18988 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
18989 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
18990 }
18991 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
18992 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
18993 }
18994 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
18995 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
18996 }
18997 static void *_p_wxEventTo_p_wxObject(void *x) {
18998 return (void *)((wxObject *) ((wxEvent *) x));
18999 }
19000 static void *_p_wxFontDataTo_p_wxObject(void *x) {
19001 return (void *)((wxObject *) ((wxFontData *) x));
19002 }
19003 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
19004 return (void *)((wxObject *) ((wxPrintData *) x));
19005 }
19006 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
19007 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
19008 }
19009 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
19010 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
19011 }
19012 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
19013 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
19014 }
19015 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
19016 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
19017 }
19018 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
19019 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
19020 }
19021 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
19022 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
19023 }
19024 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
19025 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
19026 }
19027 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
19028 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
19029 }
19030 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
19031 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
19032 }
19033 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
19034 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
19035 }
19036 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
19037 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
19038 }
19039 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
19040 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
19041 }
19042 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
19043 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
19044 }
19045 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
19046 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
19047 }
19048 static void *_p_wxGridEventTo_p_wxObject(void *x) {
19049 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
19050 }
19051 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
19052 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
19053 }
19054 static void *_p_wxControlTo_p_wxObject(void *x) {
19055 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
19056 }
19057 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
19058 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
19059 }
19060 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
19061 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
19062 }
19063 static void *_p_wxFSFileTo_p_wxObject(void *x) {
19064 return (void *)((wxObject *) ((wxFSFile *) x));
19065 }
19066 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
19067 return (void *)((wxObject *) ((wxFindReplaceData *) x));
19068 }
19069 static void *_p_wxGridTo_p_wxObject(void *x) {
19070 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
19071 }
19072 static void *_p_wxPySizerTo_p_wxObject(void *x) {
19073 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
19074 }
19075 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
19076 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
19077 }
19078 static void *_p_wxColourDataTo_p_wxObject(void *x) {
19079 return (void *)((wxObject *) ((wxColourData *) x));
19080 }
19081 static void *_p_wxPyEventTo_p_wxObject(void *x) {
19082 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
19083 }
19084 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
19085 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
19086 }
19087 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
19088 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
19089 }
19090 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
19091 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
19092 }
19093 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
19094 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
19095 }
19096 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
19097 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
19098 }
19099 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
19100 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
19101 }
19102 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
19103 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
19104 }
19105 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
19106 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
19107 }
19108 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
19109 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
19110 }
19111 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
19112 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
19113 }
19114 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
19115 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
19116 }
19117 static void *_p_wxShowEventTo_p_wxObject(void *x) {
19118 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
19119 }
19120 static void *_p_wxPrinterTo_p_wxObject(void *x) {
19121 return (void *)((wxObject *) ((wxPrinter *) x));
19122 }
19123 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
19124 return (void *)((wxObject *) ((wxMenuItem *) x));
19125 }
19126 static void *_p_wxDateEventTo_p_wxObject(void *x) {
19127 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
19128 }
19129 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
19130 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
19131 }
19132 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
19133 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
19134 }
19135 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
19136 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
19137 }
19138 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
19139 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
19140 }
19141 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
19142 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
19143 }
19144 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
19145 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
19146 }
19147 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
19148 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
19149 }
19150 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
19151 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
19152 }
19153 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
19154 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
19155 }
19156 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
19157 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
19158 }
19159 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
19160 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
19161 }
19162 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
19163 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
19164 }
19165 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
19166 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
19167 }
19168 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
19169 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
19170 }
19171 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
19172 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
19173 }
19174 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
19175 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
19176 }
19177 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
19178 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
19179 }
19180 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
19181 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
19182 }
19183 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
19184 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
19185 }
19186 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
19187 return (void *)((wxObject *) ((wxImageHandler *) x));
19188 }
19189 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
19190 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
19191 }
19192 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
19193 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
19194 }
19195 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
19196 return (void *)((wxObject *) ((wxEvtHandler *) x));
19197 }
19198 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
19199 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
19200 }
19201 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
19202 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
19203 }
19204 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
19205 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
19206 }
19207 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
19208 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
19209 }
19210 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
19211 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
19212 }
19213 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
19214 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
19215 }
19216 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
19217 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
19218 }
19219 static void *_p_wxImageTo_p_wxObject(void *x) {
19220 return (void *)((wxObject *) ((wxImage *) x));
19221 }
19222 static void *_p_wxFrameTo_p_wxObject(void *x) {
19223 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
19224 }
19225 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
19226 return (void *)((wxObject *) ((wxPyPrintout *) x));
19227 }
19228 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
19229 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
19230 }
19231 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
19232 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
19233 }
19234 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
19235 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
19236 }
19237 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
19238 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19239 }
19240 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
19241 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19242 }
19243 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
19244 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
19245 }
19246 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
19247 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
19248 }
19249 static void *_p_wxWindowTo_p_wxObject(void *x) {
19250 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
19251 }
19252 static void *_p_wxMenuTo_p_wxObject(void *x) {
19253 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
19254 }
19255 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
19256 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
19257 }
19258 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
19259 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19260 }
19261 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
19262 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
19263 }
19264 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
19265 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
19266 }
19267 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
19268 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
19269 }
19270 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
19271 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
19272 }
19273 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
19274 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19275 }
19276 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
19277 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
19278 }
19279 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
19280 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19281 }
19282 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
19283 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19284 }
19285 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
19286 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19287 }
19288 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
19289 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
19290 }
19291 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
19292 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19293 }
19294 static void *_p_wxSashEventTo_p_wxObject(void *x) {
19295 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
19296 }
19297 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
19298 return (void *)((wxObject *) ((wxPrintPreview *) x));
19299 }
19300 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
19301 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
19302 }
19303 static void *_p_wxPanelTo_p_wxObject(void *x) {
19304 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
19305 }
19306 static void *_p_wxDialogTo_p_wxObject(void *x) {
19307 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19308 }
19309 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
19310 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19311 }
19312 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
19313 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19314 }
19315 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
19316 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19317 }
19318 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
19319 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
19320 }
19321 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
19322 return (void *)((wxObject *) ((wxPrintDialog *) x));
19323 }
19324 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
19325 return (void *)((wxObject *) ((wxFileSystem *) x));
19326 }
19327 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
19328 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
19329 }
19330 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
19331 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
19332 }
19333 static void *_p_wxPyAppTo_p_wxObject(void *x) {
19334 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
19335 }
19336 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
19337 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
19338 }
19339 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
19340 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
19341 }
19342 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
19343 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
19344 }
19345 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
19346 return (void *)((wxObject *) ((wxGridTableBase *) x));
19347 }
19348 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
19349 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
19350 }
19351 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
19352 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
19353 }
19354 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
19355 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
19356 }
19357 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
19358 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19359 }
19360 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
19361 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19362 }
19363 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
19364 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
19365 }
19366 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
19367 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
19368 }
19369 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
19370 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
19371 }
19372 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
19373 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19374 }
19375 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
19376 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
19377 }
19378 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
19379 return (void *)((wxObject *) ((wxPrintDialogData *) x));
19380 }
19381 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
19382 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
19383 }
19384 static void *_p_wxValidatorTo_p_wxObject(void *x) {
19385 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
19386 }
19387 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
19388 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
19389 }
19390 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
19391 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
19392 }
19393 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
19394 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
19395 }
19396 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
19397 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
19398 }
19399 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
19400 return (void *)((wxEvtHandler *) ((wxValidator *) x));
19401 }
19402 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
19403 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
19404 }
19405 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
19406 return (void *)((wxEvtHandler *) ((wxMenu *) x));
19407 }
19408 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
19409 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
19410 }
19411 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
19412 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
19413 }
19414 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
19415 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
19416 }
19417 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
19418 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
19419 }
19420 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
19421 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
19422 }
19423 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
19424 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
19425 }
19426 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
19427 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
19428 }
19429 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
19430 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
19431 }
19432 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
19433 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
19434 }
19435 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
19436 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
19437 }
19438 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
19439 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
19440 }
19441 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
19442 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
19443 }
19444 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
19445 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
19446 }
19447 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
19448 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
19449 }
19450 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
19451 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
19452 }
19453 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
19454 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
19455 }
19456 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
19457 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
19458 }
19459 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
19460 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
19461 }
19462 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
19463 return (void *)((wxEvtHandler *) ((wxWindow *) x));
19464 }
19465 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
19466 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
19467 }
19468 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
19469 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
19470 }
19471 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
19472 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
19473 }
19474 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
19475 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
19476 }
19477 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
19478 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
19479 }
19480 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
19481 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
19482 }
19483 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
19484 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
19485 }
19486 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
19487 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
19488 }
19489 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
19490 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
19491 }
19492 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
19493 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
19494 }
19495 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
19496 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
19497 }
19498 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
19499 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
19500 }
19501 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
19502 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
19503 }
19504 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
19505 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
19506 }
19507 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
19508 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
19509 }
19510 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
19511 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
19512 }
19513 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
19514 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
19515 }
19516 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
19517 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
19518 }
19519 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
19520 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
19521 }
19522 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
19523 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
19524 }
19525 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
19526 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
19527 }
19528 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
19529 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
19530 }
19531 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
19532 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
19533 }
19534 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
19535 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
19536 }
19537 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
19538 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
19539 }
19540 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
19541 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
19542 }
19543 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
19544 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
19545 }
19546 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
19547 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
19548 }
19549 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
19550 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19551 }
19552 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
19553 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19554 }
19555 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
19556 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
19557 }
19558 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
19559 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
19560 }
19561 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
19562 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19563 }
19564 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
19565 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19566 }
19567 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
19568 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
19569 }
19570 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
19571 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
19572 }
19573 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
19574 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
19575 }
19576 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
19577 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
19578 }
19579 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
19580 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
19581 }
19582 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
19583 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
19584 }
19585 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
19586 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
19587 }
19588 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
19589 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
19590 }
19591 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
19592 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
19593 }
19594 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
19595 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
19596 }
19597 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
19598 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
19599 }
19600 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
19601 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
19602 }
19603 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
19604 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
19605 }
19606 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
19607 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
19608 }
19609 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
19610 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
19611 }
19612 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
19613 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
19614 }
19615 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
19616 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
19617 }
19618 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
19619 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
19620 }
19621 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
19622 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
19623 }
19624 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
19625 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
19626 }
19627 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
19628 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
19629 }
19630 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
19631 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
19632 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
19633 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
19634 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
19635 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
19636 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
19637 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
19638 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
19639 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
19640 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0};
19641 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0};
19642 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0};
19643 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0};
19644 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0};
19645 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0};
19646 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0};
19647 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0};
19648 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0};
19649 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0};
19650 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0};
19651 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
19652 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0};
19653 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
19654 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
19655 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
19656 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0};
19657 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0};
19658 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0};
19659 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0};
19660 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0};
19661 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0};
19662 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0};
19663 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0};
19664 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0};
19665 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0};
19666 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0};
19667 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0};
19668 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0};
19669 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0};
19670 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0};
19671 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0};
19672 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0};
19673 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0};
19674 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0};
19675 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0};
19676 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0};
19677 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0};
19678 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0};
19679 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0};
19680 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0};
19681 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0};
19682 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0};
19683 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0};
19684 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
19685 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0};
19686 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0};
19687 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0};
19688 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0};
19689 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0};
19690 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0};
19691 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0};
19692 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0};
19693 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0};
19694 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0};
19695 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0};
19696 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0};
19697 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0};
19698 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0};
19699 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0};
19700 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0};
19701 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0};
19702 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0};
19703 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0};
19704 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0};
19705 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0};
19706 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0};
19707 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0};
19708 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0};
19709 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0};
19710 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0};
19711 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0};
19712 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0};
19713 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0};
19714 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0};
19715 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0};
19716 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0};
19717 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0};
19718 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0};
19719 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0};
19720 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0};
19721 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0};
19722 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0};
19723 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0};
19724 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0};
19725 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0};
19726 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0};
19727 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0};
19728 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0};
19729 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
19730 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, 0};
19731 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, 0};
19732 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, 0};
19733 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, 0};
19734 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, 0};
19735 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, 0};
19736 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, 0};
19737 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, 0};
19738 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, 0};
19739 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, 0};
19740 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, 0};
19741 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, 0};
19742 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, 0};
19743 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, 0};
19744 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, 0};
19745 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, 0};
19746 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, 0};
19747 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, 0};
19748 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, 0};
19749 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, 0};
19750 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, 0};
19751 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, 0};
19752 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, 0};
19753 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, 0};
19754 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, 0};
19755 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, 0};
19756 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, 0};
19757 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
19758 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
19759 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
19760 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0};
19761 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0};
19762 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0};
19763 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0};
19764 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0};
19765 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0};
19766 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0};
19767 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0};
19768 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0};
19769 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0};
19770 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0};
19771 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0};
19772 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0};
19773 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0};
19774 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0};
19775 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0};
19776 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0};
19777 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0};
19778 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0};
19779 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0};
19780 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0};
19781 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0};
19782 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0};
19783 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0};
19784 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0};
19785 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0};
19786 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0};
19787 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0};
19788 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0};
19789 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0};
19790 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0};
19791 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0};
19792 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0};
19793 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0};
19794 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0};
19795 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0};
19796 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0};
19797 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0};
19798 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0};
19799 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0};
19800 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0};
19801 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0};
19802 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0};
19803 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, 0};
19804 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
19805 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
19806 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, 0};
19807 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, 0};
19808 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, 0};
19809 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, 0};
19810 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
19811 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, 0};
19812 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
19813 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, 0};
19814 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
19815 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
19816 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
19817 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
19818 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
19819
19820 static swig_type_info *swig_type_initial[] = {
19821 &_swigt__p_char,
19822 &_swigt__p_form_ops_t,
19823 &_swigt__p_int,
19824 &_swigt__p_long,
19825 &_swigt__p_unsigned_char,
19826 &_swigt__p_unsigned_int,
19827 &_swigt__p_unsigned_long,
19828 &_swigt__p_wxANIHandler,
19829 &_swigt__p_wxAcceleratorTable,
19830 &_swigt__p_wxActivateEvent,
19831 &_swigt__p_wxArrayString,
19832 &_swigt__p_wxBMPHandler,
19833 &_swigt__p_wxBoxSizer,
19834 &_swigt__p_wxCURHandler,
19835 &_swigt__p_wxCalculateLayoutEvent,
19836 &_swigt__p_wxChildFocusEvent,
19837 &_swigt__p_wxCloseEvent,
19838 &_swigt__p_wxColour,
19839 &_swigt__p_wxColourData,
19840 &_swigt__p_wxColourDialog,
19841 &_swigt__p_wxCommandEvent,
19842 &_swigt__p_wxContextMenuEvent,
19843 &_swigt__p_wxControl,
19844 &_swigt__p_wxControlWithItems,
19845 &_swigt__p_wxDC,
19846 &_swigt__p_wxDateEvent,
19847 &_swigt__p_wxDialog,
19848 &_swigt__p_wxDirDialog,
19849 &_swigt__p_wxDisplayChangedEvent,
19850 &_swigt__p_wxDropFilesEvent,
19851 &_swigt__p_wxDuplexMode,
19852 &_swigt__p_wxEraseEvent,
19853 &_swigt__p_wxEvent,
19854 &_swigt__p_wxEvtHandler,
19855 &_swigt__p_wxFSFile,
19856 &_swigt__p_wxFileDialog,
19857 &_swigt__p_wxFileSystem,
19858 &_swigt__p_wxFindDialogEvent,
19859 &_swigt__p_wxFindReplaceData,
19860 &_swigt__p_wxFindReplaceDialog,
19861 &_swigt__p_wxFlexGridSizer,
19862 &_swigt__p_wxFocusEvent,
19863 &_swigt__p_wxFont,
19864 &_swigt__p_wxFontData,
19865 &_swigt__p_wxFontDialog,
19866 &_swigt__p_wxFrame,
19867 &_swigt__p_wxGBSizerItem,
19868 &_swigt__p_wxGIFHandler,
19869 &_swigt__p_wxGrid,
19870 &_swigt__p_wxGridBagSizer,
19871 &_swigt__p_wxGridCellAttr,
19872 &_swigt__p_wxGridCellAttrProvider,
19873 &_swigt__p_wxGridCellAutoWrapStringEditor,
19874 &_swigt__p_wxGridCellAutoWrapStringRenderer,
19875 &_swigt__p_wxGridCellBoolEditor,
19876 &_swigt__p_wxGridCellBoolRenderer,
19877 &_swigt__p_wxGridCellChoiceEditor,
19878 &_swigt__p_wxGridCellCoords,
19879 &_swigt__p_wxGridCellDateTimeRenderer,
19880 &_swigt__p_wxGridCellEditor,
19881 &_swigt__p_wxGridCellEnumEditor,
19882 &_swigt__p_wxGridCellEnumRenderer,
19883 &_swigt__p_wxGridCellFloatEditor,
19884 &_swigt__p_wxGridCellFloatRenderer,
19885 &_swigt__p_wxGridCellNumberEditor,
19886 &_swigt__p_wxGridCellNumberRenderer,
19887 &_swigt__p_wxGridCellRenderer,
19888 &_swigt__p_wxGridCellStringRenderer,
19889 &_swigt__p_wxGridCellTextEditor,
19890 &_swigt__p_wxGridEditorCreatedEvent,
19891 &_swigt__p_wxGridEvent,
19892 &_swigt__p_wxGridRangeSelectEvent,
19893 &_swigt__p_wxGridSizeEvent,
19894 &_swigt__p_wxGridSizer,
19895 &_swigt__p_wxGridStringTable,
19896 &_swigt__p_wxGridTableBase,
19897 &_swigt__p_wxGridTableMessage,
19898 &_swigt__p_wxICOHandler,
19899 &_swigt__p_wxIconizeEvent,
19900 &_swigt__p_wxIdleEvent,
19901 &_swigt__p_wxImage,
19902 &_swigt__p_wxImageHandler,
19903 &_swigt__p_wxIndividualLayoutConstraint,
19904 &_swigt__p_wxInitDialogEvent,
19905 &_swigt__p_wxJPEGHandler,
19906 &_swigt__p_wxKeyEvent,
19907 &_swigt__p_wxLayoutAlgorithm,
19908 &_swigt__p_wxLayoutConstraints,
19909 &_swigt__p_wxMDIChildFrame,
19910 &_swigt__p_wxMDIClientWindow,
19911 &_swigt__p_wxMDIParentFrame,
19912 &_swigt__p_wxMaximizeEvent,
19913 &_swigt__p_wxMenu,
19914 &_swigt__p_wxMenuBar,
19915 &_swigt__p_wxMenuEvent,
19916 &_swigt__p_wxMenuItem,
19917 &_swigt__p_wxMessageDialog,
19918 &_swigt__p_wxMiniFrame,
19919 &_swigt__p_wxMouseCaptureChangedEvent,
19920 &_swigt__p_wxMouseEvent,
19921 &_swigt__p_wxMoveEvent,
19922 &_swigt__p_wxMultiChoiceDialog,
19923 &_swigt__p_wxNavigationKeyEvent,
19924 &_swigt__p_wxNcPaintEvent,
19925 &_swigt__p_wxNotifyEvent,
19926 &_swigt__p_wxObject,
19927 &_swigt__p_wxPCXHandler,
19928 &_swigt__p_wxPNGHandler,
19929 &_swigt__p_wxPNMHandler,
19930 &_swigt__p_wxPageSetupDialog,
19931 &_swigt__p_wxPageSetupDialogData,
19932 &_swigt__p_wxPaintEvent,
19933 &_swigt__p_wxPaletteChangedEvent,
19934 &_swigt__p_wxPanel,
19935 &_swigt__p_wxPaperSize,
19936 &_swigt__p_wxPasswordEntryDialog,
19937 &_swigt__p_wxPoint,
19938 &_swigt__p_wxPopupWindow,
19939 &_swigt__p_wxPreviewCanvas,
19940 &_swigt__p_wxPreviewControlBar,
19941 &_swigt__p_wxPreviewFrame,
19942 &_swigt__p_wxPrintData,
19943 &_swigt__p_wxPrintDialog,
19944 &_swigt__p_wxPrintDialogData,
19945 &_swigt__p_wxPrintPreview,
19946 &_swigt__p_wxPrinter,
19947 &_swigt__p_wxProgressDialog,
19948 &_swigt__p_wxPyApp,
19949 &_swigt__p_wxPyCommandEvent,
19950 &_swigt__p_wxPyEvent,
19951 &_swigt__p_wxPyGridCellAttrProvider,
19952 &_swigt__p_wxPyGridCellEditor,
19953 &_swigt__p_wxPyGridCellRenderer,
19954 &_swigt__p_wxPyGridTableBase,
19955 &_swigt__p_wxPyHtmlListBox,
19956 &_swigt__p_wxPyImageHandler,
19957 &_swigt__p_wxPyPanel,
19958 &_swigt__p_wxPyPopupTransientWindow,
19959 &_swigt__p_wxPyPreviewControlBar,
19960 &_swigt__p_wxPyPreviewFrame,
19961 &_swigt__p_wxPyPrintPreview,
19962 &_swigt__p_wxPyPrintout,
19963 &_swigt__p_wxPyScrolledWindow,
19964 &_swigt__p_wxPySizer,
19965 &_swigt__p_wxPyTaskBarIcon,
19966 &_swigt__p_wxPyVListBox,
19967 &_swigt__p_wxPyVScrolledWindow,
19968 &_swigt__p_wxPyValidator,
19969 &_swigt__p_wxPyWindow,
19970 &_swigt__p_wxQueryLayoutInfoEvent,
19971 &_swigt__p_wxQueryNewPaletteEvent,
19972 &_swigt__p_wxRect,
19973 &_swigt__p_wxSashEvent,
19974 &_swigt__p_wxSashLayoutWindow,
19975 &_swigt__p_wxSashWindow,
19976 &_swigt__p_wxScrollEvent,
19977 &_swigt__p_wxScrollWinEvent,
19978 &_swigt__p_wxScrolledWindow,
19979 &_swigt__p_wxSetCursorEvent,
19980 &_swigt__p_wxShowEvent,
19981 &_swigt__p_wxSingleChoiceDialog,
19982 &_swigt__p_wxSize,
19983 &_swigt__p_wxSizeEvent,
19984 &_swigt__p_wxSizer,
19985 &_swigt__p_wxSizerItem,
19986 &_swigt__p_wxSplashScreen,
19987 &_swigt__p_wxSplashScreenWindow,
19988 &_swigt__p_wxSplitterEvent,
19989 &_swigt__p_wxSplitterWindow,
19990 &_swigt__p_wxStaticBoxSizer,
19991 &_swigt__p_wxStatusBar,
19992 &_swigt__p_wxStdDialogButtonSizer,
19993 &_swigt__p_wxString,
19994 &_swigt__p_wxSysColourChangedEvent,
19995 &_swigt__p_wxTIFFHandler,
19996 &_swigt__p_wxTaskBarIconEvent,
19997 &_swigt__p_wxTextEntryDialog,
19998 &_swigt__p_wxTipWindow,
19999 &_swigt__p_wxTopLevelWindow,
20000 &_swigt__p_wxUpdateUIEvent,
20001 &_swigt__p_wxValidator,
20002 &_swigt__p_wxVisualAttributes,
20003 &_swigt__p_wxWindow,
20004 &_swigt__p_wxWindowCreateEvent,
20005 &_swigt__p_wxWindowDestroyEvent,
20006 &_swigt__p_wxXPMHandler,
20007 &_swigt__ptrdiff_t,
20008 &_swigt__std__ptrdiff_t,
20009 &_swigt__unsigned_int,
20010 };
20011
20012 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
20013 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
20014 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
20015 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
20016 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
20017 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
20018 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
20019 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
20020 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
20021 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
20022 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
20023 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
20024 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
20025 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
20026 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
20027 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
20028 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
20029 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
20030 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
20031 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
20032 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
20033 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
20034 static swig_cast_info _swigc__p_wxControl[] = { {&_swigt__p_wxControl, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxControl, 0, 0},{0, 0, 0, 0}};
20035 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
20036 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
20037 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
20038 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
20039 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
20040 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
20041 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
20042 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
20043 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
20044 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
20045 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
20046 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
20047 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
20048 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
20049 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
20050 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
20051 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
20052 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
20053 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
20054 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
20055 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
20056 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
20057 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
20058 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
20059 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
20060 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
20061 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
20062 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
20063 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
20064 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
20065 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
20066 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
20067 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
20068 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
20069 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
20070 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
20071 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
20072 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
20073 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
20074 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
20075 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
20076 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
20077 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
20078 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
20079 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
20080 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
20081 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
20082 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
20083 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
20084 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
20085 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
20086 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
20087 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
20088 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
20089 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
20090 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
20091 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
20092 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
20093 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
20094 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
20095 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
20096 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
20097 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
20098 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
20099 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
20100 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
20101 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
20102 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
20103 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
20104 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
20105 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
20106 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
20107 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
20108 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
20109 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
20110 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
20111 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
20112 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
20113 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
20114 static swig_cast_info _swigc__p_wxGridCellAttrProvider[] = { {&_swigt__p_wxGridCellAttrProvider, 0, 0, 0}, {&_swigt__p_wxPyGridCellAttrProvider, _p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider, 0, 0},{0, 0, 0, 0}};
20115 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
20116 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
20117 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
20118 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
20119 static swig_cast_info _swigc__p_wxGridCellChoiceEditor[] = { {&_swigt__p_wxGridCellChoiceEditor, 0, 0, 0}, {&_swigt__p_wxGridCellEnumEditor, _p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor, 0, 0},{0, 0, 0, 0}};
20120 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
20121 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
20122 static swig_cast_info _swigc__p_wxGridCellEditor[] = { {&_swigt__p_wxGridCellEditor, 0, 0, 0}, {&_swigt__p_wxPyGridCellEditor, _p_wxPyGridCellEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellTextEditor, _p_wxGridCellTextEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellNumberEditor, _p_wxGridCellNumberEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellFloatEditor, _p_wxGridCellFloatEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellBoolEditor, _p_wxGridCellBoolEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellAutoWrapStringEditor, _p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellChoiceEditor, _p_wxGridCellChoiceEditorTo_p_wxGridCellEditor, 0, 0}, {&_swigt__p_wxGridCellEnumEditor, _p_wxGridCellEnumEditorTo_p_wxGridCellEditor, 0, 0},{0, 0, 0, 0}};
20123 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
20124 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
20125 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
20126 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
20127 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
20128 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
20129 static swig_cast_info _swigc__p_wxGridCellRenderer[] = { {&_swigt__p_wxGridCellRenderer, 0, 0, 0}, {&_swigt__p_wxPyGridCellRenderer, _p_wxPyGridCellRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellStringRenderer, _p_wxGridCellStringRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellNumberRenderer, _p_wxGridCellNumberRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellFloatRenderer, _p_wxGridCellFloatRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellDateTimeRenderer, _p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellEnumRenderer, _p_wxGridCellEnumRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellAutoWrapStringRenderer, _p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer, 0, 0}, {&_swigt__p_wxGridCellBoolRenderer, _p_wxGridCellBoolRendererTo_p_wxGridCellRenderer, 0, 0},{0, 0, 0, 0}};
20130 static swig_cast_info _swigc__p_wxGridCellStringRenderer[] = { {&_swigt__p_wxGridCellStringRenderer, 0, 0, 0}, {&_swigt__p_wxGridCellNumberRenderer, _p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer, 0, 0}, {&_swigt__p_wxGridCellFloatRenderer, _p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer, 0, 0}, {&_swigt__p_wxGridCellDateTimeRenderer, _p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer, 0, 0}, {&_swigt__p_wxGridCellEnumRenderer, _p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer, 0, 0}, {&_swigt__p_wxGridCellAutoWrapStringRenderer, _p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer, 0, 0},{0, 0, 0, 0}};
20131 static swig_cast_info _swigc__p_wxGridCellTextEditor[] = { {&_swigt__p_wxGridCellTextEditor, 0, 0, 0}, {&_swigt__p_wxGridCellNumberEditor, _p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor, 0, 0}, {&_swigt__p_wxGridCellFloatEditor, _p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor, 0, 0}, {&_swigt__p_wxGridCellAutoWrapStringEditor, _p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor, 0, 0},{0, 0, 0, 0}};
20132 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
20133 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
20134 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
20135 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
20136 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
20137 static swig_cast_info _swigc__p_wxGridTableBase[] = { {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxGridTableBase, 0, 0}, {&_swigt__p_wxGridTableBase, 0, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxGridTableBase, 0, 0},{0, 0, 0, 0}};
20138 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
20139 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
20140 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxNotifyEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxNotifyEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxNotifyEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxNotifyEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
20141 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
20142 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
20143 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
20144 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
20145 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
20146 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
20147 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
20148 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
20149 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
20150 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
20151 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
20152 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
20153 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
20154 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
20155 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
20156 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
20157 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
20158 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
20159 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
20160 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
20161 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
20162 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
20163 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
20164 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
20165 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
20166 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
20167 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
20168 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
20169 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
20170 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
20171 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
20172 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
20173 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
20174 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
20175 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
20176 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
20177 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
20178 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
20179 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
20180 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
20181 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
20182 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
20183 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
20184 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_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_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_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_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_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_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
20185 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxPanel, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0},{0, 0, 0, 0}};
20186 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
20187 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
20188 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
20189 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
20190 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
20191 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
20192 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
20193 static swig_cast_info _swigc__p_wxScrolledWindow[] = { {&_swigt__p_wxGrid, _p_wxGridTo_p_wxScrolledWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, 0, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxScrolledWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxScrolledWindow, 0, 0},{0, 0, 0, 0}};
20194 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
20195 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
20196 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
20197 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
20198 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
20199 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
20200 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
20201
20202 static swig_cast_info *swig_cast_initial[] = {
20203 _swigc__p_char,
20204 _swigc__p_form_ops_t,
20205 _swigc__p_int,
20206 _swigc__p_long,
20207 _swigc__p_unsigned_char,
20208 _swigc__p_unsigned_int,
20209 _swigc__p_unsigned_long,
20210 _swigc__p_wxANIHandler,
20211 _swigc__p_wxAcceleratorTable,
20212 _swigc__p_wxActivateEvent,
20213 _swigc__p_wxArrayString,
20214 _swigc__p_wxBMPHandler,
20215 _swigc__p_wxBoxSizer,
20216 _swigc__p_wxCURHandler,
20217 _swigc__p_wxCalculateLayoutEvent,
20218 _swigc__p_wxChildFocusEvent,
20219 _swigc__p_wxCloseEvent,
20220 _swigc__p_wxColour,
20221 _swigc__p_wxColourData,
20222 _swigc__p_wxColourDialog,
20223 _swigc__p_wxCommandEvent,
20224 _swigc__p_wxContextMenuEvent,
20225 _swigc__p_wxControl,
20226 _swigc__p_wxControlWithItems,
20227 _swigc__p_wxDC,
20228 _swigc__p_wxDateEvent,
20229 _swigc__p_wxDialog,
20230 _swigc__p_wxDirDialog,
20231 _swigc__p_wxDisplayChangedEvent,
20232 _swigc__p_wxDropFilesEvent,
20233 _swigc__p_wxDuplexMode,
20234 _swigc__p_wxEraseEvent,
20235 _swigc__p_wxEvent,
20236 _swigc__p_wxEvtHandler,
20237 _swigc__p_wxFSFile,
20238 _swigc__p_wxFileDialog,
20239 _swigc__p_wxFileSystem,
20240 _swigc__p_wxFindDialogEvent,
20241 _swigc__p_wxFindReplaceData,
20242 _swigc__p_wxFindReplaceDialog,
20243 _swigc__p_wxFlexGridSizer,
20244 _swigc__p_wxFocusEvent,
20245 _swigc__p_wxFont,
20246 _swigc__p_wxFontData,
20247 _swigc__p_wxFontDialog,
20248 _swigc__p_wxFrame,
20249 _swigc__p_wxGBSizerItem,
20250 _swigc__p_wxGIFHandler,
20251 _swigc__p_wxGrid,
20252 _swigc__p_wxGridBagSizer,
20253 _swigc__p_wxGridCellAttr,
20254 _swigc__p_wxGridCellAttrProvider,
20255 _swigc__p_wxGridCellAutoWrapStringEditor,
20256 _swigc__p_wxGridCellAutoWrapStringRenderer,
20257 _swigc__p_wxGridCellBoolEditor,
20258 _swigc__p_wxGridCellBoolRenderer,
20259 _swigc__p_wxGridCellChoiceEditor,
20260 _swigc__p_wxGridCellCoords,
20261 _swigc__p_wxGridCellDateTimeRenderer,
20262 _swigc__p_wxGridCellEditor,
20263 _swigc__p_wxGridCellEnumEditor,
20264 _swigc__p_wxGridCellEnumRenderer,
20265 _swigc__p_wxGridCellFloatEditor,
20266 _swigc__p_wxGridCellFloatRenderer,
20267 _swigc__p_wxGridCellNumberEditor,
20268 _swigc__p_wxGridCellNumberRenderer,
20269 _swigc__p_wxGridCellRenderer,
20270 _swigc__p_wxGridCellStringRenderer,
20271 _swigc__p_wxGridCellTextEditor,
20272 _swigc__p_wxGridEditorCreatedEvent,
20273 _swigc__p_wxGridEvent,
20274 _swigc__p_wxGridRangeSelectEvent,
20275 _swigc__p_wxGridSizeEvent,
20276 _swigc__p_wxGridSizer,
20277 _swigc__p_wxGridStringTable,
20278 _swigc__p_wxGridTableBase,
20279 _swigc__p_wxGridTableMessage,
20280 _swigc__p_wxICOHandler,
20281 _swigc__p_wxIconizeEvent,
20282 _swigc__p_wxIdleEvent,
20283 _swigc__p_wxImage,
20284 _swigc__p_wxImageHandler,
20285 _swigc__p_wxIndividualLayoutConstraint,
20286 _swigc__p_wxInitDialogEvent,
20287 _swigc__p_wxJPEGHandler,
20288 _swigc__p_wxKeyEvent,
20289 _swigc__p_wxLayoutAlgorithm,
20290 _swigc__p_wxLayoutConstraints,
20291 _swigc__p_wxMDIChildFrame,
20292 _swigc__p_wxMDIClientWindow,
20293 _swigc__p_wxMDIParentFrame,
20294 _swigc__p_wxMaximizeEvent,
20295 _swigc__p_wxMenu,
20296 _swigc__p_wxMenuBar,
20297 _swigc__p_wxMenuEvent,
20298 _swigc__p_wxMenuItem,
20299 _swigc__p_wxMessageDialog,
20300 _swigc__p_wxMiniFrame,
20301 _swigc__p_wxMouseCaptureChangedEvent,
20302 _swigc__p_wxMouseEvent,
20303 _swigc__p_wxMoveEvent,
20304 _swigc__p_wxMultiChoiceDialog,
20305 _swigc__p_wxNavigationKeyEvent,
20306 _swigc__p_wxNcPaintEvent,
20307 _swigc__p_wxNotifyEvent,
20308 _swigc__p_wxObject,
20309 _swigc__p_wxPCXHandler,
20310 _swigc__p_wxPNGHandler,
20311 _swigc__p_wxPNMHandler,
20312 _swigc__p_wxPageSetupDialog,
20313 _swigc__p_wxPageSetupDialogData,
20314 _swigc__p_wxPaintEvent,
20315 _swigc__p_wxPaletteChangedEvent,
20316 _swigc__p_wxPanel,
20317 _swigc__p_wxPaperSize,
20318 _swigc__p_wxPasswordEntryDialog,
20319 _swigc__p_wxPoint,
20320 _swigc__p_wxPopupWindow,
20321 _swigc__p_wxPreviewCanvas,
20322 _swigc__p_wxPreviewControlBar,
20323 _swigc__p_wxPreviewFrame,
20324 _swigc__p_wxPrintData,
20325 _swigc__p_wxPrintDialog,
20326 _swigc__p_wxPrintDialogData,
20327 _swigc__p_wxPrintPreview,
20328 _swigc__p_wxPrinter,
20329 _swigc__p_wxProgressDialog,
20330 _swigc__p_wxPyApp,
20331 _swigc__p_wxPyCommandEvent,
20332 _swigc__p_wxPyEvent,
20333 _swigc__p_wxPyGridCellAttrProvider,
20334 _swigc__p_wxPyGridCellEditor,
20335 _swigc__p_wxPyGridCellRenderer,
20336 _swigc__p_wxPyGridTableBase,
20337 _swigc__p_wxPyHtmlListBox,
20338 _swigc__p_wxPyImageHandler,
20339 _swigc__p_wxPyPanel,
20340 _swigc__p_wxPyPopupTransientWindow,
20341 _swigc__p_wxPyPreviewControlBar,
20342 _swigc__p_wxPyPreviewFrame,
20343 _swigc__p_wxPyPrintPreview,
20344 _swigc__p_wxPyPrintout,
20345 _swigc__p_wxPyScrolledWindow,
20346 _swigc__p_wxPySizer,
20347 _swigc__p_wxPyTaskBarIcon,
20348 _swigc__p_wxPyVListBox,
20349 _swigc__p_wxPyVScrolledWindow,
20350 _swigc__p_wxPyValidator,
20351 _swigc__p_wxPyWindow,
20352 _swigc__p_wxQueryLayoutInfoEvent,
20353 _swigc__p_wxQueryNewPaletteEvent,
20354 _swigc__p_wxRect,
20355 _swigc__p_wxSashEvent,
20356 _swigc__p_wxSashLayoutWindow,
20357 _swigc__p_wxSashWindow,
20358 _swigc__p_wxScrollEvent,
20359 _swigc__p_wxScrollWinEvent,
20360 _swigc__p_wxScrolledWindow,
20361 _swigc__p_wxSetCursorEvent,
20362 _swigc__p_wxShowEvent,
20363 _swigc__p_wxSingleChoiceDialog,
20364 _swigc__p_wxSize,
20365 _swigc__p_wxSizeEvent,
20366 _swigc__p_wxSizer,
20367 _swigc__p_wxSizerItem,
20368 _swigc__p_wxSplashScreen,
20369 _swigc__p_wxSplashScreenWindow,
20370 _swigc__p_wxSplitterEvent,
20371 _swigc__p_wxSplitterWindow,
20372 _swigc__p_wxStaticBoxSizer,
20373 _swigc__p_wxStatusBar,
20374 _swigc__p_wxStdDialogButtonSizer,
20375 _swigc__p_wxString,
20376 _swigc__p_wxSysColourChangedEvent,
20377 _swigc__p_wxTIFFHandler,
20378 _swigc__p_wxTaskBarIconEvent,
20379 _swigc__p_wxTextEntryDialog,
20380 _swigc__p_wxTipWindow,
20381 _swigc__p_wxTopLevelWindow,
20382 _swigc__p_wxUpdateUIEvent,
20383 _swigc__p_wxValidator,
20384 _swigc__p_wxVisualAttributes,
20385 _swigc__p_wxWindow,
20386 _swigc__p_wxWindowCreateEvent,
20387 _swigc__p_wxWindowDestroyEvent,
20388 _swigc__p_wxXPMHandler,
20389 _swigc__ptrdiff_t,
20390 _swigc__std__ptrdiff_t,
20391 _swigc__unsigned_int,
20392 };
20393
20394
20395 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
20396
20397 static swig_const_info swig_const_table[] = {
20398 { SWIG_PY_POINTER, (char*)"GRID_VALUE_STRING", 0, 0, (void *)"string", &SWIGTYPE_p_char},
20399 { SWIG_PY_POINTER, (char*)"GRID_VALUE_BOOL", 0, 0, (void *)"bool", &SWIGTYPE_p_char},
20400 { SWIG_PY_POINTER, (char*)"GRID_VALUE_NUMBER", 0, 0, (void *)"long", &SWIGTYPE_p_char},
20401 { SWIG_PY_POINTER, (char*)"GRID_VALUE_FLOAT", 0, 0, (void *)"double", &SWIGTYPE_p_char},
20402 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICE", 0, 0, (void *)"choice", &SWIGTYPE_p_char},
20403 { SWIG_PY_POINTER, (char*)"GRID_VALUE_TEXT", 0, 0, (void *)"string", &SWIGTYPE_p_char},
20404 { SWIG_PY_POINTER, (char*)"GRID_VALUE_LONG", 0, 0, (void *)"long", &SWIGTYPE_p_char},
20405 { SWIG_PY_POINTER, (char*)"GRID_VALUE_CHOICEINT", 0, 0, (void *)"choiceint", &SWIGTYPE_p_char},
20406 { SWIG_PY_POINTER, (char*)"GRID_VALUE_DATETIME", 0, 0, (void *)"datetime", &SWIGTYPE_p_char},
20407 {0, 0, 0, 0.0, 0, 0}};
20408
20409 #ifdef __cplusplus
20410 }
20411 #endif
20412 /*************************************************************************
20413 * Type initialization:
20414 * This problem is tough by the requirement that no dynamic
20415 * memory is used. Also, since swig_type_info structures store pointers to
20416 * swig_cast_info structures and swig_cast_info structures store pointers back
20417 * to swig_type_info structures, we need some lookup code at initialization.
20418 * The idea is that swig generates all the structures that are needed.
20419 * The runtime then collects these partially filled structures.
20420 * The SWIG_InitializeModule function takes these initial arrays out of
20421 * swig_module, and does all the lookup, filling in the swig_module.types
20422 * array with the correct data and linking the correct swig_cast_info
20423 * structures together.
20424
20425 * The generated swig_type_info structures are assigned staticly to an initial
20426 * array. We just loop though that array, and handle each type individually.
20427 * First we lookup if this type has been already loaded, and if so, use the
20428 * loaded structure instead of the generated one. Then we have to fill in the
20429 * cast linked list. The cast data is initially stored in something like a
20430 * two-dimensional array. Each row corresponds to a type (there are the same
20431 * number of rows as there are in the swig_type_initial array). Each entry in
20432 * a column is one of the swig_cast_info structures for that type.
20433 * The cast_initial array is actually an array of arrays, because each row has
20434 * a variable number of columns. So to actually build the cast linked list,
20435 * we find the array of casts associated with the type, and loop through it
20436 * adding the casts to the list. The one last trick we need to do is making
20437 * sure the type pointer in the swig_cast_info struct is correct.
20438
20439 * First off, we lookup the cast->type name to see if it is already loaded.
20440 * There are three cases to handle:
20441 * 1) If the cast->type has already been loaded AND the type we are adding
20442 * casting info to has not been loaded (it is in this module), THEN we
20443 * replace the cast->type pointer with the type pointer that has already
20444 * been loaded.
20445 * 2) If BOTH types (the one we are adding casting info to, and the
20446 * cast->type) are loaded, THEN the cast info has already been loaded by
20447 * the previous module so we just ignore it.
20448 * 3) Finally, if cast->type has not already been loaded, then we add that
20449 * swig_cast_info to the linked list (because the cast->type) pointer will
20450 * be correct.
20451 **/
20452
20453 #ifdef __cplusplus
20454 extern "C" {
20455 #if 0
20456 } /* c-mode */
20457 #endif
20458 #endif
20459
20460 #if 0
20461 #define SWIGRUNTIME_DEBUG
20462 #endif
20463
20464 SWIGRUNTIME void
20465 SWIG_InitializeModule(void *clientdata) {
20466 size_t i;
20467 swig_module_info *module_head;
20468 static int init_run = 0;
20469
20470 clientdata = clientdata;
20471
20472 if (init_run) return;
20473 init_run = 1;
20474
20475 /* Initialize the swig_module */
20476 swig_module.type_initial = swig_type_initial;
20477 swig_module.cast_initial = swig_cast_initial;
20478
20479 /* Try and load any already created modules */
20480 module_head = SWIG_GetModule(clientdata);
20481 if (module_head) {
20482 swig_module.next = module_head->next;
20483 module_head->next = &swig_module;
20484 } else {
20485 /* This is the first module loaded */
20486 swig_module.next = &swig_module;
20487 SWIG_SetModule(clientdata, &swig_module);
20488 }
20489
20490 /* Now work on filling in swig_module.types */
20491 #ifdef SWIGRUNTIME_DEBUG
20492 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
20493 #endif
20494 for (i = 0; i < swig_module.size; ++i) {
20495 swig_type_info *type = 0;
20496 swig_type_info *ret;
20497 swig_cast_info *cast;
20498
20499 #ifdef SWIGRUNTIME_DEBUG
20500 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20501 #endif
20502
20503 /* if there is another module already loaded */
20504 if (swig_module.next != &swig_module) {
20505 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
20506 }
20507 if (type) {
20508 /* Overwrite clientdata field */
20509 #ifdef SWIGRUNTIME_DEBUG
20510 printf("SWIG_InitializeModule: found type %s\n", type->name);
20511 #endif
20512 if (swig_module.type_initial[i]->clientdata) {
20513 type->clientdata = swig_module.type_initial[i]->clientdata;
20514 #ifdef SWIGRUNTIME_DEBUG
20515 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
20516 #endif
20517 }
20518 } else {
20519 type = swig_module.type_initial[i];
20520 }
20521
20522 /* Insert casting types */
20523 cast = swig_module.cast_initial[i];
20524 while (cast->type) {
20525 /* Don't need to add information already in the list */
20526 ret = 0;
20527 #ifdef SWIGRUNTIME_DEBUG
20528 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
20529 #endif
20530 if (swig_module.next != &swig_module) {
20531 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
20532 #ifdef SWIGRUNTIME_DEBUG
20533 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
20534 #endif
20535 }
20536 if (ret) {
20537 if (type == swig_module.type_initial[i]) {
20538 #ifdef SWIGRUNTIME_DEBUG
20539 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
20540 #endif
20541 cast->type = ret;
20542 ret = 0;
20543 } else {
20544 /* Check for casting already in the list */
20545 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
20546 #ifdef SWIGRUNTIME_DEBUG
20547 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
20548 #endif
20549 if (!ocast) ret = 0;
20550 }
20551 }
20552
20553 if (!ret) {
20554 #ifdef SWIGRUNTIME_DEBUG
20555 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
20556 #endif
20557 if (type->cast) {
20558 type->cast->prev = cast;
20559 cast->next = type->cast;
20560 }
20561 type->cast = cast;
20562 }
20563 cast++;
20564 }
20565 /* Set entry in modules->types array equal to the type */
20566 swig_module.types[i] = type;
20567 }
20568 swig_module.types[i] = 0;
20569
20570 #ifdef SWIGRUNTIME_DEBUG
20571 printf("**** SWIG_InitializeModule: Cast List ******\n");
20572 for (i = 0; i < swig_module.size; ++i) {
20573 int j = 0;
20574 swig_cast_info *cast = swig_module.cast_initial[i];
20575 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20576 while (cast->type) {
20577 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
20578 cast++;
20579 ++j;
20580 }
20581 printf("---- Total casts: %d\n",j);
20582 }
20583 printf("**** SWIG_InitializeModule: Cast List ******\n");
20584 #endif
20585 }
20586
20587 /* This function will propagate the clientdata field of type to
20588 * any new swig_type_info structures that have been added into the list
20589 * of equivalent types. It is like calling
20590 * SWIG_TypeClientData(type, clientdata) a second time.
20591 */
20592 SWIGRUNTIME void
20593 SWIG_PropagateClientData(void) {
20594 size_t i;
20595 swig_cast_info *equiv;
20596 static int init_run = 0;
20597
20598 if (init_run) return;
20599 init_run = 1;
20600
20601 for (i = 0; i < swig_module.size; i++) {
20602 if (swig_module.types[i]->clientdata) {
20603 equiv = swig_module.types[i]->cast;
20604 while (equiv) {
20605 if (!equiv->converter) {
20606 if (equiv->type && !equiv->type->clientdata)
20607 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
20608 }
20609 equiv = equiv->next;
20610 }
20611 }
20612 }
20613 }
20614
20615 #ifdef __cplusplus
20616 #if 0
20617 {
20618 /* c-mode */
20619 #endif
20620 }
20621 #endif
20622
20623
20624
20625 #ifdef __cplusplus
20626 extern "C" {
20627 #endif
20628
20629 /* Python-specific SWIG API */
20630 #define SWIG_newvarlink() SWIG_Python_newvarlink()
20631 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
20632 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
20633
20634 /* -----------------------------------------------------------------------------
20635 * global variable support code.
20636 * ----------------------------------------------------------------------------- */
20637
20638 typedef struct swig_globalvar {
20639 char *name; /* Name of global variable */
20640 PyObject *(*get_attr)(void); /* Return the current value */
20641 int (*set_attr)(PyObject *); /* Set the value */
20642 struct swig_globalvar *next;
20643 } swig_globalvar;
20644
20645 typedef struct swig_varlinkobject {
20646 PyObject_HEAD
20647 swig_globalvar *vars;
20648 } swig_varlinkobject;
20649
20650 SWIGINTERN PyObject *
20651 swig_varlink_repr(swig_varlinkobject *v) {
20652 v = v;
20653 return PyString_FromString("<Swig global variables>");
20654 }
20655
20656 SWIGINTERN int
20657 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
20658 swig_globalvar *var;
20659 flags = flags;
20660 fprintf(fp,"Swig global variables { ");
20661 for (var = v->vars; var; var=var->next) {
20662 fprintf(fp,"%s", var->name);
20663 if (var->next) fprintf(fp,", ");
20664 }
20665 fprintf(fp," }\n");
20666 return 0;
20667 }
20668
20669 SWIGINTERN PyObject *
20670 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
20671 swig_globalvar *var = v->vars;
20672 while (var) {
20673 if (strcmp(var->name,n) == 0) {
20674 return (*var->get_attr)();
20675 }
20676 var = var->next;
20677 }
20678 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
20679 return NULL;
20680 }
20681
20682 SWIGINTERN int
20683 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
20684 swig_globalvar *var = v->vars;
20685 while (var) {
20686 if (strcmp(var->name,n) == 0) {
20687 return (*var->set_attr)(p);
20688 }
20689 var = var->next;
20690 }
20691 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
20692 return 1;
20693 }
20694
20695 SWIGINTERN PyTypeObject*
20696 swig_varlink_type(void) {
20697 static char varlink__doc__[] = "Swig var link object";
20698 static PyTypeObject varlink_type
20699 #if !defined(__cplusplus)
20700 ;
20701 static int type_init = 0;
20702 if (!type_init) {
20703 PyTypeObject tmp
20704 #endif
20705 = {
20706 PyObject_HEAD_INIT(&PyType_Type)
20707 0, /* Number of items in variable part (ob_size) */
20708 (char *)"swigvarlink", /* Type name (tp_name) */
20709 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
20710 0, /* Itemsize (tp_itemsize) */
20711 0, /* Deallocator (tp_dealloc) */
20712 (printfunc) swig_varlink_print, /* Print (tp_print) */
20713 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
20714 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
20715 0, /* tp_compare */
20716 (reprfunc) swig_varlink_repr, /* tp_repr */
20717 0, /* tp_as_number */
20718 0, /* tp_as_sequence */
20719 0, /* tp_as_mapping */
20720 0, /* tp_hash */
20721 0, /* tp_call */
20722 0, /* tp_str */
20723 0, /* tp_getattro */
20724 0, /* tp_setattro */
20725 0, /* tp_as_buffer */
20726 0, /* tp_flags */
20727 varlink__doc__, /* tp_doc */
20728 #if PY_VERSION_HEX >= 0x02000000
20729 0, /* tp_traverse */
20730 0, /* tp_clear */
20731 #endif
20732 #if PY_VERSION_HEX >= 0x02010000
20733 0, /* tp_richcompare */
20734 0, /* tp_weaklistoffset */
20735 #endif
20736 #if PY_VERSION_HEX >= 0x02020000
20737 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
20738 #endif
20739 #if PY_VERSION_HEX >= 0x02030000
20740 0, /* tp_del */
20741 #endif
20742 #ifdef COUNT_ALLOCS
20743 0,0,0,0 /* tp_alloc -> tp_next */
20744 #endif
20745 };
20746 #if !defined(__cplusplus)
20747 varlink_type = tmp;
20748 type_init = 1;
20749 }
20750 #endif
20751 return &varlink_type;
20752 }
20753
20754 /* Create a variable linking object for use later */
20755 SWIGINTERN PyObject *
20756 SWIG_Python_newvarlink(void) {
20757 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
20758 if (result) {
20759 result->vars = 0;
20760 }
20761 return ((PyObject*) result);
20762 }
20763
20764 SWIGINTERN void
20765 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
20766 swig_varlinkobject *v = (swig_varlinkobject *) p;
20767 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
20768 if (gv) {
20769 size_t size = strlen(name)+1;
20770 gv->name = (char *)malloc(size);
20771 if (gv->name) {
20772 strncpy(gv->name,name,size);
20773 gv->get_attr = get_attr;
20774 gv->set_attr = set_attr;
20775 gv->next = v->vars;
20776 }
20777 }
20778 v->vars = gv;
20779 }
20780
20781 /* -----------------------------------------------------------------------------
20782 * constants/methods manipulation
20783 * ----------------------------------------------------------------------------- */
20784
20785 /* Install Constants */
20786 SWIGINTERN void
20787 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
20788 PyObject *obj = 0;
20789 size_t i;
20790 for (i = 0; constants[i].type; ++i) {
20791 switch(constants[i].type) {
20792 case SWIG_PY_INT:
20793 obj = PyInt_FromLong(constants[i].lvalue);
20794 break;
20795 case SWIG_PY_FLOAT:
20796 obj = PyFloat_FromDouble(constants[i].dvalue);
20797 break;
20798 case SWIG_PY_STRING:
20799 if (constants[i].pvalue) {
20800 obj = PyString_FromString((char *) constants[i].pvalue);
20801 } else {
20802 Py_INCREF(Py_None);
20803 obj = Py_None;
20804 }
20805 break;
20806 case SWIG_PY_POINTER:
20807 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
20808 break;
20809 case SWIG_PY_BINARY:
20810 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
20811 break;
20812 default:
20813 obj = 0;
20814 break;
20815 }
20816 if (obj) {
20817 PyDict_SetItemString(d,constants[i].name,obj);
20818 Py_DECREF(obj);
20819 }
20820 }
20821 }
20822
20823 /* -----------------------------------------------------------------------------*/
20824 /* Fix SwigMethods to carry the callback ptrs when needed */
20825 /* -----------------------------------------------------------------------------*/
20826
20827 SWIGINTERN void
20828 SWIG_Python_FixMethods(PyMethodDef *methods,
20829 swig_const_info *const_table,
20830 swig_type_info **types,
20831 swig_type_info **types_initial) {
20832 size_t i;
20833 for (i = 0; methods[i].ml_name; ++i) {
20834 char *c = methods[i].ml_doc;
20835 if (c && (c = strstr(c, "swig_ptr: "))) {
20836 int j;
20837 swig_const_info *ci = 0;
20838 char *name = c + 10;
20839 for (j = 0; const_table[j].type; ++j) {
20840 if (strncmp(const_table[j].name, name,
20841 strlen(const_table[j].name)) == 0) {
20842 ci = &(const_table[j]);
20843 break;
20844 }
20845 }
20846 if (ci) {
20847 size_t shift = (ci->ptype) - types;
20848 swig_type_info *ty = types_initial[shift];
20849 size_t ldoc = (c - methods[i].ml_doc);
20850 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
20851 char *ndoc = (char*)malloc(ldoc + lptr + 10);
20852 if (ndoc) {
20853 char *buff = ndoc;
20854 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
20855 if (ptr) {
20856 strncpy(buff, methods[i].ml_doc, ldoc);
20857 buff += ldoc;
20858 strncpy(buff, "swig_ptr: ", 10);
20859 buff += 10;
20860 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
20861 methods[i].ml_doc = ndoc;
20862 }
20863 }
20864 }
20865 }
20866 }
20867 }
20868
20869 /* -----------------------------------------------------------------------------*
20870 * Initialize type list
20871 * -----------------------------------------------------------------------------*/
20872
20873 #ifdef __cplusplus
20874 }
20875 #endif
20876
20877 /* -----------------------------------------------------------------------------*
20878 * Partial Init method
20879 * -----------------------------------------------------------------------------*/
20880
20881 #ifdef __cplusplus
20882 extern "C"
20883 #endif
20884 SWIGEXPORT void SWIG_init(void) {
20885 static PyObject *SWIG_globals = 0;
20886 PyObject *m, *d;
20887 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
20888
20889 /* Fix SwigMethods to carry the callback ptrs when needed */
20890 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
20891
20892 m = Py_InitModule((char *) SWIG_name, SwigMethods);
20893 d = PyModule_GetDict(m);
20894
20895 SWIG_InitializeModule(0);
20896 SWIG_InstallConstants(d,swig_const_table);
20897
20898 PyDict_SetItemString(d,"GRID_VALUE_STRING", SWIG_FromCharPtr("string"));
20899 PyDict_SetItemString(d,"GRID_VALUE_BOOL", SWIG_FromCharPtr("bool"));
20900 PyDict_SetItemString(d,"GRID_VALUE_NUMBER", SWIG_FromCharPtr("long"));
20901 PyDict_SetItemString(d,"GRID_VALUE_FLOAT", SWIG_FromCharPtr("double"));
20902 PyDict_SetItemString(d,"GRID_VALUE_CHOICE", SWIG_FromCharPtr("choice"));
20903 PyDict_SetItemString(d,"GRID_VALUE_TEXT", SWIG_FromCharPtr("string"));
20904 PyDict_SetItemString(d,"GRID_VALUE_LONG", SWIG_FromCharPtr("long"));
20905 PyDict_SetItemString(d,"GRID_VALUE_CHOICEINT", SWIG_FromCharPtr("choiceint"));
20906 PyDict_SetItemString(d,"GRID_VALUE_DATETIME", SWIG_FromCharPtr("datetime"));
20907 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
20908 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellCoords",_wrap_GridNoCellCoords_get, _wrap_GridNoCellCoords_set);
20909 SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellRect",_wrap_GridNoCellRect_get, _wrap_GridNoCellRect_set);
20910 {
20911 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_ROWS", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_NUMBER_ROWS)));
20912 }
20913 {
20914 PyDict_SetItemString(d,"GRID_DEFAULT_NUMBER_COLS", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_NUMBER_COLS)));
20915 }
20916 {
20917 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_HEIGHT", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_ROW_HEIGHT)));
20918 }
20919 {
20920 PyDict_SetItemString(d,"GRID_DEFAULT_COL_WIDTH", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_COL_WIDTH)));
20921 }
20922 {
20923 PyDict_SetItemString(d,"GRID_DEFAULT_COL_LABEL_HEIGHT", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
20924 }
20925 {
20926 PyDict_SetItemString(d,"GRID_DEFAULT_ROW_LABEL_WIDTH", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
20927 }
20928 {
20929 PyDict_SetItemString(d,"GRID_LABEL_EDGE_ZONE", SWIG_From_int(static_cast<int >(wxGRID_LABEL_EDGE_ZONE)));
20930 }
20931 {
20932 PyDict_SetItemString(d,"GRID_MIN_ROW_HEIGHT", SWIG_From_int(static_cast<int >(wxGRID_MIN_ROW_HEIGHT)));
20933 }
20934 {
20935 PyDict_SetItemString(d,"GRID_MIN_COL_WIDTH", SWIG_From_int(static_cast<int >(wxGRID_MIN_COL_WIDTH)));
20936 }
20937 {
20938 PyDict_SetItemString(d,"GRID_DEFAULT_SCROLLBAR_WIDTH", SWIG_From_int(static_cast<int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
20939 }
20940 {
20941 PyDict_SetItemString(d,"GridCellAttr_Any", SWIG_From_int(static_cast<int >(wxGridCellAttr::Any)));
20942 }
20943 {
20944 PyDict_SetItemString(d,"GridCellAttr_Default", SWIG_From_int(static_cast<int >(wxGridCellAttr::Default)));
20945 }
20946 {
20947 PyDict_SetItemString(d,"GridCellAttr_Cell", SWIG_From_int(static_cast<int >(wxGridCellAttr::Cell)));
20948 }
20949 {
20950 PyDict_SetItemString(d,"GridCellAttr_Row", SWIG_From_int(static_cast<int >(wxGridCellAttr::Row)));
20951 }
20952 {
20953 PyDict_SetItemString(d,"GridCellAttr_Col", SWIG_From_int(static_cast<int >(wxGridCellAttr::Col)));
20954 }
20955 {
20956 PyDict_SetItemString(d,"GridCellAttr_Merged", SWIG_From_int(static_cast<int >(wxGridCellAttr::Merged)));
20957 }
20958 {
20959 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_GET_VALUES", SWIG_From_int(static_cast<int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
20960 }
20961 {
20962 PyDict_SetItemString(d,"GRIDTABLE_REQUEST_VIEW_SEND_VALUES", SWIG_From_int(static_cast<int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
20963 }
20964 {
20965 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_INSERTED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
20966 }
20967 {
20968 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_APPENDED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
20969 }
20970 {
20971 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_ROWS_DELETED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
20972 }
20973 {
20974 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_INSERTED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
20975 }
20976 {
20977 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_APPENDED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
20978 }
20979 {
20980 PyDict_SetItemString(d,"GRIDTABLE_NOTIFY_COLS_DELETED", SWIG_From_int(static_cast<int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
20981 }
20982 {
20983 PyDict_SetItemString(d,"Grid_wxGridSelectCells", SWIG_From_int(static_cast<int >(wxGrid::wxGridSelectCells)));
20984 }
20985 {
20986 PyDict_SetItemString(d,"Grid_wxGridSelectRows", SWIG_From_int(static_cast<int >(wxGrid::wxGridSelectRows)));
20987 }
20988 {
20989 PyDict_SetItemString(d,"Grid_wxGridSelectColumns", SWIG_From_int(static_cast<int >(wxGrid::wxGridSelectColumns)));
20990 }
20991 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
20992 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
20993 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
20994 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
20995 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
20996 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
20997 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
20998 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
20999 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
21000 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
21001 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
21002 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
21003 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
21004 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
21005 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
21006 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
21007 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
21008
21009
21010 }
21011
wxWidgets (Impactor)